Lenguajes de Programacion en Ensamblador

ÍÍnnddiiccee

Introducción ........................................................................................... pág. 3

ASM ........................................................................................................ pág. 4

Sun SPARC.............................................................................................. pág. 6

PA RISC .................................................................................................. pág. 8

Lenguaje Ensamblador x86...................................................................... pág. 10

Microsoft Macro Assembler .................................................................... pág. 12

Netwide Assembler ................................................................................. pág. 14

Turbo Assembler ..................................................................................... pág. 16

Flat Assembler ......................................................................................... pág. 17

Conclusiones ........................................................................................... pág. 18

Bibliografía ............................................................................................. pág. 19

Lenguajes de Programación en Ensamblador 2

IInnttrroodduucccciióónn

La importancia del lenguaje ensamblador es principalmente

que se trabaja directamente con el microprocesador; por lo

cual se debe de conocer el funcionamiento interno de este,

tiene la ventaja de que en él se puede realizar cualquier tipo de

programas que en los lenguajes de alto nivel no lo pueden

realizar. Otro punto sería que los programas en ensamblador

ocupan menos espacio en memoria.

A pesar de su antiguo uso y en el auge de los lenguajes de

alto nivel de la actualidad, el uso de lenguajes ensambladores

se restringe básicamente a un solo propósito: el manejo

detallado y exhaustivo de los componentes de una arquitectura

de computadora, manejos que muy difícilmente un lenguaje de

alto nivel puede realizar, a pesar el grado de conocimiento por

parte del programador en cuanto a hardware se refiere.

Exponemos a continuación una breve reseña de algunos

lenguajes ensambladores que tuvieron su principal uso entre

las décadas de los 50 - 90, se detallan algunos eventos

históricos y acerca de sus creadores quienes forjaron el camino

hacia el actual mundo de la programación.


AASSMM

El lenguaje ensamblador, o assembler (assembly language en inglés), es un lenguaje de programación de bajo nivel para los computadores, microprocesadores, microcontroladores y otros circuitos integradosprogramables. Implementa una representación simbólica de los códigos de máquina binarios y otras constantes necesarias para programar una arquitectura dada de CPU y constituye la representación más directa del código máquina específico para cada arquitectura legible por un programador. Esta representación es usualmente 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 portátiles.

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 son llamados 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.

Muchos dispositivos programables (como los microcontroladores) aún cuentan con el ensamblador como la única manera de ser manipulados.


Características

El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido 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.


SSuunn SSPPAARRCC

SPARC (del inglés Scalable Processor ARChitecture) es una arquitectura RISC big-endian. Es decir, una arquitectura con un conjunto de instrucciones reducidas.

Fue originalmente diseñada por Sun Microsystems y dirigido por el ingeniero Kaa en 1985, se basa en los diseños RISC I y II de la Universidad de California en Berkeley que fueron definidos entre los años 1980 y 1982.

La empresa Sun Microsystems diseñó esta arquitectura y la licenció a otros fabricantes como Texas Instruments, Cypress Semiconductor, Fujitsu, LSI Logic entre otros.

SPARC es la primera arquitectura RISC abierta y como tal, las especificaciones de diseño están publicadas, así otros fabricantes de microprocesadores pueden desarrollar su propio diseño.

Una de las ideas innovadoras de esta arquitectura es la ventana de registros que permite hacer fácilmente compiladores de alto rendimiento y una significativa reducción de memoria en las instrucciones load/store en relación con otras arquitecturas RISC. Las ventajas se aprecian sobre todo en programas grandes.

La cpu SPARC está compuesta de una unidad entera, UI (Integer Unit) que procesa la ejecución básica y una FPU (Floating-Point Unit) que ejecuta las operaciones y cálculos de reales. La IU y la FPU pueden o no estar integradas en el mismo chip.

Aunque no es una parte formal de la arquitectura, las computadoras basadas en sistemas SPARC de Sun Microsystems tienen una unidad de manejo de memoria (MMU) y un gran caché de direcciones virtuales (para instrucciones y datos) que están dispuestos periféricamente sobre un bus de datos y direcciones de 32 bits.

Principales características

Su característica distintiva es utilizar ventanas de registros. 32 registros de "enteros" de 32 bits. 16 registros de punto flotante de 64 bits (para el caso de doble precisión) que se

pueden utilizar como 32 registros de 32 bits (para precisión simple). Modos de direccionamiento: Inmediato, (constantes de 13 bits). Directo, (offset de 13 bits). Indirecto, (registro + offset de 13 bits o registro + registro).


