50746990-ENSAMBLADOR

Instituto Tecnológico Superior de Informática “Ibarra”

TEMA: ENSAMBLADOR

INTEGRANTES: JENNIFER PÉREZ

MERCEDES ENRÍQUEZ

NIVEL: 3º SISTEMAS DIURNO

FECHA: 14/03/2011

LIC: JORGE VIVERO

Realizado por: JENNIFER PÉREZ Y MERCEDES ENRÍQUEZ Página 1

TRABAJO

DE ORGANIZACIÓN

DE COMPUTADORAS


INTRODUCCIÓN AL ENSAMBLADOR:

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

Es usado principalmente porque hay aplicaciones o programas que deben tratar directamente con los registros de la máquina, la memoria, dispositivos de E/S, etc.

PROCESOS PARA LA CREACIÓN DE UN PROGRAMA:

Para la creación de un programa es necesario seguir cinco pasos: Diseño del algoritmo, codificación del mismo, su traducción a lenguaje máquina, la prueba del programa y la depuración. En la etapa de diseño se plantea el problema a resolver y se propone la mejor solución, creando diagramas esquemáticos utilizados para el mejor planteamiento de la solución. La codificación del programa consiste en escribir el programa en algún lenguaje de programación (en este caso en ensamblador

8086), tomando como base la solución propuesta en el paso anterior. La traducción al lenguaje máquina es la creación del programa objeto, esto es, el programa escrito como una secuencia de ceros y unos que pueda ser interpretado por el procesador. La prueba del programa consiste en verificar que el programa funcione sin errores, o sea, que haga lo que


ENSAMBLADOR


tiene que hacer. La última etapa es la eliminación de las fallas detectadas en el programa durante la fase de prueba. La corrección de una falla normalmente requiere la repetición de los pasos comenzando desde el primero o el segundo. Para crear un programa en ensamblador utilizararemos el debugger, que se encuentra en cualquier PC con el sistema operativo MS-DOS, lo cual lo pone al alcance de cualquier usuario que tenga acceso a una máquina con estas características. Debug solo puede crear archivos con extensión .EXE, y por las características de este tipo de programas no pueden ser mayores de 64 kb, además deben comenzar en el desplazamiento, offset, o dirección de memoria 0100Hh dentro del segmento específico.

DEFINICIÓN BASICA

El término ensamblador (del inglés assembler) se refiere a un tipo de programa informático que se encarga de traducir un fichero fuente escrito en un lenguaje ensamblador, a un fichero objeto que contiene código máquina, ejecutable directamente por la máquina para la que se ha generado. El propósito para el que se crearon este tipo de aplicaciones es la de facilitar la escritura de programas, ya que escribir directamente en código binario, que es el único código entendible por la computadora, es en la práctica imposible. La evolución de los lenguajes de programación a partir del lenguaje ensamblador originó también la evolución de este programa ensamblador hacia lo que se conoce como programa compilador.

FUNCIONAMIENTO

El programa lee el fichero escrito en lenguaje ensamblador y sustituye cada uno de los códigos nemotécnicos que aparecen por su código de operación correspondiente en sistema binario para la plataforma que se eligió como destino en las opciones específicas del ensamblador.cc


http://es.wikipedia.org/wiki/Compilador

http://es.wikipedia.org/wiki/C%C3%B3digo_binario

http://es.wikipedia.org/wiki/Microprocesador

http://es.wikipedia.org/wiki/C%C3%B3digo_m%C3%A1quina

http://es.wikipedia.org/wiki/C%C3%B3digo_m%C3%A1quina

http://es.wikipedia.org/wiki/Fichero_objeto

http://es.wikipedia.org/wiki/Lenguaje_ensamblador

http://es.wikipedia.org/wiki/Fichero_fuente

http://es.wikipedia.org/wiki/Programa_(computaci%C3%B3n)


TIPOS DE ENSAMBLADORES

Podemos distinguir entre tres tipos de ensambladores:

Ensambladores básicos. Son de muy bajo nivel, y su tarea consiste básicamente en ofrecer nombres simbólicos a las distintas instrucciones, parámetros y cosas tales como los modos de direccionamiento. Además, reconoce una serie de directivas (o meta instrucciones) que indican ciertos parámetros de funcionamiento del ensamblador.

Ensambladores modulares, o macro ensambladores. Descendientes de los ensambladores básicos, fueron muy populares en las décadas de los 50 y los 60, antes de la generalización de los lenguajes de alto nivel. Hacen todo lo que puede hacer un ensamblador, y además proporcionan una serie de directivas para definir e invocar macroinstrucciones (o simplemente, macros). Véase X86.

Ensambladores modulares 32-bits o de alto nivel. Son ensambladores que aparecieron como respuesta a una nueva arquitectura de procesadores de 32 bits, muchos de ellos teniendo compatibilidad hacia atrás pudiendo trabajar con programas con estructuras de 16 bits. Además de realizar la misma tarea que los anteriores, permitiendo también el uso de macros, permiten utilizar estructuras de programación más complejas propias de los lenguajes de alto nivel.

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


http://es.wikipedia.org/wiki/X86

http://es.wikipedia.org/wiki/Macroinstrucci%C3%B3n

http://es.wikipedia.org/wiki/Lenguaje_de_alto_nivel

http://es.wikipedia.org/wiki/1960s

http://es.wikipedia.org/wiki/1950s

http://es.wikipedia.org/wiki/Macro_ensamblador

http://es.wikipedia.org/w/index.php?title=Meta_instrucciones&action=edit&redlink=1

http://es.wikipedia.org/wiki/Instrucci%C3%B3n


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.

Típicamente, 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.


http://es.wikipedia.org/wiki/Segmentaci%C3%B3n_(inform%C3%A1tica)

