lenguaje ensamblador

Un programa ensamblador crea código objeto traduciendo combinaciones de mnemónicos y sintaxis para operaciones y modos de direccionamiento a sus equivalentes numéricos. Esta representación normalmente incluye un código de operación (" opcode ") así como otros bits de control y datos. El ensamblador también calcula expresiones constantes y resuelve nombres simbólicos para ubicaciones de memoria y otras entidades. ^{[ 21 ]} El uso de referencias simbólicas es una característica clave de los ensambladores, que ahorra cálculos tediosos y actualizaciones manuales de direcciones después de modificaciones del programa. La mayoría de los ensambladores también incluyen funciones de macro para realizar sustitución textual, por ejemplo, para generar secuencias cortas comunes de instrucciones como inline , en lugar de subrutinas llamadas .

Algunos ensambladores también pueden realizar optimizaciones sencillas específicas del conjunto de instrucciones . Un ejemplo concreto son los omnipresentes ensambladores x86 de diversos proveedores. Mediante el dimensionamiento de saltos , ^{[ 21 ]} la mayoría de ellos pueden realizar reemplazos de instrucciones de salto (saltos largos reemplazados por saltos cortos o relativos) en cualquier número de pasadas, según se solicite. Otros incluso pueden realizar una simple reorganización o inserción de instrucciones, como algunos ensambladores para arquitecturas RISC que ayudan a optimizar una planificación de instrucciones adecuada para aprovechar la tubería de la CPU de la forma más eficiente posible. ^{[ 22 ]}

Los ensambladores existen desde la década de 1950, como primer paso previo al lenguaje máquina y a los lenguajes de programación de alto nivel como Fortran , Algol , COBOL y Lisp . También han existido diversas clases de traductores y generadores de código semiautomáticos con propiedades similares tanto al lenguaje ensamblador como a los lenguajes de alto nivel, siendo Speedcode quizás uno de los ejemplos más conocidos.

Puede haber varios ensambladores con sintaxis diferente para una CPU o arquitectura de conjunto de instrucciones en particular . Por ejemplo, una instrucción para agregar datos de memoria a un registro en un procesador de la familia x86 podría ser , en la sintaxisadd eax,[ebx] original de Intel , mientras que esta se escribiría en la sintaxis AT&T utilizada por el ensamblador GNU . A pesar de las diferentes apariencias, las diferentes formas sintácticas generalmente generan el mismo código máquina numérico . Un solo ensamblador también puede tener diferentes modos para admitir variaciones en las formas sintácticas, así como sus interpretaciones semánticas exactas (como la sintaxis FASM , la sintaxis TASM , el modo ideal, etc., en el caso especial de la programación en ensamblador x86 ).addl (%ebx),%eax

S1 B DELANTERO ... EQUIPO DE ADELANTE * ... BKWD EQU * ... S2 B BKWD

Un programa escrito en lenguaje ensamblador consta de una serie de instrucciones de procesador mnemotécnicas y meta-instrucciones (conocidas como operaciones declarativas, directivas, pseudo-instrucciones, pseudo-operaciones y pseudo-ops), comentarios y datos. Las instrucciones en lenguaje ensamblador suelen constar de un código de operación mnemotécnico seguido de un operando , que puede ser una lista de datos, argumentos o parámetros. ^{[ 25 ]} Algunas instrucciones pueden ser "implícitas", lo que significa que los datos sobre los que opera la instrucción están definidos implícitamente por la propia instrucción; dicha instrucción no requiere un operando. La instrucción resultante es traducida por un ensamblador a instrucciones en lenguaje máquina que pueden cargarse en memoria y ejecutarse.

Por ejemplo, la siguiente instrucción le indica a un procesador x86 / IA-32 que mueva un valor inmediato de 8 bits a un registro . El código binario de esta instrucción es 10110 seguido de un identificador de 3 bits que indica qué registro usar. El identificador del registro AL es 000, por lo que el siguiente código máquina carga el registro AL con los datos 01100001. ^{[ 25 ]}

10110000 01100001

Este código informático binario se puede hacer más legible para los humanos expresándolo en hexadecimal de la siguiente manera.