Utiliza instrucciones retardadas (saltos, load y store ). Manejo de memoria: Espacio virtual de 4 Gigabytes. Unidad de manejo de memoria (MMU) que trabaja con páginas de tamaño

configurable.

Categorías de Instrucciones

La arquitectura SPARC tiene cerca de 50 instrucciones enteras, unas pocas más que el anterior diseño RISC, pero menos de la mitad del número de instrucciones enteras del 6800 de Motorola.

Las instrucciones de SPARC se pueden clasificar en cinco categorías:

LOAD y STORE (La única manera de acceder a la memoria). Estas instrucciones usan dos registros o un registro y una constante para calcular la dirección de memoria a direccionar.

Instrucciones Aritméticas/Lógicas/Shift. Ejecutan operaciones aritméticas, lógicas y de desplazamiento de bits. Estas instrucciones calculan el resultado si es una función de 2 operandos y guardan el resultado en un registro.

Operaciones del Coprocesador. La IU extrae las operaciones de punto flotante desde las instrucciones del bus de datos y los coloca en la cola para la FPU. La FPU ejecuta los cálculos de punto flotante con un número fijo en unidad aritmética de punto flotante, (el número es dependiente de la aplicación). Las operaciones de punto flotante son ejecutadas concurrentemente con las instrucciones de la IU y con otras operaciones de punto flotante cuando es necesario. La arquitectura SPARC también especifica una interfaz para la conexión de un coprocesador adicional.

Instrucciones de Control de Transferencia. Estas incluyen jumps, calls, traps y branches. El control de transferencia es retardado usualmente hasta después de la ejecución de la próxima instrucción, así el pipeline no es vaciado porque ocurre un control de tiempo. De este modo, los compiladores pueden ser optimizados por ramas retardadas.

Instrucciones de control de registros Read/Write. Estas instrucciones se incluyen para leer y grabar el contenido de varios registros de control. Generalmente la fuente o destino está implícito en la instrucción.


PPAA--RRIISSCC

PA-RISC es el nombre por el que se conoce una arquitectura de microprocesadores desarrollada por sistemas Hewlett-Packard y VLSI Technology Operation. Esta arquitectura se basa en el modelo RISC y en PA (Precision Architecture). También se suelen referir a ella como la arquitectura HP/PA, Hewlett Packard Precision Architecture. PA se desarrolla en Palo Alto, donde se encuentra la central de HP.

A finales de los 80, HP comenzó a construir dos series de computadores, ambas basadas en CISC. Una de ellas es la serie HP 9000 de estaciones de trabajo Unix, basadas en el microprocesador Motorola 68000. La otra serie era la serie HP 3000 de minicomputadoras, basadas en un diseño de CPU de HP de 16 bits.

Los primeros PA-RISC fueron dispositivos de 32 bits. Se usaron por primera vez en las últimas series de HP 3000, la 930 y la 950, comúnmente conocidos como sistemas Spectrum (nombre que le pusieron en los laboratorios de HP). Estas máquinas corrían sobre MPE/iX. La serie HP 9000 se actualizó también a la arquitectura PA-RISC recién creada, pero en esta serie se trabajaba sobre HP-UX.

Otros sistemas operativos que se pueden usar sobre arquitecturas PA-RISC son Mach kernel, Linux, OpenBSD, NetBSD y FreeBSD entre otros.

Una característica interesante de PA-RISC es que la mayoría de sus microprocesadores no tiene caché L2. En su lugar se implementaba una caché L1 mayor, formada por chips separados conectados al microprocesador a través de un bus(actualmente está integrada en el propio chip). Sólo el modelo PA-7300LC tiene caché L2. Otra innovación de esta arquitectura fue la adición de un repertorio de instrucción multimedia (SIMD) conocido como MAX e introducido por primera vez en el 7100LC.

El diseño fue actualizado en 1996 en la versión 2.0 de la arquitectura. La nueva versión era una arquitectura de 64 bits, implementada en la serie PA-8000 de HP. Contaba con 10 unidades funcionales y un nuevo sistema de segmentación de cauce. Otro cambio que se introdujo fue la separación de la caché de instrucciones en dos, dependiendo del tiempo de ejecución de las instrucciones que iban a ir almacenadas en ellas. El PA-8200 fue lanzado por HP en 1997 y contaba con algunas mejoras sobre el PA-8000, como una mejora predicción en los saltos y cachés más grandes, más rápidas y con unos algoritmos de predicción más eficientes.