http://es.wikipedia.org/w/index.php?title=Planificaci%C3%B3n_de_instrucciones&action=edit&redlink=1

http://es.wikipedia.org/w/index.php?title=Planificaci%C3%B3n_de_instrucciones&action=edit&redlink=1

http://es.wikipedia.org/wiki/X86-64

http://es.wikipedia.org/wiki/X86

http://es.wikipedia.org/wiki/PA-RISC

http://es.wikipedia.org/wiki/SPARC

http://es.wikipedia.org/wiki/MIPS

http://es.wikipedia.org/wiki/RISC

http://es.wikipedia.org/wiki/Lenguajes_de_alto_nivel


http://es.wikipedia.org/wiki/Subrutina

http://es.wikipedia.org/w/index.php?title=Expansi%C3%B3n_en_l%C3%ADnea&action=edit&redlink=1

http://es.wikipedia.org/wiki/Macro

http://es.wikipedia.org/wiki/Lenguaje_ensamblador#cite_note-0

http://es.wikipedia.org/w/index.php?title=Nombre_simb%C3%B3lico&action=edit&redlink=1

http://es.wikipedia.org/wiki/Opcode

http://es.wikipedia.org/wiki/Mnem%C3%B3nico

http://es.wikipedia.org/wiki/C%C3%B3digo_objeto

http://es.wikipedia.org/wiki/Ensamblador


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

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.


http://es.wikipedia.org/wiki/Microprocesador

http://es.wikipedia.org/wiki/AT%26T

http://es.wikipedia.org/wiki/Intel

http://es.wikipedia.org/w/index.php?title=Sintaxis_(programaci%C3%B3n)&action=edit&redlink=1

http://es.wikipedia.org/wiki/Lenguaje_de_alto_nivel

http://es.wikipedia.org/wiki/Desensamblador




PROCESAMIENTO DE ENSAMBLADO

Este ensamblador es de dos pasadas.

Durante la primera pasada, el programa origen se lee para desarrollar la tabla de símbolos.

Durante la segunda pasada el archivo objeto se crea (ensamblado) con referencia a la tabla desarrollada en la primera pasada.

Durante la segunda pasada se crea el listado del programa origen.

Cada enunciado origen se procesa completamente antes de que el enunciado siguiente se lea.

A medida que el enunciado se procesa el ensamblador examina los campos de etiqueta, de código de operación y de operando.

La tabla de códigos de operación se revisa para encontrar un código operacional similar.

Durante el procesamiento de un mnemónico correspondiente a un código de operación normal, el código máquina normal se inserta en el archivo objetivo.



La acción buscada por una directriz del ensamblador ocurre durante el procesamiento de dicha directriz.

Cualquier error que detecta el ensamblador se muestra justamente antes de la línea que contiene dicho error.

Aún y cuando no se desee producir un listado origen, los errores se despliegan para indicar que el procesamiento de ensamblado no se llevó a cabo de manera normal.

VENTAJAS Y DESVENTAJAS DE UN ENSAMBLADOR

VENTAJAS

1. .- Como trabaja directamente con el microprocesador al ejecutar un programa, pues como este lenguaje es el más cercano a la máquina la computadora lo procesa más rápido.

2. Eficiencia de tamaño .- Un programa en ensamblador no ocupa mucho espacio en memoria porque no tiene que cargan librerías y demás como son los lenguajes de alto nivel.

3. Flexibilidad .- Es flexible porque todo lo que puede hacerse con una máquina, puede hacerse en el lenguaje ensamblador de esta máquina; los lenguajes de alto nivel tienen en una u otra forma limitantes para explotar al máximo los recursos de la máquina. O sea que en lenguaje ensamblador se pueden hacer tareas específicas que en un lenguaje de alto nivel no se pueden llevar acabo porque tienen ciertas limitantes que no se lo permite.

DESVENTAJASTiempo de programación .- Como es un lenguaje de bajo nivel requiere más instrucciones para realizar el mismo proceso, en comparación con un lenguaje de alto nivel. Por otro lado, requiere de más cuidado por parte


http://www.monografias.com/trabajos14/administ-procesos/administ-procesos.shtml#PROCE

http://www.sinergia-web.com.mx/clases/asm9708/Temas/#tiempo

http://www.monografias.com/trabajos4/refrec/refrec.shtml

http://www.monografias.com/trabajos16/desarrollo-del-lenguaje/desarrollo-del-lenguaje.shtml

http://www.sinergia-web.com.mx/clases/asm9708/Temas/#flexibilidad

http://www.sinergia-web.com.mx/clases/asm9708/Temas/#tamano

http://www.monografias.com/trabajos15/computadoras/computadoras.shtml


http://www.monografias.com/Computacion/Programacion/


del programador, pues es propenso a que los errores de lógica se reflejen más fuertemente en la ejecución.Programas fuente grandes .- Por las mismas razones que aumenta el tiempo, crecen los programas fuentes; simplemente requerimos más instrucciones primitivas para describir procesos equivalentes. Esto es una desventaja porque dificulta el mantenimiento de los programas, y nuevamente reduce la productividad de los programadores.Peligro de afectar recursos inesperadamente .- Que todo error que podamos cometer, o todo riesgo que podamos tener, podemos afectar los recursos de la máquina, programar en este lenguaje lo más común que pueda pasar es que la máquina se bloquee o se reinicialice. Porque con este lenguaje es perfectamente posible (y sencillo) realizar secuencias de instrucciones inválidas, que normalmente no aparecen al usar un lenguaje de alto nivel.Falta de portabilidad.- Porque para cada máquina existe un lenguaje ensamblador; por ello, evidentemente no es una selección apropiada de lenguaje cuando deseamos codificar en una máquina y luego llevar los programas a otros sistemas operativos o modelos de computadoras.

