INTEGRANTES:

Karina Solano
Ma.Dolores Defàz

INTRODUCCIÓN

Los ensambladores son programas que procesan los enunciados del programa origen
en lenguaje ensamblador y los traducen en archivos en lenguaje máquina que son
ejecutados por un microprocesador o un micro controlador.
Los ensambladores permiten que los programas origen se escriban y se editen en una
computadora para generar un código ejecutable en otra computadora. El archivo en
lenguaje objeto ejecutable resultante se carga y se ejecuta en el sistema destino.

DEFINICIONES BASICAS DE UN ENSAMBLADOR

El sistema alfanumérico para escribir código máquina mediante expresiones

abreviadas (mnemotécnicos).
La compilación es más complicada porque incluye la conversión de operaciones
matemáticas complejas, comandos de lenguaje natural o tipos de comandos
complejos.
Cada ordenador tiene su propio lenguaje ensamblador, exclusivo de su CPU; un
lenguaje de alto nivel (LAN) puede ser compilado en distintas máquinas.
Lenguaje de programación que está a un paso del lenguaje de máquina. El
ensamblador traduce cada sentencia del lenguaje ensamblador a una instrucción de
máquina. Los programadores deben estar bien familiarizados con la arquitectura del
computador, siendo los programas en lenguaje ensamblador no documentados
difíciles de mantener. El lenguaje ensamblador es dependiente del hardware; hay un
lenguaje ensamblador diferente para cada serie de CPU.
Tipo de herramienta que traduce un archivo de código fuente escrito en lenguaje
ensamblador, a un archivo objeto que puede ser ejecutado por la computadora.
El paso de un código fuente escrito en un lenguaje de programación cualquiera hacia
un archivo ejecutable es realizado por un compilador.
La operación inversa la realiza un desensamblador.
Lenguaje de máquina es el sistema de códigos directamente interpretable por un
circuito micro programable, como el microprocesador de una computadora o el micro
controlador de un autómata (un PLC) . Este lenguaje está compuesto por un conjunto
de instrucciones que determinan acciones a ser tomadas por la máquina. Un programa
de computadora consiste en una cadena de estas instrucciones de lenguaje de
máquina (más los datos). Estas instrucciones son normalmente ejecutadas en
secuencia, con eventuales cambios de flujo causados por el propio programa o
eventos externos. El lenguaje de máquina es específico de cada máquina o
arquitectura de la máquina, aunque el conjunto de instrucciones disponibles pueda ser
similar entre ellas.
Los circuitos micro programables son sistemas digitales, lo que significa que trabajan
con dos únicos niveles de tensión. Dichos niveles, por abstracción, se simbolizan con
el cero, 0, y el uno, 1, por eso el lenguaje de máquina sólo utiliza dichos signos. Esto
permite el empleo de las teorías del álgebra booleana y del sistema binario en el
diseño de este tipo de circuitos y en su programación.
ESTRUCTURA DE UN PROGRAMA

Un programa en lenguaje ensamblador estará formado por una secuencia de

sentencias. Cada sentencia ocupa una sola línea y tiene la siguiente estructura:
[Etiqueta] [Operación] [Operandos] [Comentarios]
Los cuatro campos de una sentencia son opcionales, si no aparece ninguno de ellos
(una línea en blanco) tendríamos una sentencia vacía.

Las sentencias se dividen en dos tipos:

 Instrucciones:

Estas sentencias representan órdenes al procesador y tras el proceso de compilación

generan código ejecutable.

 Directivas:

Estas sentencias dirigen el proceso de compilación o construcción del programa

ejecutable. No generan código ejecutable. Normalmente se utilizan para aumentar la
legibilidad del código fuente.
El fichero creado con todas las sentencias que constituyen un programa se denomina
fichero fuente. Este tipo de fichero tiene formato ASCII. Se recomienda que el fichero
de código fuente tenga por extensión .ens.
El fichero fuente se compila utilizando el programa ensamblador. El programa
ensamblador generará un nuevo fichero, denominado fichero ejecutable, de igual
nombre y de extensión .eje.
Este fichero tiene formato ASCII y contiene el código máquina de las instrucciones que
componen el programa, así como cierta información adicional para realizar la carga del
programa en el simulador del computador elemental.