El PA-8500 fue el primero en el cual se añadió la cache al encapsulado del microprocesador. Contaba con 1.5 MB de caché L1, lo que le permitió conseguir una gran mejora en el rendimiento. Se actualizó el bus Runway con una implementación basada en DDR, consiguiendo 2GB/s de ancho de banda entre microprocesador y memoria. La tabla de saltos aumentó el doble hasta alcanzar 2048 entradas y el buffer desde 120 a 160 entradas.

El 8600 es básicamente igual al 8500 pero con una política semi-LRU para la caché. El 8700 cuenta con una velocidad superior a la del 8600 y con una caché L1 de 2.25 MB. También se añadió capacidad de precaptación de datos.

PA-8800, Mako, cuenta con dos microprocesadores independientes en el mismo encapsulado (dual-core). Cada chip cuenta con SMP de 2 vías, así como 1.5 MB de caché L1, pero HP ha decidido añadir 32 MB de cache L2 en chips separados. El bus Runway ha sido reemplazado por el bus Itanium2, capaz de mantener tasas de 6.4 Gb/s y mantener un expepcional ancho de banda.

Después del PA-8900, HP esperar retirar la arquitectura PA-RISC para sustituirla con la arquitectura Itanium. El núcleo que se introdujo con el PA-8000 no ha cambiado de forma significativa hasta hoy; cada generación posterior solo ha aumentado la velocidad de reloj y la capacidad de la caché. Se ha mantenido el número de 2 núcleos en el mismo encapsulado.


LLeenngguuaajjee eennssaammbbllaaddoorr xx8866

El lenguaje ensamblador x86 es la familia de los lenguajes ensambladores para los procesadores de la familia x86, que incluye desde los procesadores Intel 8086 y 8088, pasando por los Pentium de Intel y los Athlon de AMD y llegando hasta los últimos procesadores x86 de estas compañías. Como el resto de lenguajes ensambladores, usa una serie de mnemotécnicos para representar las operaciones fundamentales que el procesador puede realizar. Los compiladores a menudo producen código ensamblador como un paso intermedio cuando traducen un programa de alto nivel a código máquina. Considerado como un lenguaje de programación de bajo nivel y específico para cada máquina. Aunque algunas veces es usado para software de aplicación de sistemas de ventanas, los lenguajes ensambladores son utilizados principalmente en aplicaciones críticas como sistemas de arranque, Sistemas Operativos, núcleos y en controladoras de dispositivos, así como en sistemas en tiempo real o pequeños sistemas embebidos.

Historia