REGISTROS INTERNOS DE LA UNIDAD CENTRAL DE PROCESO (UCP):

La UCP o CPU tiene 14 registros internos, cada uno de ellos de 16 bits (una palabra). Los bits están enumerados de derecha a izquierda, de tal modo que el bit menos significativo es el bit 0.

Los registros se pueden clasificar de la siguiente forma:

Registros de datos:

AX: Registro acumulador. Es el principal empleado en las operaciones aritméticas.

BX: Registro base. Se usa para indicar un desplazamiento.

CX: Registro contador. Se usa como contador en los bucles.

DX: Registro de datos. También se usa en las operaciones aritméticas.



http://www.monografias.com/trabajos/adolmodin/adolmodin.shtml

http://www.monografias.com/trabajos11/teosis/teosis.shtml

http://www.monografias.com/trabajos5/selpe/selpe.shtml

http://www.sinergia-web.com.mx/clases/asm9708/Temas/#portabilidad

http://www.monografias.com/trabajos13/ripa/ripa.shtml

http://www.sinergia-web.com.mx/clases/asm9708/Temas/#afectar

http://www.monografias.com/trabajos6/prod/prod.shtml

http://www.monografias.com/trabajos15/mantenimiento-industrial/mantenimiento-industrial.shtml

http://www.monografias.com/trabajos14/administ-procesos/administ-procesos.shtml#PROCE

http://www.monografias.com/trabajos10/formulac/formulac.shtml#FUNC

http://www.monografias.com/trabajos901/evolucion-historica-concepciones-tiempo/evolucion-historica-concepciones-tiempo.shtml

http://www.sinergia-web.com.mx/clases/asm9708/Temas/#fuentegrande

http://www.monografias.com/trabajos15/logica-metodologia/logica-metodologia.shtml


Estos registros son de uso general y también pueden ser utilizados como registros de 8 bits, para utilizarlos como tales es necesario referirse a ellos como por ejemplo: AH y AL, que son los bytes alto (high) y bajo (low) del registro AX. Esta nomenclatura es aplicable también a los registros BX, CX y DX.

Registros de segmentos:

CS: Registro de segmento de código. Contiene la dirección de las instrucciones del programa.

DS: Registro segmento de datos. Contiene la dirección del área de memoria donde se encuentran los datos del programa.

SS: Registro segmento de pila. Contiene la dirección del segmento de pila. La pila es un espacio de memoria temporal que se usa para almacenar valores de 16 bits (palabras).

ES: Registro segmento extra. Contiene la dirección del segmento extra. Se trata de un segmento de datos adicional que se utiliza para superar la limitación de los 64Kb del segmento de datos y para hacer transferencias de datos entre segmentos.

Registros punteros de pila:

SP: Puntero de la pila. Contiene la dirección relativa al segmento de la pila.

BP: Puntero base. Se utiliza para fijar el puntero de pila y así poder acceder a los elementos de la pila.

Registros índices:

SI: Índice fuente.



DI: Índice destino.

Puntero de instrucciones:

IP: Registro puntero de instrucción o contador de programa (PC). Contiene el desplazamiento de la siguiente instrucción a ejecutar respecto al segmento de código en ejecución. Por lo tanto, la dirección completa de la siguiente instrucción sería CS:IP. La única forma de influir en este registro es de forma indirecta mediante instrucciones de bifurcación.

Registro de banderas (flags):

Cada bandera es un bit y se usa para registrar la información de estado y de control de las operaciones del microprocesador. Hay nueve banderas (los 7 bits restantes no se utilizan):

Banderas de estado: Registran el estado del procesador, normalmente asociado a una comparación o a una instrucción aritmética.

CF: Bandera de acareo.

OF: Bandera de desbordamiento (aritmético).

ZF: Bandera de resultado 0 o comparación igual.

SF: Bandera de resultado o comparación negativa.

PF: Bandera de paridad (número par de bits).

AF: Bandera auxiliar. Indica si hay necesidad de ajuste en las operaciones aritméticas con números

BCD.

Banderas de control:

DF: Bandera de dirección. Controla la dirección de las operaciones con cadenas de caracteres incrementando o excrementando automáticamente los registros índices (SI y DI)



IF: Bandera de interrupciones. Indica si están permitidas o no las interrupciones de los dispositivos externos.

TF: Bandera de atrape. Controla la operación de modo paso a paso (usada por el programa DEBUG).

SEGMENTOS Y REGISTROS ASOCIADOS:

La arquitectura de los procesadores x86 obliga al uso de segmentos de memoria para manejar la información, el tamaño de estos segmentos es de 64kb. La razón de ser de estos segmentos es que, considerando que el tamaño máximo de un número que puede manejar el procesador está dado por una palabra de 16 bits o registro, no sería posible accesar a más de 65536 localidades de memoria utilizando uno solo de estos registros, ahora, si se divide la memoria de la pc en grupos o segmentos, cada uno de 65536 localidades, y utilizamos una dirección en un registro exclusivo para localizar cada segmento, y entonces cada dirección de una casilla específica la formamos con dos registros, nos es posible acceder a una cantidad de 4294967296 bytes de memoria, lo cual es, en la actualidad, más memoria de la que veremos instalada en una PC. Para que el ensamblador pueda manejar los datos es necesario que cada dato o instrucción se encuentren localizados en el área que corresponde a sus respectivos segmentos. El ensamblador accede a esta información tomando en cuenta la localización del segmento, dada por los registros DS, ES, SS y CS, y dentro de dicho registro la dirección del dato específico. Es por ello que cuando creamos un programa empleando el Debug en cada línea que vamos ensamblando aparece algo parecido a lo siguiente:

1CB0:0102 MOV AX, BX

En donde el primer número, 1CB0, corresponde al segmento de memoria que se está utilizando, el segundo se refiere la dirección dentro de dicho



segmento, y a continuación aparecen las instrucciones que se almacenaran a partir de esa dirección.

La forma de indicarle al ensamblador con cuales de los segmentos se va a trabajar es por medio de las directivas .CODE, .DATA y .STACK.

El ensamblador se encarga de ajustar el tamaño de los segmentos tomando como base el número de bytes que necesita cada instrucción que va ensamblando, ya que sería un desperdicio de memoria utilizar los segmentos completos. Por ejemplo, si un programa únicamente necesita 10kb para almacenar los datos, el segmento de datos únicamente será de 10kb y no de los 64kb que puede manejar.

Un programa consta de 4 tipos de segmentos. Cada segmento se direcciona mediante un determinado tipo de registro de segmento:

Segmento código: Cada instrucción se direcciona mediante el registro segmento de código y el registro de desplazamiento IP, CS: IP.

Segmento de datos: Los datos de direccionan mediante el registro de segmento de dato y un registro de desplazamiento (BX, SI o DI), por ejemplo DS: BX.

Segmento de pila: Los datos se direccionan mediante el registro segmento de pila y un registro de desplazamiento (SP o BP), por ejemplo SS: SP.

Segmento extra: Igual que el de datos, sustituyendo el registro de segmento, por ejemplo ES: BX.

SOFTWARE NECESARIO:



Para poder crear un programa se requieren varias herramientas: Primero un editor para crear el programa fuente. Segundo un compilador (Turbo Assembler) que no es más que un programa que

"traduce" el programa fuente a un programa objeto. Y tercero un enlazador (Turbo Linker), que genere el programa ejecutable a partir del programa objeto. El editor puede ser cualquier editor de textos que se tenga a la mano, como compilador utilizaremos el programa Turbo Assembler (TASM), y como enlazador utilizaremos el Turbo Link (TLINK). La extensión usada para que el TASM reconozca

los programas fuente en ensamblador es .ASM, una vez traducido el programa fuente, el TASM crea un archivo con la extensión .OBJ, este archivo contiene un "formato intermedio" del programa, llamado así porque aún no es ejecutable pero tampoco es ya un programa en lenguaje fuente. El enlazador genera, a partir de un archivo .OBJ o la combinación de varios de estos archivos, un programa ejecutable, cuya extensión es .EXE.

LA ESTRUCTURA DEL ENSAMBLADOR:

En el lenguaje ensamblador las líneas de código constan de dos partes, la primera es el nombre de la instrucción que se va a ejecutar y la segunda son los parámetros del comando u operando. Por ejemplo:

ADD ah bh

Aquí "ADD" es el comando a ejecutar (en este caso una adición o suma) y tanto "ah" como "bh" son los parámetros.

El nombre de las instrucciones en este lenguaje puede estar formado de 2 a 6 letras, a estas instrucciones también se les llama nombres mnemónicos o códigos de operación, ya que representan alguna función que habrá de realizar el procesador. Existen algunos comandos que no



requieren parámetros para su operación, así como otros que requieren solo un parámetro.

Algunas veces se utilizarán las instrucciones como sigue:

ADD al,[170]

Los corchetes en el segundo parámetro nos indican que vamos a trabajar con el contenido de la casilla de memoria número 170 y no con el valor 170, a esto se le conoce como direccionamiento directo (en la instrucción viene la dirección del objeto).

ESTRUCTURA

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 int ; 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 … FIN

ESTRUCTURA

TITLE p04asm1 (EXE) operaciones de mover y sumar;-----------------------------------------------------STACKSG SEGMENT PARA STACK ´Stack´ DW 32 DUP(0) STACKSG ENDS;-----------------------------------------------------DATASG SEGMENT PARA ´Data´ FLDA DW 250 FLDB DW 125 FLDC DW ?DATASG ENDS;-----------------------------------------------------CODESG SEGMENT PARA ´Code´



BEGIN PROC FAR ASSUME SS:STACKSG,DS:DATASG, CS:CODESG MOV AX,DATASG ; SE ASIGNA DIRECCION DE DATASG MOV DS,AX ; EN REGISTRO DS

MOV AX,FLDA ; MOVER 0250 A AX ADD AX,FLDB ; SUMAR 0125 A AX MOV FLDC,AX ; ALMACENAR SUMA EN FLDC MOV AX,4C00H ; SALIDA A DOS INT 21HBEGIN ENDP ; FIN DE PROCEDIMIENTOCODESG ENDS ; FIN DE SEGMENTOEND BEGIN ; FIN DE PROGRAMA

De todas las secciones posibles que pueden formar parte de una programa en lenguaje ensamblador, sólo será obligatoria la sección de definición del código del programa. Todas las demás secciones serán opcionales pudiendo estar presentes o no. Si aparece alguna de las secciones del esquema, tendrá que estar colocada en el orden indicado.

TÉCNICAS DE CODIFICACIÓN EN ENSAMBLADOR:

En ensamblador los bucle, condicionales, subrutinas y demás elementos se codifica de forma distinta de cómo se hace en otros lenguajes de alto nivel. A continuación describiremos algunas técnicas útiles para codificar las estructuras más usuales.

BUCLES:



Inicialización de un registro(a modo de contador) al nº de vueltas del bucle

Etiqueta: Primera instrucción del bucle

<Resto de instrucciones dentro del bucle>

decrementar el contador saltar a la etiqueta si el contador es mayor que cero

<Instrucciones fuera del bucle>