Estructura de un fichero en lenguaje ensamblador

Los ficheros de código fuente escritos en lenguaje ensamblador se organizan en
líneas. Cada una de las líneas del fichero puede contener una directiva, una
instrucción o ambas cosas a la vez en los casos en que sea posible. El carácter
separador de líneas es el retorno de carro, por lo que una instrucción no podrá ocupar
más de una línea en el fichero fuente.
Todos los ficheros fuente tienen que adecuarse a una estructura fija dividida en
secciones.
La estructura a seguir se muestra a continuación:
Escala EQU 1000 ; Definición de constantes simbólicas
ORIGEN 7F40h ; Definición del origen de carga del programa
INICIO ini ; Definición de la etiqueta que marca la
; Primera instrucción a ejecutar del programa
.PILA 100h ; Definición de la pila
.DATOS ; Definición de los datos del programa
dato1 VALOR 12h
 …
.CODIGO ; Definición del código del programa
INI: MOV R5, R4
…

Comentamos algunas convenciones que usaremos:

 Los ficheros de código fuente llevarán la extensión *.ASM

 Los ficheros de listado llevarán la extensión *.LST

 Los ficheros de código objeto llevarán la extensión *.OB]

 Los ficheros de errores llevarán la extensión *.ERR

 Los ficheros ejecutables en formato Intel Hex llevarán la extensión *.HEX

 Comentario descriptivo del programa (utilizar una cabecera

estandarizada).

 Definir el microcontrolador que se usará (con las directivas LIST e

INCLUDE).

 Introducir las opciones de compilación (que serán vistas más adelante)

(opcional).

 Establecer las constantes que se usarán (con la directiva EQU).

 Reservar espacios de memoria (directiva RES) (si es necesario).

 Configurar los puertos.

 Desarrollar el programa con comentarios, en lo posible explicando cada

línea de código..

 Los mnemónicos escritos en minúscula y las constantes y variables en

mayúscula hacen que el código escrito sea más visible.

 Colocar las rutinas en el mismo sitio, todas contiguas.

 Dibujar diagramas de flujo o escribir seudocódigo.

    Su estructura en un programa ejemplo muy simple:

    Hemos visto la estructura general. Ahora veremos la posición de los

elementos del código por 4 columnas:

 Columna 1: Etiquetas. Las etiquetas se rigen por las siguientes normas:

 Debe situarse en la primera columna.

 Debe contener únicamente caracteres alfanuméricos.

 El máximo de caracteres es de 31.

 Columna 2: Operación. En esta columna se situarán las instrucciones.

El campo del código de operación es el único que nunca puede estar
vacío; éste siempre contiene una instrucción o una directiva del
ensamblador.
  Columna 3: Operandos El campo de operandos o de dirección puede
contener una dirección o un dato, o puede estar en blanco. Normalmente
contendrá registros o literales con los que se operará (f, l ok , b y w).

 Columna 4: Comentario. El campo del comentario o de etiquetas es

opcional. Aquí se situará cualquier comentario personalizado que
deseemos. Estos son útiles para saber qué hace un programa sin tener
que descifrar el código entero. El compilador (ensamblador) ignorará
todo texto más allá del carácter punto y coma ";".

    Los comentarios generalmente se sitúan en la cuarta columna para describir

la acción de una línea de código, pero pueden situarse en cualquier parte de
programa para describir cualquier otro evento, siempre que estén después del
carácter ";" (semicolon en inglés).

    Normalmente las columnas son separadas por una tabulación. El espacio

mínimo entre dos columnas es de un carácter, que puede ser un espacio en
vez de una tabulación.

Delimitadores (separación entre campos)

 Los campos van separados sólo con espacios y/o tabulaciones. No

agregue nunca otros caracteres (comas, puntos, etc.)

 No utilice espacios extra, particularmente después de comas que

