Lenguaje ensamblador

Ir a la navegaci�nIr a la b�squeda
Para otros usos de este t�rmino, v�ase Ensamblador (desambiguaci�n).

Lenguaje de m�quina del Intel 8088. El c�digo de m�quina en hexadecimal se resalta

en rojo, el equivalente en lenguaje ensamblador en magenta, y las direcciones de
memoria donde se encuentra el c�digo, en azul. Abajo se ve un texto en hexadecimal
y ASCII.
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). Esto est� en contraste con la
mayor�a de los lenguajes de programaci�n de alto nivel, que idealmente son
portables.

Un programa utilitario llamado ensamblador es usado para traducir sentencias del

lenguaje ensamblador al c�digo de m�quina del computador objetivo. El ensamblador
realiza una traducci�n m�s o menos isomorfa (un mapeo de uno a uno) desde las
sentencias mnem�nicas a las instrucciones y datos de m�quina. Esto est� en
contraste con los lenguajes de alto nivel, en los cuales una sola declaraci�n
generalmente da lugar a muchas instrucciones de m�quina.

Muchos sofisticados ensambladores ofrecen mecanismos adicionales para facilitar el

desarrollo del programa, controlar el proceso de ensamblaje, y la ayuda de
depuraci�n. Particularmente, la mayor�a de los ensambladores modernos incluyen una
facilidad de macro (descrita m�s abajo), y se llaman macro ensambladores.

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.

�ndice
1 Caracter�sticas
2 Programa ensamblador
2.1 Ensambladores de alto nivel
2.2 Uso del t�rmino
3 Lenguaje
3.1 Instrucciones de CPU
3.2 Ensamblado
3.3 Ejemplos
4 Dise�o del lenguaje
4.1 Elementos b�sicos
4.1.1 Mnem�nicos de opcode y mnem�nicos extendidos
4.1.2 Secciones de datos
4.1.3 Directivas del ensamblador
4.2 Macros
4.3 Soporte para programaci�n estructurada
5 Uso del lenguaje ensamblador
5.1 Perspectiva hist�rica
5.2 Uso actual
5.3 Aplicaciones t�picas
6 Detalles adicionales
7 Ejemplos de lenguaje ensamblador
7.1 Ejemplo para la arquitectura x86
7.2 Ejemplo para el computador virtual (POCA)
7.3 Ejemplo para el �C Intel 8051
7.4 Ejemplo para el Microchip PIC16F84
8 V�ase tambi�n
9 Referencias
10 Bibliograf�a
11 Enlaces externos
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.
El lenguaje ensamblador es 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.
Programa ensamblador
Art�culo principal: Ensamblador
Generalmente, un programa ensamblador (assembler en ingl�s) moderno crea c�digo
objeto traduciendo instrucciones mnem�nicas de lenguaje ensamblador en opcodes, y
resolviendo los nombres simb�licos para las localizaciones de memoria y otras
entidades.1? El uso de referencias simb�licas es una caracter�stica clave del
lenguaje ensamblador, evitando tediosos c�lculos y actualizaciones manuales de las
direcciones despu�s de cada modificaci�n del programa. La mayor�a de los
ensambladores tambi�n incluyen facilidades de macros para realizar sustituci�n
textual - ej. generar cortas secuencias de instrucciones como expansi�n en l�nea en
vez de llamar a subrutinas.

Los ensambladores son generalmente m�s simples de escribir que los compiladores
para los lenguajes de alto nivel, y han estado disponibles desde los a�os 1950. Los
ensambladores modernos, especialmente para las arquitecturas basadas en RISC, tales
como MIPS, Sun SPARC, y HP PA-RISC, as� como tambi�n para el x86 (-64), optimizan
la planificaci�n de instrucciones para explotar la segmentaci�n del CPU
eficientemente.

En los compiladores para lenguajes de alto nivel, son el �ltimo paso antes de
generar el c�digo ejecutable.

N�mero de paso Hay dos tipos de ensambladores basados en cu�ntos pasos a trav�s de
la fuente son necesarios para producir el programa ejecutable.

Los ensambladores de un solo paso pasan a trav�s del c�digo fuente una vez y asumen
que todos los s�mbolos ser�n definidos antes de cualquier instrucci�n que los
refiera.
Los ensambladores de dos pasos crean una tabla con todos los s�mbolos y sus valores
en el primer paso, despu�s usan la tabla en un segundo paso para generar c�digo. El
ensamblador debe por lo menos poder determinar la longitud de cada instrucci�n en
el primer paso para que puedan ser calculadas las direcciones de los s�mbolos.
La ventaja de un ensamblador de un solo paso es la velocidad, que no es tan
importante como lo fue en un momento dados los avances en velocidad y capacidades
del computador. La ventaja del ensamblador de dos pasos es que los s�mbolos pueden
ser definidos dondequiera en el c�digo fuente del programa. Esto permite a los
programas ser definidos de maneras m�s l�gicas y m�s significativas, haciendo los
programas de ensamblador de dos pasos m�s f�ciles de leer y mantener.2?

Ensambladores de alto nivel

Los m�s sofisticados ensambladores de alto nivel proporcionan abstracciones del
lenguaje tales como:

Estructuras de control avanzadas

Declaraciones e invocaciones de procedimientos/funciones de alto nivel
Tipos de datos abstractos de alto nivel, incluyendo las estructuras/records,
uniones, clases, y conjuntos
Procesamiento de macros sofisticado (aunque est� disponible en los ensambladores
ordinarios desde finales de 1960 para el IBM/360, entre otras m�quinas)
Caracter�sticas de programaci�n orientada a objetos
Uso del t�rmino
Note que, en el uso profesional normal, el t�rmino ensamblador es frecuentemente
usado tanto para referirse al lenguaje ensamblador como tambi�n al programa
ensamblador (que convierte el c�digo fuente escrito en el lenguaje ensamblador a
c�digo objeto que luego ser� enlazado para producir lenguaje de m�quina). Las dos
expresiones siguientes utilizan el t�rmino "ensamblador":