SALTOS CONDICIONALES:

Instrucción de comparación

Evaluar condición y si se cumple saltar a la etiqueta prefijada

<Instrucciones para el caso de no cumplirse la condición> saltar fuera del condicional

MACROS:

Declaración:

<nombre de la macro> MACRO

<instrucciones de la macro>

ENDM

Llamada:

<nombre de la macro>

SUBRUTINAS:

Declaración:



<nombre la de subrutina> PROC

<instrucciones de la subrutina>

RET

<nombre de la subrutina> ENDP

Llamada:

CALL <nombre de la subrutina>

INTERRUPCIONES:

Definición de interrupción:

Una interrupción es una instrucción que detiene la ejecución de un programa para permitir el uso de la UCP a un proceso prioritario.

Una vez concluido este último proceso se devuelve el control a la aplicación anterior. Por ejemplo, cuando estamos trabajando con un procesador de palabras y en ese momento llega un aviso de uno de los puertos de comunicaciones, se detiene temporalmente la aplicación que estábamos utilizando para permitir el uso del procesador al manejo de la información que está legando en ese momento. Una vez terminada la transferencia de información se reanudan las funciones normales del procesador de palabras. Las interrupciones ocurren muy seguido, sencillamente la interrupción que actualiza la hora del día ocurre aproximadamente 18 veces por segundo. Para lograr administrar todas estas interrupciones, la computadora cuenta con un espacio de memoria, llamado memoria baja, donde se almacenan las direcciones de cierta localidad de memoria donde se encuentran un juego de instrucciones que la UCP ejecutará para después regresar a la aplicación en proceso.

La sentencia para usar una interrupción en ensamblador es INT número. En el programa anterior hicimos uso de la interrupción número 21h para llamar a DOS.



A continuación describiremos los 3 tipos de interrupciones:

INTERRUPCIONES INTERNAS DE HARDWARE:

Las interrupciones internas son generadas por ciertos eventos que surgen durante la ejecución de un programa. Este tipo de interrupciones son manejadas en su totalidad por el hardware y no es posible modificarlas. Un ejemplo claro de este tipo de interrupciones es la que actualiza el contador del reloj interno de la computadora, el hardware hace el llamado a esta interrupción varias veces durante un segundo para mantener la hora actualizada. Aunque no podemos manejar directamente esta interrupción (no podemos controlar por software las actualizaciones del reloj), es posible utilizar sus efectos en la computadora para nuestro beneficio, por ejemplo para crear un "reloj virtual" actualizado continuamente gracias al contador del reloj interno. Únicamente debemos escribir un programa que lea el valor actual del contador y lo traduzca a un formato entendible para el usuario.

INTERRUPCIONES EXTERNAS DE HARDWARE:

Las interrupciones externas las generan los dispositivos periféricos, como pueden ser: teclado, impresoras, tarjetas de comunicaciones, etc. También son generadas por los coprocesadores. No es posible desactivar a las interrupciones externas. Estas interrupciones no son enviadas directamente a la UCP, sino que se mandan a un circuito integrado cuya función es exclusivamente manejar este tipo de interrupciones. El circuito, llamado PIC 8259A, si es controlado por la UCP utilizando para tal control una serie de vías de comunicación llamadas puertos.

INTERRUPCIONES DE SOFTWARE:

Las interrupciones de software pueden ser activadas directamente por el ensamblador invocando al número de interrupción deseada con la instrucción INT. El uso de las interrupciones nos ayuda en la creación de



programas, utilizándolas nuestros programas son más cortos, es más fácil entenderlos y usualmente tienen un mejor desempeño debido en gran parte a su menor tamaño. Este tipo de interrupciones podemos separarlas en dos categorías: las interrupciones del sistema operativo DOS y las interrupciones del BIOS. La diferencia entre ambas es que las interrupciones del sistema operativo son más fáciles de usar pero también son más lentas ya que estas interrupciones hacen uso del BIOS para lograr su cometido, en cambio las interrupciones del BIOS son mucho más rápidas pero tienen la desventaja que, como son parte del hardware son muy específicas y pueden variar dependiendo incluso de la marca del fabricante del circuito. La elección del tipo de interrupción a utilizar dependerá únicamente de las características que le quiera dar a su programa: velocidad (utilizando las del BIOS) o portabilidad (utilizando las del DOS).

INTERRUPCIÓN 21H

Propósito: Llamar a diversas funciones del DOS.

Sintaxis:

Int 21H

Nota: Cuando trabajamos en TASM es necesario especificar que el valor que estamos utilizando es hexadecimal. Esta interrupción tiene varias funciones, para acceder a cada una de ellas es necesario que el registro AH se encuentre el número de función que se requiera al momento de llamar a la interrupción.

SALTOS, CICLOS Y PROCEDIEMIENTOS:

Los saltos incondicionales en un programa escrito en lenguaje ensamblador están dados por la instrucción JMP, un salto es alterar el flujo de la ejecución de un programa enviando el control a la dirección



indicada. Un ciclo, conocido también como iteración o bucle, es la repetición de un proceso un cierto número de veces hasta que alguna condición se cumpla. En estos ciclos se utilizan los bifurcaciones "condicionales" basados en el estado de las banderas. Por ejemplo la instrucción JNZ que salta solamente si el resultado de una operación es diferente de cero y la instrucción JZ que salta si el resultado de la operación es cero. Por último tenemos los procedimientos o rutinas, que son una serie de pasos que se usarán repetidamente en el programa y en lugar de escribir todo el conjunto de pasos únicamente se les llama por medio de la instrucción CALL. Un procedimiento en ensamblador es aquel que inicie con la palabra PROC y termine con la palabra RET (ya explicado anteriormente).