B0 61

Aquí, B0significa "Mover una copia del siguiente valor a AL ", y 61es una representación hexadecimal del valor 01100001, que es 97 en decimal . El lenguaje ensamblador para la familia 8086 proporciona el mnemónico MOV (abreviatura de move ) para instrucciones como esta, por lo que el código máquina anterior se puede escribir de la siguiente manera en lenguaje ensamblador, con un comentario explicativo si es necesario, después del punto y coma. Esto es mucho más fácil de leer y recordar.

MOV AL , 61h ; Cargar AL con 97 decimal (61 hexadecimal)

En algunos lenguajes ensamblador (incluido este), el mismo mnemónico, como MOV, puede usarse para una familia de instrucciones relacionadas para cargar, copiar y mover datos, ya sean valores inmediatos, valores en registros o ubicaciones de memoria a las que apuntan valores en registros o direcciones directas incrustadas en la instrucción. Otros ensambladores pueden usar mnemónicos de código de operación separados, como L para "mover memoria a registro", ST para "mover registro a memoria", LR para "mover registro a registro", MVI para "mover operando inmediato a memoria", etc.

Si se utiliza el mismo mnemónico para diferentes instrucciones, significa que el mnemónico corresponde a varios códigos de instrucción binarios diferentes, excluyendo los datos (por ejemplo, 61hen este ejemplo), dependiendo de los operandos que siguen al mnemónico. Por ejemplo, para las CPU x86/IA-32, la sintaxis del lenguaje ensamblador de Intel MOV AL, AHrepresenta una instrucción que mueve el contenido del registro AH al registro AL . La forma hexadecimal ^{[ nb 3 ]} de esta instrucción es:

88 E0

El primer byte, 88h, identifica un movimiento entre un registro del tamaño de un byte y otro registro o memoria, y el segundo byte, E0h, está codificado (con tres campos de bits) para especificar que ambos operandos son registros, la fuente es AH y el destino es AL .

En un caso como este, donde el mismo mnemónico puede representar más de una instrucción binaria, el ensamblador determina qué instrucción generar examinando los operandos. En el primer ejemplo, el operando 61hes una constante numérica hexadecimal válida y no un nombre de registro válido, por lo que solo la B0instrucción es aplicable. En el segundo ejemplo, el operando AHes un nombre de registro válido y no una constante numérica válida (hexadecimal, decimal, octal o binaria), por lo que solo la 88instrucción es aplicable.

Los lenguajes ensamblador siempre se diseñan de manera que esta falta de ambigüedad se imponga universalmente mediante su sintaxis. Por ejemplo, en el lenguaje ensamblador Intel x86, una constante hexadecimal debe comenzar con un dígito numérico, de modo que el número hexadecimal 'A' (equivalente a diez en decimal) se escribiría como 0Aho 0AH, no AH, específicamente para que no pueda parecer el nombre del registro AH . (La misma regla también evita la ambigüedad con los nombres de los registros BH , CH y DH , así como con cualquier símbolo definido por el usuario que termine con la letra H y que contenga únicamente caracteres que sean dígitos hexadecimales, como la palabra "BEACH").

Volviendo al ejemplo original, mientras que el código de operación x86 10110000 ( B0) copia un valor de 8 bits en el registro AL , 10110001 ( B1) lo mueve a CL y 10110010 ( B2) lo hace a DL . A continuación se muestran ejemplos en lenguaje ensamblador. ^{[ 25 ]}

MOV AL , 1h ; Cargar AL con valor inmediato 1 MOV CL , 2h ; Cargar CL con valor inmediato 2 MOV DL , 3h ; Cargar DL con valor inmediato 3

La sintaxis de MOV también puede ser más compleja, como muestran los siguientes ejemplos. ^{[ 26 ]}

MOV EAX , [ EBX ] ; Mueve los 4 bytes de memoria en la dirección contenida en EBX a EAX. MOV [ ESI + EAX ], CL ; Mueve el contenido de CL al byte en la dirección ESI+EAX. MOV DS , DX ; Mueve el contenido de DX al registro de segmento DS.