Lenguaje
El lenguaje ensamblador refleja directamente la arquitectura y las instrucciones en
lenguaje de m�quina de la CPU, y pueden ser muy diferentes de una arquitectura de
CPU a otra.

Cada arquitectura de microprocesador tiene su propio lenguaje de m�quina, y en

consecuencia su propio lenguaje ensamblador ya que este se encuentra muy ligado a
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.

Instrucciones de CPU
La mayor�a de las CPU tienen m�s o menos los mismos grupos de instrucciones, aunque
no necesariamente tienen todas las instrucciones de cada grupo. Las operaciones que
se pueden realizar var�an de una CPU a otra. Una CPU particular puede tener
instrucciones que no tenga otro y viceversa.

Los primeros microprocesadores de 8 bits no ten�an operaciones para multiplicar o

dividir n�meros, por ejemplo, y hab�a que hacer subrutinas para realizar esas
operaciones. Otras CPU puede que no tengan operaciones de punto flotante y habr�a
que hacer o conseguir bibliotecas que realicen esas operaciones.

Las instrucciones de la CPU pueden agruparse, de acuerdo a su funcionalidad, en:

Operaciones con enteros: (de 8, 16, 32 y 64 bits dependiendo de la arquitectura de

la CPU, en los sistemas muy viejos tambi�n de 12, 18, 24, 36 y 48 bits).

Estas son operaciones realizadas por la Unidad aritm�tico l�gica de la CPU:

Operaciones aritm�ticas. Como suma, resta, multiplicaci�n, divisi�n, m�dulo, cambio

de signo
Operaciones booleanas. Operaciones l�gicas bit a bit como AND, OR, XOR, NOT
Operaciones de bits. Como desplazamiento o shift l�gico y rotaciones u Operadores a
nivel de bits (hacia la derecha o hacia la izquierda, a trav�s del bit del acarreo
o sin �l)
Comparaciones
Operaciones de mover datos:

Entre los registros y la memoria:

Aunque la instrucci�n se llama "mover", en la CPU, "mover datos" significa en
realidad copiar datos, desde un origen a un destino, sin que el dato desaparezca
del origen.
Se pueden mover valores:
Desde un registro a otro
Desde un registro a un lugar de la memoria
Desde un lugar de la memoria a un registro
Desde un lugar a otro de la memoria
Un valor inmediato a un registro
Un valor inmediato a un lugar de memoria
Operaciones de pila (stack, en ingl�s):
PUSH (escribe datos hacia el tope de la pila)
POP (lee datos desde el tope de la pila)
Operaciones de entrada/salida:
Son operaciones que mueven datos de un registro, desde y hacia un puerto; o de la
memoria, desde y hacia un puerto
INPUT Lectura desde un puerto de entrada
OUTPUT Escritura hacia un puerto de salida
Operaciones para el control del flujo del programa:

Llamadas y retornos de subrutinas

Llamadas y retornos de interrupciones
Saltos condicionales de acuerdo al resultado de la comparaciones
Saltos incondicionales
Operaciones con n�meros reales:

El est�ndar para las operaciones con n�meros reales en las CPU est� definido por el
IEEE 754.

Una CPU puede tener operaciones de punto flotante con n�meros reales mediante el
coprocesador num�rico (si lo hay), como las siguientes:

Operaciones aritm�ticas. Suma, resta, multiplicaci�n, divisi�n, cambio de signo,

valor absoluto, parte entera
Operaciones trascendentales
Operaciones trigonom�tricas. Seno, coseno, tangente, arcotangente
Operaciones con logaritmos, potencias y ra�ces
Otras
El lenguaje ensamblador tiene mnem�nicos para cada una de las instrucciones de la
CPU en adici�n a otros mnem�nicos a ser procesados por el programa ensamblador
(como por ejemplo macros y otras sentencias en tiempo de ensamblado).

Ensamblado
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 y simplificar la programaci�n. 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.

Para el mismo procesador y el mismo conjunto de instrucciones de CPU, diferentes

programas ensambladores pueden tener, cada uno de ellos, variaciones y diferencias
en el conjunto de mnem�nicos o en la sintaxis de su lenguaje ensamblador. Por
ejemplo, en un lenguaje ensamblador para la arquitectura x86, se puede expresar la
instrucci�n para mover 5 al registro AL de la siguiente manera: MOV AL, 5, mientras
que para otro ensamblador para la misma arquitectura se expresar�a al rev�s: MOV 5,
AL. Ambos lenguajes ensambladores har�an exactamente lo mismo, solo que est�
expresado de manera diferente. El primero usa la sintaxis de Intel, mientras que el
segundo usa la sintaxis de AT&T.

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.

Ejemplos
Un programa escrito en lenguaje ensamblador consiste en una serie de instrucciones
que corresponden al flujo de �rdenes ejecutables por un microprocesador.

Por ejemplo, en el lenguaje ensamblador para un procesador x86:

La sentencia

MOV AL, 61h

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

El programa ensamblador lee la sentencia de arriba y produce su equivalente binario

en lenguaje de m�quina.

Binario: 10110000 01100001 (hexadecimal: B61)

El mnem�nico MOV es un c�digo de operaci�n u "opcode". El opcode es seguido por una
lista de argumentos o par�metros, completando una t�pica instrucci�n de
ensamblador. En el ejemplo, AL es un registro de 8 bits del procesador, al cual se
le asignar� el valor hexadecimal 61 especificado.