separan operandos.( Ejemplo: movlw 5, w )

 No use caracteres delimitadores (espacios y tabulaciones) en nombres o

etiquetas.

INSTRUCCIONES BÁSICAS EN ENSAMBLADOR

Seguimos con nuestro mini-curso de asm. Hoy vamos a hablar de los registros y el
conjunto de instrucciones “básicas”. Sé que va a ser un poco latazo, pero no tenemos
más remedio hacerlo.

REGISTROS

Ya dijimos en su momento que, para que nos entendamos, los registros son como
nuestras “variables nativas”.

Disponemos de 8 registros de 32-bits de propósito general, que son los siguientes:

eax (accumulation register): cuando llamamos a una función del sistema, el código de
retorno va normalmente en eax (0=SUCCESS por lo general).
ebx (base register)
ecx (count register): el contador, usado para manejar strings, bucles ...
edx (data register)
esi, edi (source index, destination index): se suelen usar como punteros para ir
recorriendo strings o zonas de memoria
ebp (base pointer): apunta a la base del stack
esp (stack pointer): apunta al último elemento metido en el stack

Para nosotros, la regla genérica será: preservar el valor de los registros y luego
usarlos para lo que nos de la gana. Nada nos impide usar eax como si fuera el stack
register, siempre y cuando tengamos cuidado de ir actualizando todo.

Aparte, para preservar en su momento la compatibilidad con las CPUs de 16-bits, los
registros de 32-bits se subdividen en partes de 16 y 8 bits, que son las siguientes:

Lo mismo aplicaría a ebx, ecx y edx. Sin embargo, ebp, esp, edi y esi sólo tienen un
subregistro de 16 bits (bp, sp, di y si respectivamente).

Aparte de estos registros, tenemos también los segment-registers, de los que

hablaremos en otro momento para no liar todavía más esto, y un registro especial que
contiene los flags de la cpu, EFLAGS. En éste, la CPU guarda distintos flags, como
por ejemplo el ZF (zero flag), que indica si el resultado de la última operación ha sido
cero, o el CF (carry flag), que es el “y llevo una” de toda la vida.

Estos flags sirven para meter saltos condicionales en el código, como veremos más
adelante.

INSTRUCCIONES BÁSICAS

Aquí lo mejor es ir viendo ejemplos:

xor eax, eax; hace un or exclusivoeax con eax y el resultado lo guarda en eax
xor ebx, eax; hace un or exclusivo de ebx con eax y el resultado lo mete en ebx

add eax, esi; suma a eax el valor de esi

sub, edi, ebp; resta de edi el valor de ebp
add eax, 0x712A119F; suma a eax la constante 0x712A119F
sub eax, 0x712A119F; resta de eax ...

inc eax; incrementa el valor de eax

dec eax; decrementa el valor de eax

mov eax, ebx: mueve ebx a eax

mov eax, eax: en realidad no hace nada ... mueve eax a eax
nop: una instrucción especial que sirve para gastar un ciclo de CPU sin hacer nada.
Son los 0x90 que vemos en los shellcodes.
mov eax, [ecx]: mueve a eax el contenido de la dirección de memoria ecx
mov eax, [0x7438aaFF]: mueve a eax el contenido de la dirección de memoria
0x7438aaFF
mov eax, [ebx+ecx]: mueve a eax el contenido de la dirección de memoria ebx+ecx

push edi; envía el valor de edi al stack, y además el valor de esp baja en 4 para que
apunte al nuevo elemento.
pop edi; mete el contenido del stack en edi y aumenta esp en 4 para que apunte al
valor anterior almacenado en el stack.

Así pues, pop edi es lo mismo que:

mov edi, [esp]; los corchetes indican “contenido de”
add esp, 4

Push 0x712A119F; envía la constante 0x712A119F al stack, el valor de esp se

actualiza.

jmp 0x712A119F: salta a la dirección 0x712A119F

jmp eax: salta a eax
jmp [eax+edx]: salta a la dirección apuntada por el valor de eax+edx