En cada caso, el mnemónico MOV se traduce directamente a uno de los códigos de operación 88-8C, 8E, A0-A3, B0-BF, C6 o C7 mediante un ensamblador, y el programador normalmente no tiene que saber ni recordar cuál. ^{[ 25 ]}

Un ensamblador transforma el lenguaje ensamblador en código máquina, y un desensamblador puede realizar la transformación inversa, al menos parcialmente . A diferencia de los lenguajes de alto nivel , existe una correspondencia uno a uno entre muchas instrucciones simples de ensamblador y las instrucciones del lenguaje máquina. Sin embargo, en algunos casos, un ensamblador puede proporcionar pseudoinstrucciones (esencialmente macros) que se expanden en varias instrucciones del lenguaje máquina para proporcionar funcionalidades de uso común. Por ejemplo, para una máquina que carece de la instrucción "saltar si es mayor o igual", un ensamblador puede proporcionar una pseudoinstrucción que se expanda a las instrucciones de la máquina "establecer si es menor que" y "saltar si es cero (en el resultado de la instrucción establecer)". La mayoría de los ensambladores completos también proporcionan un lenguaje de macros avanzado (que se describe más adelante) que utilizan los proveedores y programadores para generar secuencias de código y datos más complejas. Dado que la información sobre pseudoinstrucciones y macros definidas en el entorno del ensamblador no está presente en el programa objeto, un desensamblador no puede reconstruir las invocaciones de macros y pseudoinstrucciones, sino que solo puede desensamblar las instrucciones de máquina reales que el ensamblador generó a partir de esas entidades abstractas del lenguaje ensamblador. Del mismo modo, dado que el ensamblador ignora los comentarios en el archivo fuente del lenguaje ensamblador y estos no tienen ningún efecto en el código objeto que genera, un desensamblador siempre es completamente incapaz de recuperar los comentarios del código fuente.

Cada arquitectura informática tiene su propio lenguaje máquina. Las computadoras difieren en la cantidad y el tipo de operaciones que admiten, en el tamaño y la cantidad de registros, y en la representación de los datos almacenados. Si bien la mayoría de las computadoras de propósito general pueden realizar esencialmente la misma funcionalidad, la forma en que lo hacen difiere; los lenguajes ensamblador correspondientes reflejan estas diferencias.

Para un mismo conjunto de instrucciones, pueden existir varios conjuntos de mnemónicos o sintaxis de lenguaje ensamblador, que normalmente se implementan en diferentes programas ensambladores. En estos casos, el más común suele ser el proporcionado por el fabricante de la CPU y utilizado en su documentación.

Dos ejemplos de CPU con conjuntos de mnemónicos diferentes son la familia Intel 8080 y la Intel 8086/8088. Dado que Intel reclamó los derechos de autor de sus mnemónicos en lenguaje ensamblador (al menos en cada página de su documentación publicada en las décadas de 1970 y principios de 1980), algunas empresas que producían de forma independiente CPU compatibles con los conjuntos de instrucciones de Intel inventaron sus propios mnemónicos. La CPU Zilog Z80 , una mejora de la Intel 8080A , admite todas las instrucciones de la 8080A y muchas más; Zilog inventó un lenguaje ensamblador completamente nuevo, no solo para las nuevas instrucciones , sino también para todas las instrucciones de la 8080A. Por ejemplo, mientras que Intel utiliza los mnemónicos MOV , MVI , LDA , STA , LXI , LDAX , STAX , LHLD y SHLD para diversas instrucciones de transferencia de datos, el lenguaje ensamblador Z80 utiliza el mnemónico LD para todas ellas. Un caso similar son las CPU NEC V20 y V30 , copias mejoradas de las Intel 8086 y 8088, respectivamente. Al igual que Zilog con la Z80, NEC inventó nuevos mnemónicos para todas las instrucciones de las 8086 y 8088, para evitar acusaciones de infracción de los derechos de autor de Intel. (Es cuestionable si tales derechos de autor pueden ser válidos, y compañías de CPU posteriores como AMD ^{[ nb 4 ]} y Cyrix republicaron los mnemónicos de instrucciones x86/IA-32 de Intel exactamente sin permiso ni sanción legal). Es dudoso que en la práctica muchas personas que programaron las V20 y V30 realmente escribieron en el lenguaje ensamblador de NEC en lugar del de Intel; dado que dos lenguajes ensamblador para la misma arquitectura de conjunto de instrucciones son isomorfos (algo así como el inglés y el Pig Latin ), no hay obligación de usar el lenguaje ensamblador publicado por un fabricante con los productos de ese fabricante.