El c�digo de m�quina generado por el ensamblador consiste de 2 bytes. El primer

byte contiene empaquetado la instrucci�n MOV y el c�digo del registro hacia donde
se va a mover el dato:

1011 0000 01100001

| | |
 | | +---- N�mero 61h en binario
| |
| +--- Registro AL
+-------- Instrucci�n MOV
En el segundo byte se especifica el n�mero 61h, escrito en binario como 01100001,
que se asignar� al registro AL, quedando la sentencia ejecutable como:

10110000 01100001
La cual puede ser entendida y ejecutada directamente por el procesador.

Dise�o del lenguaje

Elementos b�sicos
Hay un grado grande de diversidad en la manera en que los autores de los
ensambladores categorizan las sentencias y en la nomenclatura que usan. En
particular, algunos describen cualquier cosa como pseudo-operaci�n (pseudo-Op), con
excepci�n del mnem�nico de m�quina o del mnem�nico extendido.

Un t�pico lenguaje ensamblador consiste en 3 tipos de sentencias de instrucci�n que

son usadas para definir las operaciones del programa:

Mnem�nicos de opcode
Secciones de datos
Directivas de ensamblador
Mnem�nicos de opcode y mnem�nicos extendidos
A diferencia de las instrucciones (sentencias) de los lenguajes de alto nivel, las
instrucciones en el lenguaje ensamblador son generalmente muy simples.
Generalmente, una mnem�nico es un nombre simb�lico para una sola instrucci�n en
lenguaje de m�quina ejecutable (un opcode), y hay por lo menos un mnem�nico de
opcode definido para cada instrucci�n en lenguaje de m�quina. Cada instrucci�n
consiste t�picamente en una operaci�n u opcode m�s cero o m�s operandos. La mayor�a
de las instrucciones refieren a un solo valor, o a un par de valores. Los operandos
pueden ser inmediatos (t�picamente valores de un byte, codificados en la propia
instrucci�n), registros especificados en la instrucci�n, impl�citos o las
direcciones de los datos localizados en otra parte de la memoria. Esto est�
determinado por la arquitectura subyacente del procesador, el ensamblador
simplemente refleja c�mo trabaja esta arquitectura. Los mnem�nicos extendidos son
frecuentemente usados para especificar una combinaci�n de un opcode con un operando
espec�fico, ej, el ensamblador del System/360 usa a B como un mnem�nico extendido
para el BC con una m�scara de 15 y NOP al BC con una m�scara de 0.

Los mnem�nicos extendidos son frecuentemente usados para soportar usos

especializados de instrucciones, a menudo para prop�sitos no obvios con respecto al
nombre de la instrucci�n. Por ejemplo, muchos CPU no tienen una instrucci�n
expl�cita de NOP (No Operaci�n), pero tienen instrucciones que puedan ser usadas
para tal prop�sito. En el CPU 8086, la instrucci�n XCHG AX,AX (intercambia el
registro AX consigo mismo) es usada para el NOP, con NOP siendo un pseudo-opcode
para codificar la instrucci�n XCHG AX,AX. Algunos desensambladores reconocen esto y
decodificar�n la instrucci�n XCHG AX,AX como NOP. Similarmente, los ensambladores
de IBM para el System/360 usan los mnem�nicos extendidos NOP y NOPR con las
m�scaras cero para BC y BCR.

Algunos ensambladores tambi�n soportan simples macroinstrucciones incorporadas que

generan dos o m�s instrucciones de m�quina. Por ejemplo, con algunos ensambladores
para el Z80, la instrucci�n

LD HL, BC
genera las instrucciones

LD L, C
LD H, B.3?
LD HL, BC es un pseudo-opcode, que en este caso simula ser una instrucci�n de 16
bits, cuando se expande se producen dos instrucciones de 8 bits que equivalen a la
simulada de 16 bits.

Secciones de datos
Hay instrucciones usadas para definir elementos de datos para manejar datos y
variables. Definen el tipo de dato, la longitud y la alineaci�n de los datos. Estas
instrucciones tambi�n pueden definir si los datos est�n disponibles para programas
exteriores (programas ensamblados separadamente) o solamente para el programa en el
cual la secci�n de datos est� definida. Algunos ensambladores clasifican estas
instrucci�n.

Directivas del ensamblador

Los directivas del ensamblador, tambi�n llamadas los pseudo opcodes, pseudo-
operaciones o pseudo-ops, son instrucciones que son ejecutadas por un ensamblador
en el tiempo de ensamblado, no por un CPU en el tiempo de ejecuci�n. Pueden hacer
al ensamblado del programa dependiente de par�metros entrados por un programador,
de modo que un programa pueda ser ensamblado de diferentes maneras, quiz�s para
diversos aplicaciones. Tambi�n pueden ser usadas para manipular la presentaci�n de
un programa para hacerlo m�s f�cil leer y mantener.

Por ejemplo, las directivas pudieran ser usadas para reservar �reas de
almacenamiento y opcionalmente para asignar su contenido inicial. Los nombres de
las directivas a menudo comienzan con un punto para distinguirlas de las
instrucciones de m�quina.

Los ensambladores simb�licos le permiten a los programadores asociar nombres

arbitrarios (etiquetas o s�mbolos) a posiciones de memoria. Usualmente, cada
constante y variable tiene un nombre para que las instrucciones puedan referir a
esas ubicaciones por nombre, as� promoviendo el c�digo autodocumentado. En el
c�digo ejecutable, el nombre de cada subprograma es asociado a su punto de entrada,
as� que cualquier llamada a un subprograma puede usar su nombre. Dentro de
subprogramas, a los destinos GOTO se le dan etiquetas. Algunos ensambladores
soportan s�mbolos locales que son l�xicamente distintos de los s�mbolos normales
(ej, el uso de "10$" como un destino GOTO).

