Lenguaje ensamblador

Lenguaje de máquina del Intel 8088. El código de máquina se resalta en rojo, el equivalente en lenguaje assembler en magenta, y las direcciones de memoria donde se encuentra el código, en azul.

El lenguaje ensamblador 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.

Fue usado principalmente en los inicios del desarrollo de software, cuando aun no se contaba con los potentes lenguajes de alto nivel. Actualmente se utiliza con frecuencia en ambientes académicos y de investigación, especialmente cuando se requiere la manipulación directa de hardware, se pretenden altos rendimientos o un uso de recursos controlado y reducido.

Muchos dispositivos programables (como los microcontroladores) aun 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 directamente por un ser humano ya que su estructura se acerca mas bien al lenguaje máquina, es decir, lenguaje de bajo nivel.
• El lenguaje ensamblador es difícilmente portable, es decir, un código escrito para un microprocesador en particular necesita ser modificado muchas veces en su totalidad para poder ser usado en otro microprocesador.
• Los programas hechos en lenguaje ensamblador son generalmente más rápidos y consumen menos recursos del sistema (memoria RAM y ROM). 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 de programar en un lenguaje de alto nivel.

Ensambladores

Un ensamblador (assembler en inglés) es un programa que crea código objeto traduciendo instrucciones nemónicas de un programa fuente escrito en ensamblador a códigos ejecutables e interpretando los nombres simbólicos para direcciones de memoria y otras entidades (ensamblado). El uso de referencias simbólicas es una característica básica del lenguaje ensamblador, evitando tediosos cálculos y direccionamiento manual después de cada modificación del programa. La mayoría de los ensambladores también incluyen facilidades para crear macros, a fin de generar series de instrucciones cortas que se ejecutan en tiempo real, en lugar de utilizar subrutinas.​

Los ensambladores son por lo general más fáciles de programar que los compiladores de lenguajes de alto nivel, y han estado disponibles desde la década de 1950. Los ensambladores modernos, especialmente para arquitecturas basadas en RISC, como por ejemplo MIPS, SPARC y PA-RISC optimizan las instrucciones para explotar al máximo la eficiencia de segmentación​ de la CPU.

Los ensambladores avanzados ofrecen posibilidades de abstracción que incluyen:

• Control avanzado de estructuras.
• Procedimientos de alto nivel, declaración de funciones.
• Tipos de datos que incluyen estructuras, registros, uniones, clases y conjuntos.
• Sofisticado procesamiento de macros.

Lenguaje

Un programa escrito en lenguaje ensamblador consiste en una serie de instrucciones que corresponden al flujo de órdenes ejecutables que pueden ser cargadas en la memoria de un sistema basado en microprocesador.

Por ejemplo, un procesador x86 puede ejecutar la siguiente instrucción binaria como se expresa en código de máquina:

• Binario: 10110000 01100001 (Hexadecimal: 0xb061)

La representación equivalente en lenguaje ensamblador es más fácil de recordar:

• MOV al, 061h

Esta instrucción significa:

• Asigna el valor hexadecimal 61 (97 decimal) al registro "al".

El mnemónico "mov" es un código de operación u "opcode", elegido por los diseñadores de la colección de instrucciones para abreviar "move" (mover, pero en el sentido de copiar valores de un sitio a otro). El opcode es seguido por una lista de argumentos o parámetros, completando una instrucción de ensamblador típica.

La transformación del lenguaje ensamblador en código máquina la realiza un programa Ensamblador, y la traducción inversa la puede efectuar un desensamblador. A diferencia de los lenguajes de alto nivel, aquí hay usualmente una correspondencia 1 a 1 entre las instrucciones simples del ensamblador y el lenguaje de máquina. Sin embargo, en algunos casos, un ensamblador puede proveer "pseudo instrucciones" que se expanden en un código de máquina más extenso a fin de proveer la funcionalidad necesaria. Por ejemplo, para un código máquina condicional como "si X mayor o igual que" , un ensamblador puede utilizar una pseudoinstrucción al grupo "haga si menor que" , y "si = 0" sobre el resultado de la condición anterior. Los Ensambladores más completos también proveen un rico lenguaje de macros que se utiliza para generar código más complejo y secuencias de datos.

El uso del ensamblador no resuelve definitivamente el problema de cómo programar un sistema basado en microprocesador de modo sencillo ya que para hacer un uso eficiente del mismo, hay que conocer a fondo el microprocesador, los registros de trabajo de que dispone, la estructura de la memoria, y muchas cosas más referentes a su estructura básica de funcionamiento.

Cada arquitectura de microprocesadores tiene su propio lenguaje de máquina, y en consecuencia su propio lenguaje ensamblador ya que este se encuentra muy ligado al la estructura del hardware para el cual se programa. Los microprocesadores difieren en el tipo y número de operaciones que soportan; también pueden tener diferente cantidad de registros, y distinta representación de los tipos de datos en memoria. Aunque la mayoría de los microprocesadores son capaces de cumplir esencialmente las mismas funciones, la forma en que lo hacen difiere y los respectivos lenguajes ensamblador reflejan tal diferencia.

Pueden existir múltiples conjuntos de mnemónicos o sintáxis de lenguaje ensamblador para un mismo conjunto de instrucciones, instanciados típicamente en diferentes programas en ensamblador. En estos casos, la alternativa más popular es la provista por los fabricantes, y usada en los manuales del programa.

Código máquina

El código máquina, o lenguaje de máquina, está formado por instrucciones sencillas, que -dependiendo de la estructura del procesador- pueden especificar:

• Registros específicos para operaciones aritméticas, direccionamiento o control de funciones.
• Posiciones de memoria específicas (offset).
• Modos de direccionamiento usados para interpretar operandos.