También tenemos saltos condicionales, como esto:

cmp eax, esp; comparamos eax con esp

je eax: salta a eax si eax es igual que esp
jne ebx: si no es igual salta a ebx

Y esta se usa mucha como método rápido de guardar el valor de algún registro:
xchg eax, ebx; intercambia los valores de eax y ebx

La instrucción call, que ya la vimos en el tutorial anterior, lo que hace es enviar al stack
la dirección de retorno, que es la siguiente al call, y saltar a la función. Es decir, estos
dos bloques de instrucciones son equivalentes:

; bloque 1
call eax
retorno:

; bloque 2
push addr retorno
jmp eax
retorno:

Como podéis imaginar, “retorno” es una etiqueta. El pre-compilador se encargará de

meter allí el offset (dirección) que corresponda.

Finalmente, la instrucción ret es la que se usa para volver de las llamadas a las
funciones. Lo que hace es leer la dirección a la que tiene que volver del stack y saltar
allí. Es decir, es lo mismo que:

jmp [esp]
add esp, 4

Así mismo, no debemos olvidar que todas estas instrucciones también existen en sus
versiones de 8 y 16 bits (bueno, todas no... pero la mayoría sí). Por ejemplo:

xor al, ah
mov bl, cl
inc cl
mov al, 0x90

Teniendo cuidado de que el tamaño de que el tamaño del origen y el destino sea el
mismo.

Iremos comentando nuevas instrucciones pero sólo conforme vayan saliendo, para
hacer esto un poco más o menos... Con lo visto en este tutorial, tenemos suficiente
más que suficiente para empezar a programar.

EJERCICIOS

SUMA, RESTA, MULTIPLICACION, DIVISION.

SUMAR DOS NUMEROS DE DOS DIGITOS EN LENGUAJE ENSAMBLOR
Programa que suma dos numeros cada uno de dos dígitos
; y le aplica el ajuste en ASCII para separar en

bcd el
; resultado
.modeltiny
.stack
.data
Msgdb’Echame los numeros a sumar $'

.code
.startup
movah,09h;interrupcion para imprimir una cadena
leadx,msg;entenemos la dirección de memoria de ms

int 21h ;ejecutamos la interrupción

 
movah,01h;interr. lee el carácter 1 del número 1
int 21h ;ejecutamos la interrupción

subal,30h ;hacemos el ajuste de carácter a numero

movbl,al;guardamos el numero en bl
 

int 21h ;lee el carácter 2 del número 1

subal,30h ;ajustamos el numero
movcl,al;copeamos a cl

 
int 21h ;lee el carácter 1 del número 2
subal,30h ;ajustamos el numero
addbl,al;lo sumamos a las decenas

 
int 21h ;lee el carácter 2 del número 2
subal,30h ;ajustamos el numero
addcl,al;sumamos a las unidades

movax,cx;pasamos el R para convertirlo BCD

aaa;convierte BCD
movcx,ax;respaldamos el resultado separado

 
addbl,ch;sumamos el acarreo a las decenas
movax,bx;pasamosax para convertir a BCD

aaa;convertimos BCD separado

movbx,ax;respaldamos el resultado
movdl,bh;muevo las centenas a dl

adddl,30h ;ajusto las centenas

movah,02h;interr. mostrar un carácter
int 21h ;muestra las centenas en pantalla

 
movdl,bl;muevo las decenas a dl
adddl,30h ;ajusto las decenas

int 21h ;muestro las decenas

 
movdl,cl;muevo las unidades a dl
adddl,30h ;ajusto las unidades

int 21h ;muestro las unidades

 
.exit
End

RESTAR DOS NUMEROS EN LENGUAJE ENSAMBLADOR

invokewrite, addrsalt
invokewrite, addr num1 ;mensaje del primer valor
 
call leer ;lee un número
movEbx,numero;muevo al a bl
 
invokewrite, addrsalt
invokewrite, addr num2 ;mensaje del segundo valor
 
call leer ;lee un numero
sub Ebx,numero;sumo bl - al
movnumero,Ebx
invokewrite, addrsalt
invokewrite, addr res ;mensaje del resultado
 