La mayor�a de los ensambladores proporcionan un manejo flexible de s�mbolos,

permitiendo a los programadores manejar diversos espacios de nombres, calcular
autom�ticamente offsets dentro de estructuras de datos, y asignar etiquetas que
refieren a valores literales o al resultado de c�lculos simples realizados por el
ensamblador. Las etiquetas tambi�n pueden ser usadas para inicializar constantes y
variables con direcciones relocalizables.

Los lenguajes ensambladores, como la mayor�a de los otros lenguajes de computador,

permiten que sean a�adidos comentarios al c�digo fuente, que son ignorados por el
programa ensamblador. El buen uso de los comentarios es a�n m�s importante con
c�digo ensamblador que con lenguajes de alto nivel, pues el significado y el
prop�sito de una secuencia de instrucciones es m�s duro de descifrar a partir del
c�digo en s� mismo.

El uso sabio de estas facilidades puede simplificar grandemente los problemas de

codificar y mantener el c�digo de bajo nivel. El c�digo fuente de lenguaje
ensamblador crudo generado por compiladores o desensambladores - c�digo sin ning�n
comentario, ni s�mbolos con alg�n sentido, ni definiciones de datos - es muy
dif�cil de leer cuando deben hacerse cambios.

Macros
Muchos ensambladores soportan macros predefinidas, y otras soportan macros
definidas (y repetidamente redefinibles) por el programador que implican secuencias
de l�neas del texto en las cuales las variables y las constantes est�n empotradas.
Esta secuencia de l�neas de texto puede incluir opcodes o directivas. Una vez una
macro se define, su nombre se puede usar en lugar de un mnem�nico. Cuando el
ensamblador procesa tal sentencia, reemplaza la sentencia por las l�neas del texto
asociadas a esa macro, entonces las procesa como si hubieran existido en el archivo
del c�digo fuente original (incluyendo, en algunos ensambladores, la expansi�n de
cualquier macro que exista en el texto de reemplazo).

Puesto que las macros pueden tener nombres cortos pero se expanden a varias, o de
hecho, muchas l�neas de c�digo, pueden usarse para hacer que los programas en
lenguaje ensamblador parezcan ser mucho m�s cortos, requiriendo menos l�neas de
c�digo fuente, como sucede con los lenguajes de alto nivel. Tambi�n se pueden usar
para a�adir niveles de estructura m�s altos a los programas ensamblador;
opcionalmente introducen c�digo de depuraci�n empotrado v�a par�metros y otras
caracter�sticas similares.

Muchos ensambladores tienen macros incorporadas (o predefinidas) para las llamadas

de sistema y otras secuencias especiales de c�digo, tales como la generaci�n y el
almacenamiento de los datos realizados a trav�s de avanzadas operaciones bitwise y
operaciones booleanas usadas en juegos, software de seguridad, gesti�n de datos y
criptograf�a.

Los macro ensambladores a menudo permiten a las macros tomar par�metros. Algunos
ensambladores incluyen lenguajes macro muy sofisticados, incorporando elementos de
lenguajes de alto nivel tales como par�metros opcionales, variables simb�licas,
condiciones, manipulaciones de strings, operaciones aritm�ticas, todos usables
durante la ejecuci�n de una macro dada, y permitiendo a las macros guardar el
contexto o intercambiar informaci�n. As� una macro puede generar un gran n�mero de
instrucciones o definiciones de datos en lenguaje ensamblador, basadas en los
argumentos de la macro. Esto se podr�a usar para generar, por ejemplo, estructuras
de datos de estilo de r�cord o bucles "desenrollados", o podr�a generar algoritmos
enteros basados en par�metros complejos. Una organizaci�n, usando lenguaje
ensamblador, que ha sido fuertemente extendido usando tal suite de macros, puede
ser considerada que se est� trabajando en un lenguaje de alto nivel, puesto que
tales programadores no est�n trabajando con los elementos conceptuales de m�s bajo
nivel del computador.

Las macros se usaron para adaptar sistemas de software de gran escala para clientes
espec�ficos en la era del mainframe, y tambi�n se usaron por el personal del
cliente para satisfacer las necesidades de sus patrones haciendo versiones
espec�ficas de los sistemas operativos del fabricante. Esto fue hecho, por ejemplo,
por los programadores de sistema que trabajaban con el Conversational Monitor
System / Virtual Machine (CMS/VM) de IBM y con los complementos real time
transaction processing de IBM, CICS, Customer Information Control System, el
airline/financial system que comenz� en los a�os 1970 y todav�a corre con muchos
sistemas de reservaciones computarizados (CRS) y sistemas de tarjeta de cr�dito de
hoy.

Tambi�n es posible usar solamente las habilidades de procesamiento de macros de un

ensamblador para generar c�digo escrito en lenguajes completamente diferentes. Por
ejemplo, para generar una versi�n de un programa en COBOL usando un programa macro
ensamblador puro conteniendo l�neas de c�digo COBOL dentro de operadores de tiempo
ensamblaje dando instrucciones al ensamblador para generar c�digo arbitrario.

Esto era porque, como en los a�os 1970 fue observado, el concepto de "procesamiento
de macro" es independiente del concepto de "ensamblaje", siendo el anterior, en
t�rminos modernos, m�s un procesamiento de textos, que una generaci�n de c�digo
objeto. El concepto de procesamiento de macro apareci�, y aparece, en el lenguaje
de programaci�n C, que soporta "instrucciones de preprocesador" de fijar variables,
y hace pruebas condicionales en sus valores. Observe que a diferencia de ciertos
macroprocesadores previos dentro de los ensambladores, el preprocesador de C no es
Turing-completo porque carec�a de la capacidad de bucle o go to, esto �ltimo
permitiendo a los programas hacer bucles.

