El lenguaje ensamblador, o assembler (en inglés assembly language y la abreviación asm) es un lenguaje de programación de bajo nivel.
Consiste en un conjunto de mnemónicos que representan instrucciones básicas para los computadores, microprocesadores, microcontroladores y otros circuitos integrados programables.
Implementa una representación simbólica de los códigos de máquina binarios y otras constantes necesarias para programar una arquitectura de procesador y constituye la representación más directa del código máquina específico para cada arquitectura legible por un programador.
Cada arquitectura de procesador tiene su propio lenguaje ensamblador que usualmente es definida por el fabricante de hardware, y está basada en los mnemónicos que simbolizan los pasos de procesamiento (las instrucciones), los registros del procesador, las posiciones de memoria y otras características del lenguaje. Un lenguaje ensamblador es por lo tanto específico de cierta arquitectura de computador física (o virtual).
Fue usado principalmente en los inicios del desarrollo de software, cuando aún no se contaba con potentes lenguajes de alto nivel y los recursos eran limitados. Actualmente se utiliza con frecuencia en ambientes académicos y de investigación, especialmente cuando se requiere la manipulación directa de hardware, alto rendimiento, o un uso de recursos controlado y reducido.
También es utilizado en el desarrollo de controladores de dispositivo (en inglés, device drivers) y en el desarrollo de sistemas operativos, debido a la necesidad del acceso directo a las instrucciones de la máquina. Muchos dispositivos programables (como los microcontroladores) aún cuentan con el ensamblador como la única manera de ser manipulados.
CARACTERÍSTICAS
- El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido ya que su estructura se acerca al lenguaje máquina, es decir, es un lenguaje de bajo nivel.
- Difícilmente portable, es decir, un código escrito para un microprocesador, puede necesitar ser modificado, para poder ser usado en otra máquina distinta. Al cambiar a una máquina con arquitectura diferente, generalmente es necesario reescribirlo completamente.
- Los programas hechos por un programador experto en lenguaje ensamblador son generalmente mucho más rápidos y consumen menos recursos del sistema (memoria RAM y ROM) que el programa equivalente compilado desde un lenguaje de alto nivel. Al programar cuidadosamente en lenguaje ensamblador se pueden crear programas que se ejecutan más rápidamente y ocupan menos espacio que con lenguajes de alto nivel.
- Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por un microprocesador por lo que se pueden crear segmentos de código difíciles y/o muy ineficientes de programar en un lenguaje de alto nivel, ya que, entre otras cosas, en el lenguaje ensamblador se dispone de instrucciones del CPU que generalmente no están disponibles en los lenguajes de alto nivel.
- También se puede controlar el tiempo en que tarda una rutina en ejecutarse, e impedir que se interrumpa durante su ejecución.
VENTAJAS - DESVENTAJAS
VENTAJAS
- Como trabaja directamente con el microprocesador al ejecutar un programa, pues como este lenguaje es el mas cercano a la máquina la computadora lo procesa mas rápido.
- Eficiencia de tamaño: Un programa en ensamblador no ocupa mucho espacio en memoria porque no tiene que cargan librerías y demás como son los lenguajes de alto nivel
- Flexibilidad: Es flexible porque todo lo que puede hacerse con una máquina, puede hacerse en el lenguaje ensamblador de esta máquina; los lenguajes de alto nivel tienen en una u otra forma limitantes para explotar al máximo los recursos de la máquina. O sea que en lenguaje ensamblador se pueden hacer tareas especificas que en un lenguaje de alto nivel no se pueden llevar acabo porque tienen ciertas limitantes que no se lo permite
DESVENTAJAS
- Tiempo de programación: Como es un lenguaje de bajo nivel requiere más instrucciones para realizar el mismo proceso, en comparación con un lenguaje de alto nivel. Por otro lado, requiere de más cuidado por parte del programador, pues es propenso a que los errores de lógica se reflejen más fuertemente en la ejecución.
- Programas fuente grandes: Por las mismas razones que aumenta el tiempo, crecen los programas fuentes; simplemente requerimos más instrucciones primitivas para describir procesos equivalentes. Esto es una desventaja porque dificulta el mantenimiento de los programas, y nuevamente reduce la productividad de los programadores.
- Peligro de afectar recursos inesperadamente: Que todo error que podamos cometer, o todo riesgo que podamos tener, podemos afectar los recursos de la maquina, programar en este lenguaje lo más común que pueda pasar es que la máquina se bloquee o se reinicie. Porque con este lenguaje es perfectamente posible (y sencillo) realizar secuencias de instrucciones inválidas, que normalmente no aparecen al usar un lenguaje de alto nivel.
- Falta de portabilidad: Porque para cada máquina existe un lenguaje ensamblador; por ello, evidentemente no es una selección apropiada de lenguaje cuando deseamos codificar en una máquina y luego llevar los programas a otros sistemas operativos o modelos de computadoras.
INSTRUCCIONES - REGISTROS
INSTRUCCIONES
ARITMÉTICAS: Se usa para la realizar operaciones aritméticas sobre los operandos.
SUB: Resta el operando fuente del destino.
DIV: El divisor puede ser un byte o palabra y es el operando que se la da instrucción.
IDIV: Consiste basicamente en lo mismo que la instrucción DIV, solo que esta ultima realiza la operación con signo.
MUL: El ensambldor asume que el multiplicando sera del mismo tamaño que el del multiplicador, por lo tanto multiplica el valor almacenado en el registro que se le da como operando por el que se encuentre contenido en AH si el multiplicador es de 8 bits o por AX si el multiplicador es de 16 bits.
LÓGICAS: Son utilizadas para realizar operaciones lógicas sobre los operandos.
AND: Con esta instrucción se lleva a cabo la operación "y" lógica de los dos operandos.
OR: Lleva a cabo, bit por bit, la disyunción inclusiva lógica de los dos operandos .
XOR: Su función efectuar bit por bit la disyunción exclusiva lógica de los dos operandos.
TEST: Realiza una conjunción, bit por bit, de los operandos, pero a diferencia de AND esta instrucción no coloca el resultado en el operando destino, solo tiene efecto sobre el estado de las banderas.
NEG: Esta instrucción genera el complemento a 2 del operando destino y lo almacena en este mismo operando.
NOT: Lleva a cabo la negación bit por bit del operando destino
TRANSFERENCIA: Son utilizadas para mover los contenidos de los operandos. Cada instrucción se puede usar con diferentes modos de direccionamiento.
MOV: Transferencia de datos entre celdas de memoria, registros y acumulador.
MOVS: Mover cadenas de bytes o palabras desde la fuente, direccionada por SI, hasta el destino direccionado por DI.
CARGA: Son instrucciones específicas de los registros. Son usadas para cargar en algún registro bytes o cadenas de bytes.
LODS: Toma la cadena que se encuentre en la dirección especificada por SI, la carga al registro AL (o AX) y suma o resta 1 (segun el estado de DF) a SI si la transferencia es de bytes o 2 si la transferencia es de palabras.
LAHF: Esta instrucción es útil para verificar el estado de las banderas durante la ejecución de nuestro programa.
LDS: El operando fuente debe ser una palabra doble en memoria. La palabra asociada con la dirección mas grande es transferida a DS, o sea que se toma como la dirección del segmento. La palabra asociada con la dirección menor es la dirección del desplazamiento y se deposita en el registro señalado como destino.
LEA: El operando fuente debe estar ubicado en memoria, y se coloca su desplazamiento en el registro índice o apuntador especificado en destino.
LES: El operando fuente debe ser un operando en memoria de palabra doble. El contenido de la palabra con la dirección mayor se interpreta como la dirección del segmento y se coloca en ES. La palabra con la dirección menor es la dirección del desplazamiento y se coloca en el registro especificado en el parámetro destino.
PILA: Estas instruciones permiten el uso de la pila para almacenar y extraer datos.
POP: Esta instrucción transfiere el último valor almacenado en la pila al operando destino, después incrementa en dos el registro SP.
POPF: Este comando transfiere bits de la palabra almacenada en la parte superior de la pila hacia el registro de banderas.
PUSH: La instrucción PUSH decrementa en dos el valor de SP y luego transfiere el contenido del operando fuente a la nueva dirección resultante en el registro recién modificado.
PUSHF: Decrementa en 2 el valor del registro SP y luego se transfiere el contenido del registro de banderas a la pila, en la dirección indicada por SP.
POPF: Este comando transfiere bits de la palabra almacenada en la parte superior de la pila hacia el registro de banderas.
PUSH: La instrucción PUSH decrementa en dos el valor de SP y luego transfiere el contenido del operando fuente a la nueva dirección resultante en el registro recién modificado.
PUSHF: Decrementa en 2 el valor del registro SP y luego se transfiere el contenido del registro de banderas a la pila, en la dirección indicada por SP.
REGISTROS
Registros de uso generalAX: Acumulador (AL:AH)
BX: Registro base (BL:BH)
CX: Registro contador (CL:CH)
DX: Registro de datos (DL:DH)
Registros de segmento (Solo se pueden usar para los usos mencionados a excepción de ES)
DS: Registro del segmento de datos
ES: Registro del segmento extra
SS: Registro del segmento de pila
CS: Registro del segmento de código
Registros punteros (También pueden tener uso general)
BP: Registro de apuntadores base
SI: Registro índice fuente
DI: Registro ìndice destino
Registros especiales (Solo se pueden usar para los usos mencionados)
SP: Registro apuntador de la pila
IP: Registro apuntador de la siguiente instrucción
F: Registro de banderas (8 bits)
Bits del registro de banderas
Overflow
NV (Apagado): No hay desbordamiento
OV (Encendido): Si lo hay
Direction
UP: Hacia adelante
DN: Hacia atras
Interrupts
DI: Desactivadas
EI: Activadas
Sign
PL: Positivo
NG: Negativo
Zero
NZ: No es cero
ZR: Si lo es
Auxilary carry
NA: No hay acarreo auxiliar
AC: Hay acarreo auxiliar
Parity
PO: Impar
PE: Paridad par
Carry
NC: No hay acarreo
CY: Si lo hay
Es un ejemplo del programa clásico Hola mundo escrito para la arquitectura de procesador x86 (bajo el sistema operativo DOS).
; ---------------------------------------------
; Programa que imprime un string en la pantalla
; ---------------------------------------------
.model small ; modelo de memoria
.stack ; segmento del stack
.data ; segmento de datos
Cadena1 DB 'Hola Mundo.$' ; string a imprimir (finalizado en $)
.code ; segmento del código
; ---------------------------------------------
; Inicio del programa
; ---------------------------------------------
programa:
; ----------------------------------------------------------------------------------------------------
; inicia el segmento de datos
; ----------------------------------------------------------------------------------------------------
MOV AX, @data ; carga en AX la dirección del segmento de datos
MOV DS, AX ; mueve la dirección al registro de segmento por medio de AX
; ----------------------------------------------------------------------------------------------------
; Imprime un string en pantalla
; ----------------------------------------------------------------------------------------------------
MOV DX, offset Cadena1 ; mueve a DX la dirección del string a imprimir
MOV AH, 9 ; AH = código para indicar al MS DOS que imprima en la pantalla, el string en DS:DX
INT 21h ; llamada al MS DOS para ejecutar la función (en este caso especificada en AH)
; ----------------------------------------------------------------------------------------------------
; Finaliza el programa
; ----------------------------------------------------------------------------------------------------
INT 20h ; llamada al MS DOS para finalizar el programa
end programa
RESUMEN
El Lenguaje Ensamblador proporciona las herramientas para tomar control sobre todo lo que la computadora realiza físicamente.
Proporciona un control absoluto sobre la PC. Los programas en ensamblador son rápidos y compactos. Una instrucción mal interpretada o un error de lógica se vuele mas compleja.
Es un tipo de lenguaje de bajo nivel utilizado para escribir programas informáticos, y constituye la representación más directa del código máquina específico para cada arquitectura de computadoras legible por un programador.
SUMMARY
Assembler Language provides the tools to take control over everything that computer physically performed.
It provides complete control over the PC. Assembler programs are fast and compact. A misunderstood instruction or a logic error will fly more complex.
It is a type of low-level language used to write computer programs, and is the most direct representation of specific machine code for each computer architecture readable by a programmer.
El lenguaje ensamblador a pesar de ser mas rápido de cualquier otro lenguaje es también el mas complejo por eso es utilizado para complementar los limitantes de los lenguajes de programación de alto nivel. Pero existen ramas donde es imprescindible el uso de lenguaje ensamblador como lo es la electrónica donde los recursos de los aparatos son limitados y es necesario utilizar lenguaje ensamblador.
GLOSARIO DE TÉRMINOS
ASM: assembly language (Lenguaje emsamblador)
BIBLIOGRAFÍA O LINKOGRAFÍA
- https://es.wikipedia.org/wiki/Lenguaje_ensamblador
- http://www.monografias.com/trabajos14/lenguaje-ensamblador/lenguaje-ensamblador.shtml#ve
- https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_lenguaje_ensamblador/Primeros_conceptos#Registros_de_la_CPU
- http://html.rincondelvago.com/ensamblador.html
Video relacionado al tema