Los procesadores Intel 8086 y 8088 fueron los primeros de 16 bits en tener un conjunto de instrucciones conocido actualmente como x86. Fueron un paso evolutivo en comparación con la generación anterior de CPUs de 8 bits, como el 8080 y heredaron muchas características e instrucciones, las cuales fueron extendidas para trabajar con 16 bits. Ambos CPUs contenían un bus de direcciones de 20 bits y un grupo de registros internos de 16 bits. El 8086 tenía un bus de datos externo de 16 bits y el 8088 uno de 8 bits. El 8088 estaba previsto como una versión debajo coste del 8086. El lenguaje ensamblador del x86 también cubre las diferentes versiones de CPU que siguieron, como el 80188 y 80186, 80286, 80386, 80486, Pentium, etc, de Intel, también como los CPU de AMD y Cyrix como los procesadores 5x86 y K6, y el NEC V20 de NEC. El término x86 aplica a cualquier CPU pueda correr el lenguaje ensamblador original (usualmente también correrá por lo menos algunas de las extensiones.

El moderno conjunto de instrucciones x86 es un superconjunto de las instrucciones del 8086 y el 8088 y una serie de extensiones a este conjunto de instrucciones que comenzaron con el microprocesador Intel 8008.


Existe casi una completa compatibilidad binaria desde los chips Intel 8088 y 8086 con los modernos procesadores Intel Pentium 4, Intel Core Duo, Intel Core i7, AMD Athlon 64, AMD Opteron, hasta la generación actual de microprocesadores x86, aunque existen algunas excepciones. Esta compatibilidad se logra gracias al uso de 2 conjuntos de instrucciones de arquitecturas, lo cual es comúnmente criticado.

La compatibilidad de los programas en lenguaje ensamblador con procesadores más antiguos sólo es posible cuando el programa no incluye instrucciones solo disponibles en los procesadores nuevos.

Generalmente, cada nuevo procesador de la serie tiene unas cuantas instrucciones adicionales y más capacidades y mejor desempeño que los anteriores. El 286 agregó unas cuantas instrucciones. el modo protegido y capacidad multitarea, el 386 extendió la plataforma de 16 a 32 bits, añadió algunas instrucciones e hizo al conjunto de instrucciones más ortogonal, haciéndolo la base de los procesadores siguientes hasta que aparecieron los de 64 bits. Con el 486 se incorporó el coprocesador numérico en el propio chip, otros procesadores posteriores agregaron instrucciones para acelerar el procesamiento multimedia, multithreading, 2 ó más núcleos, 64 bits, etc.


MMiiccrroossoofftt MMaaccrroo AAsssseemmbblleerr

El Microsoft Macro Assembler (MASM) es un ensamblador para la familia x86 de microprocesadores. Fue producido originalmente por Microsoft para el trabajo de desarrollo en su sistema operativo MS-DOS, y fue durante cierto tiempo el ensamblador más popular disponible para esesistema operativo. El MASM soportó una amplia variedad de facilidades para macros y programación estructurada, incluyendo construcciones de alto nivel para bucles, llamadas a procedimientos y alternación (por lo tanto, MASM es un ejemplo de un ensamblador de alto nivel). Versiones posteriores agregaron la capacidad de producir programas para los sistemas operativos Windows. MASM es una de las pocas herramientas de desarrollo de Microsoft para las cuales no había versiones separadas de 16 bits y 32 bits.

La competencia

A principio de los años 1990, ensambladores alternativos comenzaron a tomar algo de la cuota de mercado del MASM, como el TASM de Borland, el ensamblador A86, comercializado como shareware, y hacia finales de los años 1990, el NASM. Sin embargo, dos acontecimientos a finales de los años 1990 permitieron que el MASM conservara mucha de su cuota de mercado: Primero, Microsoft dejó de vender el MASM como un producto comercial y comenzó a distribuirlo gratuitamente como parte del Driver Development Kit (DDK) (Kit de Desarrollo de Controladores). Segundo, aparecieron, el paquete MASM32, y los tutoriales sobre Win32 de Iczelion, haciendo posible la programación de aplicaciones de Windows con el MASM. Combinado con la enorme base instalada de usuarios de MASM, estos dos eventos ayudaron a prevenir la deserción del MASM a otros ensambladores. Hoy en día, MASM sigue siendo el ensamblador número uno en la plataforma Win32, a pesar de la competencia de productos nuevos tales como NASM, FASM, GoAsm, y HLA.


Proyectos que soportan al MASM

Hay en curso muchos desarrollos de proyectos de software que soportan el MASM, incluyendo IDEs (como RadASM y WinAsm Studio), depuradores (como OllyDbg), y desensambladores (incluyendo IDAPro, el desensamblador interactivo). El proyecto MASM32 ha puesto juntos una muy impresionante librería de programador, un repositorio de ejemplos de código, y una extraordinaria documentación para los usuarios del MASM. MASM también es soportado por una gran cantidad de páginas web y foros de discusión. A pesar de la edad de este producto, sigue siendo uno de los ensambladores en existencia mejor soportados.


NNeettwwiiddee AAsssseemmbblleerr

El Netwide Assembler o NASM, es un ensamblador libre para la plataforma Intel x86. Puede ser usado para escribir programas tanto de 16 bits como de 32 bits (IA-32). En el NASM, si se usan las bibliotecas correctas, los programas de 32 bits se pueden escribir de una manera tal para que sean portables entre cualquier sistema operativo x86 de 32 bits. El paquete también incluye un desensamblador, el NDISASM.

Historia

El NASM fue escrito originalmente por Simon Tatham con ayuda de Julian Hall, y actualmente es desarrollado por un pequeño equipo en SourceForge que le hace mantenimiento. Fue lanzado originalmente bajo su propia licencia, pero más adelante fue cambiada por la licencia GNU Lesser General Public License, seguido de un número de problemas políticos causado por la selección de la licencia. La próxima versión del NASM, la 2.00, actualmente está siendo desarrollada bajo la bifurcación 0.99, e incluirá soporte para el x86-64 (x64/AMD64/Intel 64), junto con la respectiva salida de archivo objeto de 64 bits. Esta versión de desarrollo puede ser encontrada en el NASM git repository, y snapshots por lasnoches en formatos de código fuente y binarios están disponibles aquí.

Características

El NASM puede generar varios formatos binarios en cualquier máquina, incluyendo COFF (y el ligeramente diferente formato Portable Executable usado por Microsoft Windows), el a.out, ELF, Mach-O, y el formato binario nativo Minix. El NASM incluso define su propio formato binario, RDOFF, que es usado actualmente solamente por el proyecto del sistema operativo RadiOS).