A pesar del poder del procesamiento macro, �ste dej� de usarse en muchos lenguajes
de alto nivel (una importante excepci�n es C/C++) mientras que segu�a siendo
perenne para los ensambladores. Esto era porque muchos programadores estaban
bastante confundidos por la sustituci�n de par�metros macro y no distingu�an la
diferencia entre procesamiento macro, el ensamblaje y la ejecuci�n.

La sustituci�n de par�metros macro es estrictamente por nombre: en el tiempo de

procesamiento macro, el valor de un par�metro es sustituido textualmente por su
nombre. La clase m�s famosa de Error de software resultantes era el uso de un
par�metro que en s� mismo era una expresi�n y no un nombre primario cuando el
escritor macro esperaba un nombre. En el macro:

foo: macro a
load a*b
la intenci�n era que la rutina que llama proporcionar�a el nombre de una variable,
y la variable o constante "global b" ser�a usada para multiplicar a "a". Si foo se
llama con el par�metro a-c, ocurre la expansi�n macro load a-c*b. Para evitar
cualquier posible ambig�edad, los usuarios de macro procesadores pueden encerrar en
par�ntesis los par�metros formales dentro de las definiciones de macros, o las
rutinas que llaman pueden envolver en par�ntesis los par�metos de entrada.4? As�,
el macro correcto, con los par�ntesis, ser�a:

foo: macro a
load (a)*b
y su expansi�n, dar�a como resultado: load (a-c)*b

El PL/I y el C/C++ ofrecen macros, pero la esta facilidad solo puede manipular
texto. Por otra parte, los lenguajes homoic�nicos, tales como Lisp, Prolog, y
Forth, retienen el poder de los macros de lenguaje ensamblador porque pueden
manipular su propio c�digo como datos.

Soporte para programaci�n estructurada

Algunos ensambladores han incorporado elementos de programaci�n estructurada para
codificar el flujo de la ejecuci�n. El ejemplo m�s temprano de este acercamiento
estaba en el Concept-14 macro set, originalmente propuesto por el Dr. H.D. Mills
(marzo de 1970), e implementado por Marvin Kessler en la Federal Systems Division
de IBM, que extendi� el macro ensamblador del S/360 con bloques de control de flujo
IF/ELSE/ENDIF y similares.5? Esto era una manera de reducir o eliminar el uso de
operaciones GOTO en el c�digo en lenguaje ensamblador, uno de los principales
factores que causaban c�digo espagueti en el lenguaje ensamblador. Este
acercamiento fue ampliamente aceptado a principios de los a�os 1980 (los �ltimos
d�as del uso de lenguaje ensamblador en gran escala).

Un curioso dise�o fue A-natural, un ensamblador "orientado a la corriente" (stream-

oriented) para los procesadores 8080/Z80[cita requerida] de Whitesmiths Ltd.
(desarrolladores del sistema operativo Idris, similar al Unix), y lo que fue
reportado como el primer compilador C comercial). El lenguaje fue clasificado como
un ensamblador, porque trabajaba con elementos de m�quina crudos tales como
opcodes, registros, y referencias de memoria; pero incorporaba una sintaxis de
expresi�n para indicar el orden de ejecuci�n. Los par�ntesis y otros s�mbolos
especiales, junto con construcciones de programaci�n estructurada orientadas a
bloques, controlaban la secuencia de las instrucciones generadas. A-natural fue
construido como el lenguaje objeto de un compilador C, en vez de la codificaci�n
manual, pero su sintaxis l�gica gan� algunos seguidores.

Ha habido poca demanda aparente para ensambladores m�s sofisticados debido a la

declinaci�n del desarrollo de lenguaje ensamblador de larga escala.6? A pesar de
eso, todav�a se est�n desarrollando y aplicando en casos donde las limitaciones de
recursos o las particularidades en la arquitectura de sistema objetivo previenen el
efectivo uso de lenguajes de alto nivel.7?

Uso del lenguaje ensamblador

Perspectiva hist�rica
Los lenguajes ensambladores fueron primero desarrollados en los a�os 1950, cuando
fueron referidos como lenguajes de programaci�n de segunda generaci�n. Por ejemplo,
el SOAP (Symbolic Optimal Assembly Program) era un lenguaje ensamblador de 1957
para el computador IBM 650. Los lenguajes ensambladores eliminaron mucha de la
propensi�n a errores y del consumo de tiempo de la programaci�n de los lenguajes de
primera generaci�n, que se necesitaba con los primeros computadores, liberando a
los programadores del tedio tal como recordar c�digos num�ricos y c�lculo de
direcciones. Una vez fueron ampliamente usados para todo tipo de programaci�n. Sin
embargo, por los a�os 1980 (1990 en los microcomputadores), su uso hab�a sido en
gran parte suplantado por los lenguajes de alto nivel,[cita requerida] en la
b�squeda de una mejorada productividad en programaci�n. Hoy en d�a, aunque el
lenguaje ensamblador es casi siempre manejado y generado por los compiladores,
todav�a se usa para la manipulaci�n directa del hardware, acceso a instrucciones
especializadas del procesador, o para resolver problemas de desempe�o cr�tico. Los
usos t�picos son controladores/manejadores (drivers) de dispositivo, sistemas
embebidos de bajo nivel, y sistemas de tiempo real.

Hist�ricamente, un gran n�mero de programas han sido escritos enteramente en