Las operaciones más complejas se realizan combinando estas instrucciones sencillas, que pueden ser ejecutadas secuencialmente o mediante instrucciones de control de flujo.

Las operaciones disponibles en la mayoría de los conjuntos de instrucciones incluye:

• mover
  • llenar un registro con un valor constante
  • mover datos de una posición de memoria a un registro o viceversa
  • escribir y leer datos de dispositivos
• computar
  • sumar, restar, multiplicar o dividir los valores de dos registros, colocando el resultado en uno de ellos o en otro registro
  • realizar operaciones binarias, incluyendo operaciones lógicas (AND/OR/XOR/NOT)
  • comparar valores entre registros (mayor, menor, igual)
• afectar el flujo del programa
  • saltar a otra posición en el programa y ejecutar instrucciones allí
  • saltar si se cumplen ciertas condiciones (IF)
  • saltar a otra posición, pero guardar el punto de salida para retornar (CALL, llamada a subrutinas)

Algunas computadoras incluyen instrucciones complejas dentro de sus capacidades. Una sola instrucción compleja hace lo mismo que en otras computadoras puede requerir una larga serie de instrucciones, por ejemplo:

• salvar varios registros en la pila de una sola vez
• mover grandes bloques de memoria
• operaciones aritméticas complejas o de punto flotante (seno, coseno, raíz cuadrada)

Mientras que una computadora reconoce la instrucción de máquina IA-32

 10110000 01100001

para los programadores de microprocesadores x86 es mucho más fácil reconocer dicha instrucción empleando lenguaje ensamblador:

  movb  0x61,%al

Este código mueve el valor hexadecimal 61 (97 en decimal) al registro 'al'.

Ejemplos de lenguaje ensamblador

Ejemplo 1

El siguiente es un ejemplo del programa clásico Hola mundo escrito para la arquitectura de procesador x86 (bajo el sistema operativo DOS).

 .model small
 .stack
 .data
 Cadena1 DB 'Hola Mundo.$'
 .code
 
 programa:
    mov ax, @data
    mov ds, ax
    mov dx, offset Cadena1
    mov ah, 9
    int 21h
 end programa

Ejemplo 2

Una selección de instrucciones para una computadora virtual​) con las correspondientes direcciones de memoria en las que se ubicarán las instrucciones. Estas direcciones NO son estáticas. Cada instrucción se acompaña del código en lenguaje ensamblador generado (código objeto) que coincide con la arquitectura de computador virtual, o conjunto de instrucciones ISA.

Dir.	Etiqueta	Instrucción	Código máquina​
		.begin
		.org 2048
	a_start	.equ 3000
2048		ld length,%
2064		be done	00000010 10000000 00000000 00000110
2068		addcc %r1,-4,%r1	10000010 10000000 01111111 11111100
2072		addcc %r1,%r2,%r4	10001000 10000000 01000000 00000010
2076		ld %r4,%r5	11001010 00000001 00000000 00000000
2080		ba loop	00010000 10111111 11111111 11111011
2084		addcc %r3,%r5,%r3	10000110 10000000 11000000 00000101
2088	done:	jmpl %r15+4,%r0	10000001 11000011 11100000 00000100
2092	length:	20	00000000 00000000 00000000 00010100
2096	address:	a_start	00000000 00000000 00001011 10111000
		.org a_start
3000		a:</tt

Ejemplo 3

Código en lenguaje ensamblador para µC Intel 80C51:

 
 ORG 8030H
                                                                     
 T05SEG:                     
  SETB TR0
  JNB uSEG,T05SEG       ;esta subrutina es utilizada     
  CLR TR0               ;para realizar una cuenta de 
  CPL uSEG              ;0,5 segundos mediante la     
  MOV R1,DPL            ;interrupción del timer 0.     
  MOV R2,DPH                 
  CJNE R2,#07H,T05SEG        
  CJNE R1,#78H,T05SEG        
  MOV DPTR,#0000H
  RET

Ejemplo 4

Código en lenguaje ensamblador para µC 16F84 de Microchip:

  ORG	0
 Inicio
 	bsf	STATUS,RP0		
 	clrf	PORTB			
 	movlw	0xFF			
 	movwf	PORTA
 	bcf	STATUS,RP0		
 Principal
 	movf	PORTA,W			 
 	movwf	Contador	 	
 	movf	Contador,F		
 	btfsc	STATUS,Z		
 	goto	PuntoDecimal		
 	sublw	d'9'			
 	btfss	STATUS,C
         END

Bibliografía

• Dominic Sweetman: See MIPS Run. Morgan Kaufmann Publishers. ISBN 1-55860-410-3
• Robert Britton: MIPS Assembly Language Programming. Prentice Hall. ISBN 0-13-142044-5
• John Waldron: Introduction to RISC Assembly Language Programming. Addison Wesley. ISBN 0-201-39828-1

Véase también

• Lenguaje de máquina
• Tipos de datos máquina

Enlaces externos

• Wikilibros alberga un libro o manual sobre Programación en lenguaje ensamblador.
• The Art of Assembly Language Programming, [1] by Randall Hyde
• Computer-Books.us, Online Assembly Language Brooks
• PC Assembly Language(español) by Dr Paul Carter; *PC Assembly Tutorial using NASM and GCC by Paul Carter
• Programming from the Ground Up by Jonathan Bartlett
• The ASM Book by the ASM Community
• Inline::ASM módulo Perl en CPAN para programar en lenguaje ensamblador dentro de programas Perl (en inglés)
• Ejemplos prácticos de ensamblador en GNU/Linux