La variedad de formatos de la salida permite a uno portar los programas a virtualmente cualquier sistema operativo x86. Además, el NASM puede crear archivos binarios planos, usables para escribir boot loaders (cargadores de arranque), imágenes ROM, y varias facetas del desarrollo sistemas operativos. El NASM incluso puede correr en plataformas diferentes del x86, como SPARC y PowerPC, aunque no puede producir programas usables por esas máquinas.


El NASM usa la tradicional sintaxis de Intel para el lenguaje ensamblador x86, mientras que otros ensambladores libres, como el ensamblador del GNU (GAS), utilizan la sintaxis de AT&T. También evita características como la generación automática de sobreescritura (override) de segmentos y la relacionada directiva ASSUME usada por el MASM y los ensambladores compatibles, pues estas pueden ser a menudo confusas -- los programadores deben seguir por sí mismos el contenido de los registros de segmento y la localización de variables a los que éstos se refieren.


TTuurrbboo AAsssseemmbblleerr

El Turbo Assembler (TASM), un paquete ensamblador principalmente destinado a la

plataforma del IBM PC y sus compatibles. Fue la oferta de Borland en el mercado de

herramientas de programación en lenguaje ensamblador para la familia de

los microprocesadores x86. Como se pudiera esperar, trabajaban bien con

los compiladores de lenguaje de alto nivel de Borland para los PC, como Turbo C, Turbo

BASIC y Turbo Pascal. Junto con el resto de suite de lenguajes de programación Turbo.

Turbo Assembler es mantenido y empaquetado por Embarcadero Delphi y C++Builderq.

El paquete Turbo Assembler vino junto con el enlazador Turbo Linker, y era

interoperable con el depurador Turbo Debugger. Para la compatibilidad con el

ensamblador Microsoft Macro Assembler (MASM) de Microsoft, TASM también podía

ensamblar los archivos de código fuente del MASM por medio de su modo MASM. Al igual

que éste, es un ensamblador de alto nivel.

Turbo Assembler también se refiere a un ensamblador común, basado en el

microprocesador 6502 para el Commodore 64, creado por la compañía

alemana Omikron en 1985. Este producto no se relaciona con el ensamblador de Borland.


FFllaatt AAsssseemmbblleerr

Flat assembler (FASM) es un ensamblador libre, multi-paso, con el estilo de la sintaxis de

Intel que soporta las arquitecturas IA-32 y x86-64.

El proyecto fue iniciado en 1999 por Tomasz Grysztar, que en aquella época era un

estudiante no graduado de matemáticas en Polonia. El FASM está escrito en lenguaje

ensamblador, viene con el código fuente completo, y fue capaz de ensamblarse a sí mismo

(bootstrapping) desde la versión 0.90 del 4 de mayo de 1999. El primer lanzamiento

público fue anunciado la 15 de marzo de 2000.

Es notable por su velocidad rápida, optimizaciones de tamaño, portabilidad, poderosas

capacidades de macro, y la comunidad del foro en línea. Sin embargo, casi no usa

opciones en la línea de comandos. Hay disponibles archivos binarios y de código

fuente para Linux, Windows (incluyendo un IDE de

desarrollo), DOS, OpenBSD, MenuetOS, OctaOS, y DexOS. FASM contiene vínculos

(bindings) para la GUI de Windows y OpenGL.

Todas las versiones de FASM pueden generar los siguientes archivos objeto: binarios

planos (flat binary), ELF o COFF (clásico o de MS), como también ejecutables en

formato MZ, ELF o PE. Existe un traslado del ensamblador a la arquitectura ARM, llamado

FASMARM.

La última versión disponible es la 1.70.03, lanzada el 29 Junio de 2012.


CCoonncclluussiioonneess

La mayoría de los ensambladores o lenguajes

ensambladores tuvieron su auge cuando aun no existían

sistemas operativos reales o con una interfaz grafica de

usuarios como hoy en la actualidad; su principal función

era la de dar al usuario (que tenía que poseer grandes

capacidades de programación) las herramientas

necesarias para crear sus entornos de trabajo.

Muchos ensambladores en la actualidad se utilizan solo

para tareas de desarrollo donde el hardware es utilizado

minuciosamente, como desarrollo de motores gráficos

(graphic engine) para juegos o aplicaciones de

reenderizado 3D.


BBiibblliiooggrraaffííaa

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

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

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

http://www.uhu.es/tomas.mateo/ac2/manual%20ensamblador%20UHU.pdf

http://www.slideshare.net/ece79/ensamblador-8086

http://www.cs.buap.mx/~mgonzalez/asm_mododir2.pdf

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

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

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

Lenguajes de Programacion en Ensamblador

Documents

Transcript of Lenguajes de Programacion en Ensamblador