lenguaje ensamblador. Los sistemas operativos fueron casi exclusivamente escritos
en lenguaje ensamblador hasta la aceptaci�n amplia del lenguaje de programaci�n C
en los a�os 1970 y principios de los 1980. Tambi�n, muchas aplicaciones comerciales
fueron escritas en lenguaje ensamblador, incluyendo una gran cantidad del software
escrito por grandes corporaciones para mainframes de IBM. Los lenguajes COBOL y
FORTRAN eventualmente desplazaron mucho de este trabajo, aunque un n�mero de
organizaciones grandes conservaran las infraestructuras de aplicaciones en lenguaje
ensamblador hasta bien entrados los a�os 1990.

La mayor�a de los primeros microcomputadores confiaron en el lenguaje ensamblador

codificado a mano, incluyendo la mayor�a de los sistemas operativos y de las
aplicaciones grandes. Esto era porque estos sistemas ten�an limitaciones severas de
recursos, impusieron idiosincr�ticas arquitecturas de memoria y de pantalla, y
proporcionaron servicios de sistema limitados y con errores. Quiz�s m�s importante
era la falta de compiladores de primera clase de lenguajes de alto nivel adecuados
para el uso en el microcomputador. Un factor psicol�gico tambi�n pudo haber jugado
un papel: la primera generaci�n de programadores de los microcomputadores conserv�
una actitud de aficionado de "alambres y alicates".

En un contexto m�s comercial, las m�s grandes razones para usar el lenguaje
ensamblador era hacer programas con m�nimo tama�o, m�nima sobrecarga, mayor
velocidad y confiabilidad.

Los t�picos ejemplos de programas grandes en lenguaje ensamblador de ese tiempo son
los sistemas operativos IBM PC DOS y aplicaciones tempranas tales como la hoja de
c�lculo Lotus 1-2-3, y casi todos los juegos populares para la familia Atari 800 de
computadores personales. Incluso en los a�os 1990, la mayor�a de los videojuegos de
consola fueron escritos en ensamblador, incluyendo la mayor�a de los juegos para la
Mega Drive/Genesis y el Super Nintendo Entertainment System.[cita requerida] Seg�n
algunos insiders de la industria, el lenguaje ensamblador era el mejor lenguaje de
programaci�n a usar para obtener el mejor desempe�o del Sega Saturn, una consola
para la cual era notoriamente desafiante desarrollar y programar juegos.8? El
popular juego de arcade NBA Jam (1993) es otro ejemplo. El ensamblador ha sido por
largo trecho, el lenguaje de desarrollo primario en los computadores hogare�os
Commodore 64, Atari ST, as� como el ZX Spectrum. Esto fue as� en gran parte porque
los dialectos del BASIC en estos sistemas ofrecieron insuficiente velocidad de
ejecuci�n, as� como insuficientes caracter�sticas para aprovechar completamente el
hardware disponible. Algunos sistemas, m�s notablemente el Amiga, incluso tienen
IDEs con caracter�sticas de depuraci�n y macros altamente avanzados, tales como el
freeware ASM-One assembler, comparable a las del Microsoft Visual Studio (el ASM-
Uno precede al Microsoft Visual Studio).

El ensamblador para el VIC-20 fue escrito por Don French y publicado por French
Silk. Con 1639 bytes de longitud, su autor cree que es el m�s peque�o ensamblador
simb�lico jam�s escrito. El ensamblador soportaba el direccionamiento simb�lico
usual y la definici�n de cadenas de caracteres o cadenas hexadecimales. Tambi�n
permit�a expresiones de direcciones que pod�an combinarse con las operaciones de
adici�n, sustracci�n, multiplicaci�n, divisi�n, AND l�gico, OR l�gico, y
exponenciaci�n.9?

Uso actual
Siempre ha habido debates sobre la utilidad y el desempe�o del lenguaje ensamblador
relativo a lenguajes de alto nivel. El lenguaje ensamblador tiene nichos
espec�ficos donde es importante (ver abajo). Pero, en general, los modernos
compiladores de optimizaci�n para traducir lenguajes de alto nivel en c�digo que
puede correr tan r�pidamente como el lenguaje ensamblador escrito a mano, a pesar
de los contraejemplos que pueden ser encontrados.10?11?12? La complejidad de los
procesadores modernos y del subsistema de memoria hace la optimizaci�n efectiva
cada vez m�s dif�cil para los compiladores, as� como para los programadores en
ensamblador.13?14? Adicionalmente, y para la consternaci�n de los amantes de la
eficiencia, el desempe�o cada vez mayor del procesador ha significado que la
mayor�a de los CPU est�n desocupados la mayor parte del tiempo, con retardos
causados por embotellamientos predecibles tales como operaciones de entrada/salida
y paginaci�n de memoria. Esto ha hecho que la velocidad de ejecuci�n cruda del
c�digo no sea un problema para muchos programadores.

Hay algunas situaciones en las cuales los profesionales pudieran elegir utilizar el
lenguaje ensamblador. Por ejemplo cuando:

Es requerido un ejecutable binario independiente (stand-alone), es decir uno que