Realmente lo que sucede con el uso de la instrucción call es que se guarda en la pila el registro IP y se carga la dirección del procedimiento en el mismo registro, conociendo que IP contiene la localización de la siguiente instrucción que ejecutara la UCP, entonces podemos darnos cuenta que se desvía el flujo del programa hacia la dirección especificada en este registro. Al momento en que se llega a la palabra ret se saca de la pila el valor de IP con lo que se devuelve el control al punto del programa donde se invocó al procedimiento. Es posible llamar a un procedimiento que se encuentre ubicado en otro segmento, para esto el contenido de CS (que nos indica que segmento se está utilizando) es empujado también en la pila.

MOVIENTO DE LOS DATOS:

En todo programa es necesario mover datos en la memoria y en los registros de la UCP; existen diversas formas de hacer esto: puede copiar datos de la memoria a algún registro, de registro a registro, de un registro



a una pila, de la pila a un registro, transmitir datos hacia dispositivos externos así como recibir datos de dichos dispositivos. Este movimiento de datos está sujeto a reglas y restricciones.

Algunas de ellas son las que se citan a continuación. No es posible mover datos de una localidad de memoria a otra directamente, es necesario primero mover los datos de la localidad origen hacia un registro y luego del registro a la localidad destino. No se puede mover una constante directamente a un registro de segmentos, primero se debe mover a un registro de la UCP. Es posible mover bloques de datos por medio de las instrucciones movs, que copia una cadena de bytes o palabras; movsb que copia n bytes de una localidad a otra; y movsw copia n palabras de una localidad a otra. Las dos últimas instrucciones toman los valores de las direcciones definidas por DS: SI como grupo de datos a mover y ES: DI como nueva localización de los datos. Para mover los datos también existen las estructuras llamadas pilas, en este tipo de estructuras los datos se introducen con la instrucción PUSH y se extraen con la instrucción POP. En una pila el primer dato introducido es el último que podemos sacar, esto es, si en nuestro programa utilizamos las instrucciones:

PUSH AX

PUSH BX

PUSH CX

Para devolver los valores correctos a cada registro al momento de sacarlos de la pila es necesario hacerlo en el siguiente orden:

POP CX

POP BX

POP AX



Para la comunicación con dispositivos externos se utilizan el comando out para mandar información a un puerto y el comando in para leer información recibida desde algún puerto.

LA SINTAXIS DEL COMANDO OUT ES:

OUT DX, AX

Donde DX contiene el valor del puerto que se utilizará para la comunicación y AX contiene la información que se mandará.

La sintaxis del comando in es:

IN AX, DX

Donde AX es el registro donde se guardará la información que llegue y DX contiene la dirección del puerto por donde llegará la información.

A continuación nos centraremos con la instrucción MOV, ya que es la más empleada para hacer transferencias de datos.

INSTRUCCIÓN MOV:

Propósito: Transferencia de datos entre celdas de memoria, registros y acumulador. Sintaxis:

MOV Destino, Fuente

Donde Destino es el lugar a donde se moverán los datos y fuente es el lugar donde se encuentran dichos datos. Los diferentes movimientos de datos permitidos para esta instrucción son:

Destino: memoria. Fuente: acumulador

Destino: acumulador. Fuente: memoria

Destino: registro de segmento. Fuente: memoria/registro

Destino: memoria/registro. Fuente: registro de segmento



Destino: registro. Fuente: registro

Destino: registro. Fuente: memoria

Destino: memoria. Fuente: registro

Destino: registro. Fuente: dato inmediato

Destino: memoria. Fuente: dato inmediato Ejemplo:

MOV AX,0006h

MOV BX,AX

MOV AH,4Ch

INT 21H

Este pequeño programa mueve el valor 0006H al registro AX, luego mueve el contenido de AX

(0006h) al registro BX, por último mueve el valor 4Ch al semiregistro AH (parte alta del registro de datos AX) para terminar la ejecución con la opción 4C de la interrupción 21h.

OPERACIONES LÓGICAS Y ARITMÉTICAS:

Las instrucciones de las operaciones lógicas son: AND, NOT, OR y XOR, éstas trabajan sobre los bits de sus operando. Para verificar el resultado de operaciones recurrimos a la instrucción CMP. Las instrucciones utilizadas para las operaciones algebraicas son: para sumar ADD, para restar SUB, para multiplicar MUL y para dividir DIV.

Casi todas las instrucciones de comparación están basadas en la información contenida en el registro de banderas. Normalmente las banderas de este registro que pueden ser directamente manipuladas por el programador son la bandera de dirección de datos DF, usada para definir



las operaciones sobre cadenas. Otra que también puede ser manipulada es la bandera IF por medio de las instrucciones STI y

CLI, para activar y desactivar respectivamente las interrupciones.

A continuación explicaremos brevemente las instrucciones aritméticas y lógicas por separado:

OPERACIONES ARITMÉTICAS:

Las operaciones en aritmética binaria a entera permiten a la CPU realizar cálculos con números enteros positivos y negativos con una representación en complemento a 2.

• NEG operando: cambia el signo del operando. Equivaldría al NOT del número y le sumaría 1.

• ADD destino, fuente: destino = destino + fuente.

• ADC destino, fuente: destino = destino + fuente + carry (acarreo).

• SUB destino, fuente: destino = destino - fuente.

• SBB destino, fuente: destino = destino - (fuente + acarreo).

• MUL operando: multiplica sin considerar el signo. Multiplica el acumulador {AL} o {AX}por el operando fuente. Si el operando fuente es de tipo byte, el resultado se almacena en AX y si es de tipo palabra el resultado se almacena en AX la parte inferior y en DX la palabra superior.

Si tipo fuente = byte:

