Lenguaje ensamblador 1

Lenguaje ensamblador
El lenguaje Assembly (a veces mal
llamado "Ensamblador" por su
traducción literal al español) 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 Lenguaje de máquina del Intel 8088. El código de máquina se resalta en rojo, el
para cada arquitectura de equivalente en lenguaje Assembly en magenta, y las direcciones de memoria donde se
encuentra el código, en azul.
computadoras legible por un
programador.

Fue usado principalmente en los inicios del desarrollo de software, cuando aún 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.
Aunque a veces suele usarse el nombre "Ensamblador" en realidad este nombre corresponde al programa que realiza
la interpretación del código en Assembly y genera el código máquina adecuado. Dado que Assembly es un nombre
propio, no debería traducirse.
Muchos dispositivos programables (como los microcontroladores) aun cuentan con el lenguaje Assembly como la
única manera de ser manipulados.

Características
• El código escrito en lenguaje Assembly posee una cierta dificultad de ser entendido directamente por un ser
humano ya que su estructura se acerca más bien al lenguaje máquina, es decir, lenguaje de bajo nivel.
• El lenguaje Assembly es difícilmente portable, es decir, un código escrito para un microprocesador, suele
necesitar ser modificado, muchas veces en su totalidad para poder ser usado en otra máquina distinta, aun con el
mismo microprocesador.
• Los programas hechos en lenguaje Assembly son generalmente más rápidos y consumen menos recursos del
sistema (memoria RAM y ROM). Al programar cuidadosamente en lenguaje Assembly se pueden crear
programas que se ejecutan más rápidamente y ocupan menos espacio que con lenguajes de alto nivel.
• Con el lenguaje Assembly 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.
• También se puede controlar el tiempo en que tarda una rutina en ejecutarse, e impedir que se interumpa durante su
ejecución.

Ensambladores
Un ensamblador (assembler en inglés) es un programa que crea código objeto traduciendo instrucciones mnemónicas
de un programa fuente escrito en Assembly 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 Assembly, 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, que insertan el código de la macro, en dicha posición, en lugar
de utilizar subrutinas.[1]
Lenguaje ensamblador 2

Los ensambladores han estado disponibles desde la década de 1950. Los ensambladores modernos, especialmente
para arquitecturas basadas en RISC que pueden ejecutar varias instrucciones simultáneamente, como por ejemplo
MIPS, SPARC y PA-RISC optimizan las instrucciones para explotar al máximo la eficiencia de segmentación[2] de
la CPU.
En los compilador para lenguajes de alto nivel, son el último paso antes de generar el código ejecutable.
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 Assembly 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 Assembly 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 Assembly típica.
La transformación del lenguaje Assembly 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 Assembly 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
Assembly, ya que este se encuentra muy ligado a la estructura del hardware para el cual se programa, muchas veces
dentro de una misma familia de microprocesadores/microcontroladores, la estructura y sintaxis general del Assembly
se mantiene, es posible encontrar también similitudes entre lenguajes Assembly de microprocesadores de distintos
fabricantes. 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 Assembly reflejan tal diferencia.
Lenguaje ensamblador 3

Pueden existir múltiples conjuntos de mnemónicos o sintáxis de lenguaje Assembly para un mismo conjunto de
instrucciones, instanciados típicamente en diferentes programas en Assembly. 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 Assembly:

movb 0x61,%al

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

Lenguaje ensamblador 4

Ejemplos de lenguaje Assembly

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
mov ah,4ch
int 21h
end programa

Ejemplo 2
Una selección de instrucciones para una computadora virtual[3] ) 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 Assembly generado (código objeto) que coincide con la arquitectura de computador virtual, o conjunto
de instrucciones ISA.

Dir. Etiqueta Instrucción [4]

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
Lenguaje ensamblador 5