deba ejecutarse sin recursos a componentes de tiempo de ejecuci�n o a bibliotecas
asociadas con un lenguaje de alto nivel; �sta es quiz�s la situaci�n m�s com�n. Son
programas empotrados que solo almacenan una peque�a cantidad de memoria y el
dispositivo est� dirigido para hacer tareas para un simple prop�sito. Ejemplos
consisten en tel�fonos, sistemas de combustible e ignici�n para autom�viles,
sistemas de control del aire acondicionado, sistemas de seguridad, y sensores.
Interactuando directamente con el hardware, por ejemplo en controladores (drivers)
de dispositivo y manejadores de interrupci�n.
Usando instrucciones espec�ficas del procesador no explotadas o disponibles por el
compilador. Un ejemplo com�n es la instrucci�n de rotaci�n bitwise en el n�cleo de
muchos algoritmos de cifrado.
Creando funciones vectorizadas para programas en lenguajes de alto nivel como C. En
el lenguaje de alto nivel esto es a veces ayudado por funciones intr�nsecas del
compilador que mapean directamente a los mnem�nicos del SIMD, pero sin embargo
resulta en una conversi�n de ensamblador de uno a uno para un procesador de vector
asociado.
Es requerida la optimizaci�n extrema, ej, en un bucle interno en un algoritmo
intensivo en el uso del procesador. Los programadores de juegos toman ventaja de
las habilidades de las caracter�sticas del hardware en los sistemas, permitiendo a
los juegos correr m�s r�pidamente. Tambi�n las grandes simulaciones cient�ficas
requieren algoritmos altamente optimizados, ej, �lgebra lineal con BLAS o la
transformada de coseno discreta (ej, la versi�n SIMD en ensamblador del x264,15?
(una biblioteca para codificar streams de video).
Un sistema con severas limitaciones de recursos (ej, un sistema empotrado) debe ser
codificado a mano para maximizar el uso de los limitados recursos; pero esto est�
llegando a ser menos com�n a medida que el precio del procesador decrece y el
desempe�o mejora.
No existe ning�n lenguaje de alto nivel, en un procesador nuevo o especializado,
por ejemplo
Escribiendo programas de tiempo real que necesitan sincronizaci�n y respuestas
precisas, tales como sistemas de navegaci�n de vuelo, y equipo m�dico. Por ejemplo,
en un sistema fly-by-wire (vuelo por mandos el�ctricos), la telemetr�a debe ser
interpretada y hay que actuar dentro de limitaciones estrictas de tiempo. Tales
sistemas deben eliminar fuentes de retrasos impredecibles, que pueden ser creados
por (algunos) lenguajes interpretados, recolecci�n de basura autom�tica,
operaciones de paginaci�n, o multitarea preventiva. Sin embargo, algunos lenguajes
de alto nivel incorporan componentes de tiempo de ejecuci�n e interfaces de sistema
operativo que pueden introducir tales retrasos. Elegir el ensamblador o lenguajes
de bajo nivel para tales sistemas da a los programadores mayor visibilidad y
control sobre el proceso de los detalles.
Es requerido control total sobre el ambiente, en situaciones de seguridad
extremadamente alta donde nada puede darse por sentado.
Se escriben virus de computadora, bootloaders, ciertos controladores/manejadores de
dispositivo, u otros elementos muy cerca del hardware o al sistema operativo de
bajo nivel.
Se escriben simuladores del conjunto de instrucciones para monitoreo, trazado y
depuraci�n de errores donde la sobrecarga adicional es mantenida al m�nimo.
Se hace ingenier�a inversa en binarios existentes que pueden o no haber sido
escritos originalmente en un lenguaje de alto nivel, por ejemplo al crackear la
protecci�n anticopia del software propietario.
Se hace ingenier�a inversa y modificaci�n de video juegos (tambi�n denominado ROM
hacking), que es posible por medio de varios m�todos. El m�s ampliamente
implementado es alterando el c�digo del programa a nivel de lenguaje ensamblador.
Se escribe c�digo automodificable, algo para lo que el lenguaje ensamblador se
presta bien.
Se escriben juegos y otros softwares para calculadoras gr�ficas.16?
Se escribe software compilador que genera c�digo ensamblador, y por lo tanto los
desarrolladores deben ser programadores de lenguaje ensamblador.
Se escriben algoritmos criptogr�ficos que siempre deben tomar estrictamente el
mismo tiempo para ejecutar, previniendo ataques de tiempo.
Sin embargo, el lenguaje ensamblador es todav�a ense�ado en la mayor�a de los
programas de ciencias de la computaci�n e ingenier�a electr�nica. Aunque hoy en
d�a, pocos programadores trabajan regularmente con el lenguaje ensamblador como una
herramienta, los conceptos fundamentales contin�an siendo muy importantes. Tales
t�picos fundamentales, como aritm�tica binaria, asignaci�n de memoria,
procesamiento del stack, codificaci�n de conjunto de caracteres, procesamiento de
interrupciones, y dise�o de compiladores, ser�an duros de estudiar en detalle sin
la comprensi�n de c�mo el computador opera a nivel del hardware. Puesto que el
comportamiento del computador es fundamentalmente definido por su conjunto de
instrucciones, la manera l�gica de aprender tales conceptos es estudiar un lenguaje
ensamblador. La mayor�a de los computadores modernos tienen un conjunto de
instrucciones similares. Por lo tanto, estudiar un solo lenguaje ensamblador es
suficiente para aprender: i) los conceptos b�sicos; ii) reconocer situaciones donde
el uso de lenguaje ensamblador puede ser apropiado; y iii) ver c�mo el c�digo
ejecutable eficiente puede ser creado por los lenguajes de alto nivel17?

Aplicaciones t�picas
El lenguaje ensamblador hard-coded es t�picamente usado en el ROM de arranque del
sistema (BIOS en los sistemas compatible IBM PC). Este c�digo de bajo nivel es
usado, entre otras cosas, para inicializar y probar el hardware del sistema antes
de cargar el sistema operativo, y est� almacenado en el ROM. Una vez que ha tomado
lugar un cierto nivel de inicializaci�n del hardware, la ejecuci�n se transfiere a
otro c�digo, t�picamente escrito en lenguajes de alto nivel; pero el c�digo
corriendo inmediatamente despu�s de que es aplicada la energ�a usualmente est�
escrito en lenguaje ensamblador. Lo mismo es cierto para los boot loaders.

Muchos compiladores traducen lenguajes de alto nivel a lenguaje ensamblador