AX = AL * fuente (multiplicación sin signo)

Si tipo fuente = palabra:

DX, AX = AX * fuente (multiplicación sin signo)



Si mitad superior (CF: acarreo) del resultado = 0

En CC CF = 1

• IMUL operando: multiplica considerando el signo.

• DIV operando: divide sin considerar el signo, un número contenido en el acumulador entre el operando fuente. El cociente se almacena en el acumulador. El resto se almacena en la extensión del acumulador. Si la extensión de AX será DX (que ocurrirá cuando sea de tipo palabra), la operación y la extensión de AL será AH.

AX

AX AL

DX

• IDIV operando: igual que el DIV pero considerando el signo.

• CBW: pasa de byte a palabra el contenido del acumulador.

• CWD: pasa de palabra a doble palabra el contenido del acumulador.

• INC destino: incrementa el destino.

• DEC destino: decrementa el destino.

OPERACIONES LÓGICAS:

Se usan para realizar operaciones a nivel de bits.

• NOT operando: cambia los bits 1 por 0 y viceversa y devuelve el resultado en el mismo operando.

AL = F2h AL 1111 0010

NOT AL; NOT AL 0000 1101 = Odh



• OR destino, fuente: operación o lógico inclusivo. El resultado se almacena en destino.

AX = FEDCh= 1111 1110 1101 1100

BX = 1234 h = 0001 0010 0011 0100

OR AX, BX 1111 1110 1111 1100 = FEFC h

• AND destino, fuente: la operación Y lógica entre 2 operandos, el resultado se deja en destino.

AX = FEDC h 1111 1110 1101 1100

BX = 1234 h 0001 0010 0011 0100

ADD AX, BX 0001 0010 0001 0100 = 1214 h

• XOR destino, fuente: la operación o lógico exclusiva; el resultado se deja en destino.

AX = FEDC h 1111 1110 1101 1100

BX = 1234 h 0001 0010 0011 0100

XOR AX, BX 1110 1100 1110 1000 = ECE8 h

11

APENDICE 1- INTERRUPCIONES.

DIRECCION INTERRUPCION FUNCION

(hex) (hex)

0-3 0 Division by zero

4-7 1 Single step trace

8-B 2 Non maskable interrupt



C-F 3 Break point instruction

10-13 4 Overflow

14-17 5 Print screen

18-1F 6,7 Reserved

20-23 8 Timer

24-27 9 Keyboard interrupt

28-37 A,B,C,D Reserved

38-3B E Diskette interrupt

3C-3F F Reserved

40-43 10 Video screen I/O

44-47 11 Equipment check

48-4B 12 Memory size check

4C-4F 13 Diskette I/O

50-53 14 Communication I/O

54-57 15 Cassette I/O

58-5B 16 Keyboard input

5C-5F 17 Printer Output

60-63 18 ROM Basic entry code

64-67 19 Bootstrap loader

68-6B 1A Time of day

6C-6F 1B Get control on keyboard break



70-73 1C Get control on timer interrupt

74-77 1D Pointer to video initialization table

78-7B 1E Pointer to diskette parameter table

7C-7F 1F Pointer to table for graphics characters

ASCII 128-255

80-83 20 DOS program terminate

84-87 21 DOS function call

88-8B 22 DOS terminate address

90-93 24 DOS fatal error vector

94-97 25 DOS absolute disk read

98-9B 26 DOS absolute disk write

9C-9F 27 DOS terminate, fix in storage

A0-FF 28-3F Reserved for DOS

100-1FF 40-7F Not used

200-217 80-85 Reserved by BASIC

218-3C3 86-F0 Used by BASIC interpreter

3C4-3FF F1-FF Not Used

JUEGO DE INSTRUCCIONES DEL 8086.



En la siguiente lista de instrucciones, para la descripción y su sintaxis se recurre a las siguientes abreviaturas:

acum uno de los acumuladores: AX o AL.

reg cualquiera de los registros

segreg uno de los registros de segmento

r/m uno de los operandos generales: registro, memoria, basado, indexado o

basado-indexado

inmed constante o símbolo de 8 o 16 bits

mem un operando de memoria: símbolo, etiqueta, variable.

etiqueta etiqueta de instrucciones.

src fuente en operaciones de cadena

dest destino en operaciones de cadena.

8086

AAA Ajuste ASCII para adición.

AAD Ajuste ASCII para división.

AAM Ajuste ASCII para multiplicación.

AAS Ajuste ASCII para división.

ADC acum, inmed Suma con acarreo.

r/m,inmed

r/m, reg

reg, r/m



ADD acum,inmed Suma.

r/m,inmed

r/m, reg

reg, r/m

AND acum,inmed Operación AND a nivel bit.

r/m,inmed

r/m, reg

reg, r/m

CALL etiqueta Llamado.

r/m

CBW Convierte byte apalabra.

CLC Limpia bandera de acarreo.

CLD Limpia bandera de dirección.

CLI Limpia bandera de interrupción.

CMC Complementa bandera de acarreo.

CMP acum,inmed Comparación

r/m,inmed

r/m, reg

reg, r/m

CMPS src,dest Comparación de cadenas.

CMPSB Compara cadenas byte por byte.



CMPSW Compara cadenas palabra por palabra.

CWD Convierte palabra a palabra doble.

13

DAA Ajuste decimal para adición.

DAS Ajuste decimal para substracción.

DEC r/m Decremento.

reg

DIV r/m División.

ESC inmed, r/m Escape con 6 bits.

HLT Alto.

IDIV r/m División entera.

IMUL r/m Mutiplicación entera.

IN accum,inmed Entrada desde puerto.

acum, DX

INC r/m Incremento.

reg