Ejemplo 3
Código en lenguaje Assembly 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 Assembly 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
Lenguaje ensamblador 6

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
• Wikilibros alberga un libro o manual sobre Programación en lenguaje Assembly.
• The Art of Assembly Language Programming [5], [6] by Randall Hyde
• Computer-Books.us [7], Online Assembly Language Brooks
• PC Assembly Language(español) [8] by Dr Paul Carter; *PC Assembly Tutorial using NASM and GCC [9] by
Paul Carter
• Programming from the Ground Up [10] by Jonathan Bartlett
• The ASM Book [11] by the ASM Community [12]
• Inline::ASM [13] módulo Perl en CPAN para programar en lenguaje Assembly dentro de programas Perl (en
inglés)
• Ejemplos prácticos de Assembly en GNU/Linux [14]
• KolibriOS [15] Un sistema operativo completamente programado en lenguaje Assembly para la arquitectura x86

Referencias
[1] David Salomon, Assemblers and Loaders. 1993 (http:/ / www. davidsalomon. name/ assem. advertis/ asl. pdf)
[2] Pipeline en inglés.
[3] Principles of Computer Architecture (http:/ / iiusaedu. com/ ~murdocca/ POCA) (POCA) – ARCTools computadora virtual disponible para
descarga y ejecución del código, acceso el 24 de agosto de 2005
[4] Murdocca, Miles J. y Heuring, Vincent P.:Principles of Computer Architecture (2000), Prentice Hall, ISBN 0-201-43664-7
[5] http:/ / cs. smith. edu/ ~thiebaut/ ArtOfAssembly/ artofasm. html
[6] http:/ / www. arl. wustl. edu/ ~lockwood/ class/ cs306/ books/ artofasm/ toc. html
[7] http:/ / www. computer-books. us/ assembler. php
[8] http:/ / www. drpaulcarter. com/ pcasm/ pcasm-book-spanish. zip
[9] http:/ / drpaulcarter. com/ pcasm/
[10] http:/ / savannah. nongnu. org/ projects/ pgubook/
[11] http:/ / www. asmcommunity. net/ book/
[12] http:/ / www. asmcommunity. net
[13] http:/ / search. cpan. org/ perldoc?Inline::ASM
[14] http:/ / snippets-tricks. org/ topicos/ programacion/ ensamblador/
[15] http:/ / www. kolibrios. org/
Fuentes y contribuyentes del artículo 7

Fuentes y contribuyentes del artículo

Lenguaje ensamblador  Fuente: http://es.wikipedia.org/w/index.php?oldid=39021533  Contribuyentes: Airunp, Albertochoa, Andreasmperu, Antur, Biasoli, Codename, Diegusjaimes, Digigalos,
Elabra sanchez, Emijrp, FrancoGG, Gades21, GermanX, Gothmog, Hann, Isha, Jesuja, JoaquinFerrero, JorgeGG, Jugones55, Jynus, Kbradero, Kved, Laura Fiorucci, Lentucky, Locovich,
Maldoror, ManuelGR, Manwë, Marvelshine, Matdrodes, MatiasBellone, Moriel, Mrisco, Muro de Aguas, Netito777, Oespinosa, Piero71, Pilaf, Platonides, Porao, Qwertyytrewqqwerty, Rafiko77,
Sabbut, Sanbec, Santiperez, Scapegoat001, Segedano, Surfaz, Tirithel, Tomatejc, Triku, Vitamine, Vizcarra, X.Cyclop, Z80user, ^CiViLoN^, 152 ediciones anónimas

Fuentes de imagen, Licencias y contribuyentes

Archivo:Codigo de maquina.png  Fuente: http://es.wikipedia.org/w/index.php?title=Archivo:Codigo_de_maquina.png  Licencia: Public Domain  Contribuyentes: User:German
Image:Wikibooks-logo.svg  Fuente: http://es.wikipedia.org/w/index.php?title=Archivo:Wikibooks-logo.svg  Licencia: logo  Contribuyentes: User:Bastique, User:Ramac

Licencia
Creative Commons Attribution-Share Alike 3.0 Unported
http:/ / creativecommons. org/ licenses/ by-sa/ 3. 0/