"¡Hola, mundo!" se puede imprimir usando lenguaje ensamblador de 32 bits para un procesador x86 con poca ayuda del sistema operativo. "Call outchr" llama a un mecanismo que imprime un carácter en AL en la consola. Una cadena de caracteres distinta de cero debe terminar con un byte cero.

Hola: mov esi , msg ; dirección de la cadena en ESI cld ; Establecer la dirección para incrementar ESI lodsb ; Cargar el primer carácter en AL, inc ESI chrlp: call outchr ; Imprimir el carácter en AL lodsb ; Cargar el siguiente carácter en AL, inc ESI or al , al ; ¿Es un terminador cero? bne chrlp ; Si no, continuar ret ; Regresar a la función que la llamómsg: db '¡Hola, mundo!' , 0xa , 0x0 ; cadena que se imprimirá

En lenguaje ensamblador de 32 bits para Linux en un procesador x86 , "¡Hola, mundo!" se imprimiría mediante una sola llamada al sistema operativo:

sección .texto ; inicio del segmento de código global _start ; declarar _start para que sea visible en el archivo objeto generado _start: mov edx , len ; longitud de la cadena, tercer argumento de write() mov ecx , msg ; dirección de la cadena, segundo argumento de write() mov ebx , 1 ; descriptor de archivo (salida estándar), primer argumento de write() mov eax , 4 ; número de llamada al sistema para write() int 0x80 ; trampa de llamada al sistema mov ebx , 0 ; código de salida, primer argumento de exit() mov eax , 1 ; número de llamada al sistema para exit() int 0x80 ; trampa de llamada al sistemasección .data ; inicio del segmento de datos msg db '¡Hola, mundo!' , 0xa ; cadena a imprimir len equ $ - msg ; longitud de esa cadena como una constante calculada en tiempo de ensamblaje

Existe una gran diversidad en la forma en que los autores de lenguajes ensambladores categorizan las instrucciones y en la nomenclatura que utilizan. En particular, algunos describen cualquier cosa que no sea un mnemónico de máquina o un mnemónico extendido como una pseudooperación (pseudo-op). Un lenguaje ensamblador típico consta de 3 tipos de instrucciones que se utilizan para definir las operaciones del programa:

• Mnemotecnia de códigos de operación
• Definiciones de datos
• Directivas de la asamblea

Muchos ensambladores admiten macros predefinidas , y otros admiten macros definidas por el programador (y redefinibles repetidamente) que implican secuencias de líneas de texto en las que se insertan variables y constantes. La definición de la macro suele ser ^{[ nb 5 ]} una combinación de instrucciones de ensamblador, por ejemplo, directivas, instrucciones de máquina simbólicas y plantillas para instrucciones de ensamblador. Esta secuencia de líneas de texto puede incluir códigos de operación o directivas. Una vez definida una macro, su nombre puede utilizarse en lugar de un mnemónico. Cuando el ensamblador procesa dicha instrucción, la reemplaza con las líneas de texto asociadas a esa macro y, a continuación, las procesa como si existieran en el archivo de código fuente (incluida, en algunos ensambladores, la expansión de cualquier macro existente en el texto de reemplazo). Las macros en este sentido se remontan a los autocodificadores de IBM de la década de 1950. ^{[ 31 ]}

Los ensambladores de macros suelen tener directivas para, por ejemplo, definir macros, definir variables, asignar a las variables el resultado de una expresión aritmética, lógica o de cadena, iterar y generar código condicionalmente. Algunas de estas directivas pueden estar restringidas al uso dentro de una definición de macro, por ejemplo, MEXIT en HLASM , mientras que otras pueden estar permitidas en código abierto (fuera de las definiciones de macros), por ejemplo, AIF y COPY en HLASM.