call mostrar ;muestra el resultado
 
callreadc ;espero a que presione tecla
 
jmp repite

invokewrite, addrsalt
invokewrite, addr num1 ;mensaje del primer valor
 
call leer ;lee un número
movEbx,numero;muevo al a bl
 
invokewrite, addrsalt
invokewrite, addr num2 ;mensaje del segundo valor
 
call leer ;lee un numero
sub Ebx,numero;sumo bl - al
movnumero,Ebx
 
invokewrite, addrsalt
invokewrite, addr res ;mensaje del resultado
 
call mostrar ;muestra el resultado
 
callreadc ;espero a que presione tecla
 
jmp repite

MULTIPLICACION DE LENGUAJE ENSAMBLADOR

.modelsmall
.stack
.data
.code
   chr1  db ?
   chr2  db ?
   chr3  db ?
 r1    db ?
   r2    db ?
 ac    db0
.startup
 ;cls
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video
 
   mov ah,01h     ;Function(character read)
   int 21h        ;Interruption DOS functions
   sub al,30h     ;ajustamos valores
   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2
  
   mov ah,01h     ;Function(character read)
   int 21h        ;Interruption DOS functions
   sub al,30h     ;Ajustamos valores
   mov chr2,al    ;chr1.[chr2]* chr3 = ac.r1.r2
  
   mov ah,02h     ;Function(character to send to standard output)
   movdl,'*'     ;Character to show
   int 21h
  
   mov ah,01h     ;Function(Read character)
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr3,al    ;chr1.chr2 *[chr3]= ac.r1.r2
  
   mov ah,02h     ;Character to send to standar output
   movdl,'='     ;
   int 21h        ;Interruption DOS functions
  
   ;Realizamos operación
  
   mov al,chr3    ;al = chr3
   mov bl,chr2    ;bl= chr2
   mulbl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCIIAdjusment
   movac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)
  
   mov al,chr3    ;AL = chr3
   mov bl,chr1    ;BL = chr1
   mulbl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   movbl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignación para el ajust)
   AAM            ;ASCIIAdjustment
   mov r1,al      ;r1 = AL
   movac,ah      ;ac= AH (Acarreo para la Centena del resultado)
  
   ;Mostramos resultado
   mov ah,02h    
   movdl,ac
   adddl,30h
   int 21h        ;Mostramos ac(Centena)
 
   mov ah,02H
   movdl,r1
   adddl,30h
   int 21h        ;Mostramos r1 (Decena)
 
   mov ah,02H
   movdl,r2
   adddl,30h
   int 21h        ;Mostramos r2 (Unidad)
.exit
End

DIVISION DE LENGUAJE ENSAMBLADOR

invokewrite, addrsalt
invokewrite, addr num1 ;mensaje del primer valor
 
call leer ;lee un número
movEbx,numero;muevo al a bl
 
invokewrite, addrsalt
invokewrite, addr num2 ;mensaje del segundo valor
 
call leer ;lee un número
movEax,Ebx
movEbx,número
 
div Ebx ;sumo bl / al
movnumero,Eax ;respaldo
movEbx,Edx
 
invokewrite, addrsalt
invokewrite, addr res ;mensaje del resultado
 
call mostrar ;muestra el resultado
 
invokewrite, addrresi;mensaje de residuo
 
movnumero,Ebx
call mostrar ;muestra el residuo
 
callreadc ;espero a que pecione tecla
 
jmp repite

FUENTES DE CONSULTA
*Internet
*Apuntes

BIBLIOGRAFIA
 http://www.google.com/search?
hl=es&source=hp&q=introduccion+DE+UN+ENSAMBLADOR&lr=&aq=f&
aqi=&aql=&oq=
 http://www.abreojosensamblador.net/html/Pags/Cap20.html
 http://www.alegsa.com.ar/Dic/compilador.php
 http://www.monografias.com/trabajos11/compil/compil.shtml
 http://www.mastermagazine.info/termino/4368.php