primero, antes de la compilaci�n completa, permitiendo que el c�digo en ensamblador
sea visto para prop�sitos de depuraci�n y optimizaci�n. Lenguajes de relativo bajo
nivel, como C, con frecuencia proveen sintaxis especial para empotrar lenguaje
ensamblador en cada plataforma de hardware. El c�digo portable del sistema entonces
puede usar estos componentes espec�ficos a un procesador a trav�s de una interface
uniforme.

El lenguaje ensamblador tambi�n es valioso en ingenier�a inversa, puesto que muchos

programas solamente son distribuidos en una forma de c�digo de m�quina. El c�digo
de m�quina es usualmente f�cil de trasladar hacia lenguaje ensamblador para luego
ser cuidadosamente examinado en esta forma, pero es muy dif�cil de trasladar hacia
un lenguaje de alto nivel. Herramientas como Interactive Disassembler, hacen uso
extenso del desensamblador para tales prop�sitos.

Un nicho que hace uso del lenguaje ensamblador es el demoscene. Ciertas

competiciones requieren a los concursantes restringir sus creaciones a un muy
peque�o tama�o (ej, 256 bytes, 1 KB, 4 KB � 64 KB), y el lenguaje ensamblador es el
lenguaje de preferencia para alcanzar este objetivo.18? Cuando los recursos son una
preocupaci�n, es una necesidad la codificaci�n en ensamblador, especialmente en
sistemas constre�idos por el procesamiento del CPU, como los primeros modelos del
Amiga, y el Commodore 64. El c�digo optimizado en ensamblador es escrito "a mano"
por los programadores en un intento de minimizar el n�mero de ciclos de CPU usados.
Las limitaciones del CPU son tan grandes que cada ciclo cuenta. Usar tales m�todos
ha habilitado, a sistemas como el Commodore 64, para producir gr�ficos en 3D en
tiempo real con efectos avanzados, una haza�a que puede ser considerada improbable
o incluso imposible para un sistema con un procesador de 0.99 MHz.[cita requerida]

Detalles adicionales
Para un determinado computador personal, mainframe, sistema empotrado, y consola de
juegos, tanto del pasado como del presente, ha sido escrito al menos uno, y
posiblemente docenas de ensambladores. Para algunos ejemplos, vea la lista de
ensambladores.

En los sistemas Unix, el ensamblador es llamado tradicionalmente as, aunque no es

un simple cuerpo de c�digo, siendo t�picamente escrito uno nuevo por cada port. Un
n�mero de variantes de Unix usan el GAS

Dentro de los grupos de procesadores, cada ensamblador tiene su propio dialecto. A

veces, algunos ensambladores pueden leer el dialecto de otro, por ejemplo, TASM
puede leer el viejo c�digo del MASM, pero no al rev�s. FASM y NASM tienen una
sintaxis similar, pero cada uno soporta diferentes macros que pueden ser dif�cil de
trasladar de uno al otro. Las cosas b�sicas son siempre las mismas, pero las
caracter�sticas avanzadas ser�n diferentes19?

Tambi�n, los lenguajes ensambladores a veces pueden ser portables a trav�s de

diferentes sistemas operativos en el mismo tipo de CPU. Las convenciones de
llamadas entre los sistemas operativos con frecuencia difieren ligeramente o en
nada. y con cuidado es posible ganar portabilidad en el lenguaje ensamblador,
usualmente al enlazar con una biblioteca de lenguaje C que no cambia entre sistemas
operativos. Un simulador de conjunto de instrucciones (que idealmente ser�a escrito
en lenguaje ensamblador) puede, en teor�a, procesar el c�digo objeto/binario de
cualquier ensamblador) para lograr la portabilidad incluso a trav�s de plataformas
(con una sobrecargue no mayor que la de un interpretador de bytecode t�pico). Esto
es esencialmente lo que logra el microc�digo cuando una plataforma de hardware
cambia internamente.

Por ejemplo, muchas cosas en libc dependen del preprocesador para hacer, al
programa antes de compilar, cosas que son espec�ficas del sistema operativo o
espec�ficas del C. De hecho, algunas funciones y s�mbolos ni siquiera est�n
garantizados que existan fuera del preprocesador. Peor a�n, el tama�o y el orden de
los campos de las estructuras, tanto como el tama�o de ciertas typedefs como off_t,
no est�n disponibles en lenguaje ensamblador sin la ayuda de un script de
configuraci�n, y difieren incluso entre versiones de Linux, haciendo imposible
portar llamadas de funciones en libc diferentes de los que toman simples enteros o
punteros como par�metros. Para manejar estos problemas, el proyecto FASMLIB provee
una biblioteca de lenguaje ensamblador portable para las plataformas Win32 y Linux,
pero todav�a est� muy incompleta.20?

Algunos lenguajes de muy alto nivel, como C y Borland/Pascal, soportan ensamblado

en l�nea, donde relativamente secciones cortas de c�digo en ensamblador puede ser
empotradas dentro del c�digo del lenguaje de alto nivel. El lenguaje Forth
com�nmente contiene un ensamblador usado para codificar palabras.

La mayor�a de la gente usa un emulador para depurar sus programas en lenguaje

ensamblador.

Ejemplos de lenguaje ensamblador

Ejemplo para la arquitectura x86
El siguiente 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
Ejemplo para el computador virtual (POCA)
Una selecci�n de instrucciones para una computadora virtual21?) 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�quina22?

.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 para el �C Intel 8051
C�digo en lenguaje ensamblador para �C Intel 80C51:

ORG 8030H
include
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.
INVOKE
MOV R2,DPH
CJNE R2,#07H,T05SEG
 CJNE R1,#78H,T05SEG
MOV DPTR,#0
RET
Ejemplo para el Microchip PIC16F84
C�digo en lenguaje ensamblador para el microcontrolador 16F84 de Microchip:

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