INT3 Interrupción3 codificada como un byte.

INT inmed Interrupción0-255.

INTO Interrupción en overflow.

IRET Retorno de interrupción.

JMP etiqueta Brinco incondicional.



r/m

J(condición)etiqueta Brinca de acuerdo a las condiciones: A (arriba), AE (arriba o igual), B

(siguiente), BE (siguiente o igual), C(acarreo), CXZ (CX en cero), E (igual),

G (mayor), GE (mayor o igual), L (menor), LE (menor o igual), NA (no

anterior), NAE (no anterior o igual), NB (no siguiente), NBE(no siguiente o

igual), NC (no acarreo), NE (no igual), NG(no mayor), NGE (no mayor o

igual), NL (no menor), NLE (no menor o igual), NO(no sobreflujo), NP (no

paridad), NS (no signo), NZ (no cero), O(sobreflujo), P (paridad),

PE(paridad par), PO (paridad impar), S (signo), Z (cero).

LAHF Carga AH con las banderas.

LDS r/m Carga DS.

LEA r/m Carga la dirección.

LES r/m Carga ES.

LOCK Cierra bus.

LODS src Carga cadena.

LODSB Carga byte de cadena en AL.

LODSW Carga palabra de la cadena en AX.

LOOP etiqueta Ciclo.

LOOPE etiqueta Ciclo mientras igual.



LOOPNE etiqueta Ciclo mientras no igual.

LOOPNZ etiqueta Ciclo mientras no cero.

LOOPZ etiqueta Ciclo mientras cero.

MOV acum,mem Mueve un valor del segundo al primer operando

r/m,inmed

mem, acum

r/m, reg

r/m,segreg

reg, inmed

reg,r/m

segreg,r/m

MOVS dest, src Mueve cadena.

14

MOVSB Mueve cadena byte por byte.

MOVSW Mueve cadena palabra por palabra.

MUL r/m Multiplicación.

NEG r/m Niega(complemento a 2).

NOP Operación ociosa.

NOT r/m Invierte valores de bits (complemento a 1).

OR acum, inmed Operación OR a nivel de bit.

r/m,inmed



r/m, reg

reg,r/m

OUTDX, accum Salida por el puerto dado por el primer operando.

inmed, acum (inmediato de 8 bits)

POP r/m Recupera valor de la pila.

reg

segreg

POPF Recupera banderas.

PUSH r/m Guarda valor en la pila.

reg

segreg

PUSHF Guarda banderas.

RCL r/m,1 Rotación a la izquierda con acarreo.

r/m,CL

RCR r/m, 1 Rotación a la derecha con acarreo.

r/m, CL

REP Repite.

REPE Repite si igual.

REPNE Repite si no igual.

REPNZ Repite si no cero.

REPZ Repite si cero.



RET [inmed] Regresa después de recuperar bytes de la pila.

ROL r/m,1 Rotación a la izquierda.

r/m, CL

ROR r/m,1 Rotación a la derecha.

r/m, CL

SAHF Carga banderas con el valor de AH.

SAL r/m, 1 Desplazamiento aritmético a la izquierda.

r/m, CL

SAR r/m, 1 Desplazamiento aritmético a la derecha.

r/m, CL

SBB acum, inmed Substracción con acarreo.

r/m,inmed

r/m, reg

reg,r/m

SCAS dest Explora cadena.

SCASB Explora cadena para el byte en AL.

SCASW Explora cadena por la palabra en AX.

SHL r/m, 1 Desplazamiento a la izquierda.

r/m, CL

SHR r/m, 1 Desplazamiento a la derecha.

15



r/m, CL

STC Fija bandera de acarreo.

STD Fija bandera de dirección.

STI Fija bandera de interrupción.

STOS dest Guarda cadena.

STOSB Guarda byte en AL en la cadena.

STOSW Guarda palabra en AX en la cadena.

SUB accum, inmed Substracción.

r/m,inmed

r/m, reg

reg,r/m

TEST acum, inmed Comparación.

r/m,inmed

r/m, reg

reg,r/m

WAIT Aguarda.

XCHG acum, reg Intercambio.

r/m,inmed

r/m, reg

reg,r/m

XLAT Traduce.



XOR acum, reg Operación XOR a nivel bit.

r/m,inmed

r/m, reg

reg,r/m

FUENTES DE CONSULTA

http://www.ganimides.ucm.cl/rcofre/manual2-8086.pdf

http://www.google.com/


http://proton.ucting.udg.mx/dpto/maestros/mateos/novedades/ensamblador/68HC11.html

http://www.monografias.com/trabajos/ensamblador/ensamblador.shtml

http://usuarios.multimania.es/patricio/ensam/ensam1.htm

http://foro.elhacker.net/asm/tutorial_asm_basico_ejemplos-t102701.0.html#ixzz1GbtWqKBS

EJERCICIOS


http://foro.elhacker.net/asm/tutorial_asm_basico_ejemplos-t102701.0.html#ixzz1GbtWqKBS

http://usuarios.multimania.es/patricio/ensam/ensam1.htm

http://www.monografias.com/trabajos/ensamblador/ensamblador.shtml

http://proton.ucting.udg.mx/dpto/maestros/mateos/novedades/ensamblador/68HC11.html


http://www.google.com/

http://www.ganimides.ucm.cl/rcofre/manual2-8086.pdf


EJERCICIO PARA LA SUMA DE DOS NÚMEROS



EJERCICIO PARA RESTAR DOS NUMEROS



EJERCICIO PARA MULTIPLICAR DOS NUMEROS



EJERCICIO PARA DIVIDIR DOS NUMEROS


50746990-ENSAMBLADOR

Documents

Transcript of 50746990-ENSAMBLADOR