Llinguaxe ensamblador

El **llinguaxe ensamblador**, o ***assembler*** (n'inglés ***assembly language*** y la abreviación ***asm***), ye un llinguaxe de programación de baxu nivel. Consiste nun conxuntu de mnemónicos que representen instruiciones básiques pa los ordenadores, microprocesadores, microcontroladores y otros circuitos integraos programables. Implementa una representación simbólica de los código de máquina binarios y otres constantes necesaries pa programar una arquiteutura de procesador y constitúi la representación más direuta del código máquina específicu pa cada arquiteutura legible por un programador. Cada arquiteutura de procesador tien el so propiu llinguaxe ensamblador que usualmente ye definida pol fabricante de hardware, y ta basada nos mnemónicos que simbolicen los pasos de procesamientu (les instruiciones), los rexistros del procesador, les posiciones de memoria y otres carauterístiques del llinguaxe. Un llinguaxe ensamblador ye polo tanto específicu de cierta arquiteutura d'ordenador física (o virtual). Esto ta en contraste cola mayoría de los llinguaxes de programación d'altu nivel, qu'idealmente son portables.

Un programa utilitariu llamáu ensamblador ye usáu pa traducir sentencies del llinguaxe ensamblador al códigu de máquina del ordenador oxetivu. L'ensamblador realiza una traducción más o menos isomorfa (un mapeo d'unu a unu) dende les sentencies mnemónicas a les instruiciones y datos de máquina. Esto ta en contraste colos llinguaxes d'altu nivel, nos cualos una sola declaración xeneralmente da llugar a munches instruiciones de máquina.

Munchos sofisticaos ensambladores ufierten mecanismos adicionales pa facilitar el desenvolvimientu del programa, controlar el procesu d'ensamblaxe, y l'ayuda de depuración. Particularmente, la mayoría de los ensambladores modernos inclúin una facilidá de macro (descrita más embaxo), y llámense macro ensambladores.

Foi usáu principalmente nos entamos del desenvolvimientu de software, cuando entá nun se cuntaba con potentes llinguaxes d'altu nivel y los recursos yeren llindaos. Anguaño utilízase con frecuencia n'ambientes académicos y d'investigación, especialmente cuando se riquir la manipulación direuta de hardware, altu rendimientu, o un usu de recursos controláu y amenorgáu. Tamién ye utilizáu nel desenvolvimientu de Manejador de dispositivu controladores de dispositivu (n'inglés, *device drivers*) y nel desenvolvimientu de sistemes operativos, por cuenta de la necesidá del accesu direutu a les instruiciones de la máquina. Munchos dispositivos programables (como los microcontroladores) entá cunten col ensamblador como la única manera de ser manipoliaos.

## Carauterístiques
* El códigu escritu en llinguaxe ensamblador tien una cierta dificultá de ser entendíu yá que la so estructura averar al llinguaxe máquina, esto ye, ye un llinguaxe de baxu nivel.
* El llinguaxe ensamblador ye difícilmente portable, esto ye, un códigu escritu pa un microprocesador, puede precisar ser modificáu, pa poder ser usáu n'otra máquina distinta. Al camudar a una máquina con arquiteutura distinta, xeneralmente ye necesariu reescribilo dafechu.
* Los programes fechos por un programador espertu en llinguaxe ensamblador son xeneralmente muncho más rápidos y peracaben menos recursos del sistema (memoria RAM y ROM) que'l programa equivalente compilado dende un llinguaxe d'altu nivel. Al programar curioso en llinguaxe ensamblador pueden crease programes que s'executen más rápido y ocupen menos espaciu que con llinguaxes d'altu nivel.
* Col llinguaxe ensamblador tiense un control bien precisu de les xeres realizaes por un microprocesador polo que pueden crease segmentos de códigu difíciles y/o bien ineficientes de programar nun llinguaxe d'altu nivel, yá que, ente otres coses, nel llinguaxe ensamblador disponer d'instruiciones del CPU que xeneralmente nun tán disponibles nos llinguaxes d'altu nivel.
* Tamién puede controlase el tiempu en que tarda una rutina n'executase, y torgar que s'ataye mientres la so execución.

## Programa ensamblador

Xeneralmente, un programa ensamblador (*assembler* n'inglés) modernu crea códigu oxetu traduciendo instruiciones mnemónicas de llinguaxe ensamblador en opcodes, y resolviendo los nomes simbólicos pa les llocalizaciones de memoria y otres entidaes. L'usu de referencies simbóliques ye una carauterística clave del llinguaxe ensamblador, evitando aburribles cálculos y actualizaciones manuales de les direiciones dempués de cada cambéu del programa. La mayoría de los ensambladores tamién inclúin facilidaes de macros pa realizar sustitución testual - ej. xenerar curties secuencies d'instruiciones como espansión en llinia en cuenta de llamar a subrutines.

Los ensambladores son xeneralmente más simples d'escribir que los compiladores pa los llinguaxes d'altu nivel, y tuvieron disponibles dende los años 1950. Los ensambladores modernos, especialmente pa les arquitectures basaes en RISC, tales como MIPS, Sun SPARC, y HP PA-RISC, según tamién pal x86 (-64), optimicen la planificación d'instruiciones pa esplotar la segmentación del CPU eficientemente.

Nos compiladores pa llinguaxes d'altu nivel, son el postreru paso antes de xenerar el códigu ejecutable.

Númberu de camín
Hai dos tipos de ensambladores basaos en cuántos pasos al traviés de la fonte son necesarios pa producir el programa ejecutable.

* Los ensambladores d'un solu pasu pasen al traviés del códigu fonte una vegada y asumen que tolos símbolos van ser definíos antes de cualquier instruición que los refiera.
* Los ensambladores de dos pasos crean una tabla con tolos símbolos y los sos valores nel primer pasu, dempués usen la tabla nun segundu pasu pa xenerar códigu. L'ensamblador debe a lo menos poder determinar el llargor de cada instruición nel primer pasu por que puedan ser calculaes les direiciones de los símbolos.

La ventaya d'un ensamblador d'un solu pasu ye la velocidá, que nun ye tan importante como lo foi nun momentu daos les meyores en velocidá y capacidaes del ordenador. La ventaya del ensamblador de dos pasos ye que los símbolos pueden ser definíos uquier nel códigu fonte del programa. Esto dexa a los programes ser definíos de maneres más lóxiques y más significatives, faciendo los programes de ensamblador de dos pasos más fáciles de lleer y caltener.

### Ensambladores d'altu nivel

Los más sofisticaos ensambladores d'altu nivel apurren astraiciones del llinguaxe tales como:

* Estructures de control avanzaes
* Declaraciones y invocaciones de procedimientos/funciones d'altu nivel
* Tipos de datos astractos d'altu nivel, incluyendo les estructures/records, uniones, clases, y conxuntos
* Procesamientu de macros sofisticáu (anque ta disponible nos ensambladores ordinarios dende finales de 1960 pal IBM/360, ente otres máquines)
* Carauterístiques de programación empobinada a oxetos

### Usu del términu

Note que, nel usu profesional normal, el términu ensamblador ye frecuentemente usáu tantu pa referise al llinguaxe ensamblador como tamién al programa ensamblador (que convierte'l códigu fuente escritu nel llinguaxe ensamblador a códigu oxetu que depués va ser enllazáu pa producir llinguaxe de máquina). Los dos espresiones siguientes utilicen el términu "ensamblador":

## Llinguaxe

El llinguaxe ensamblador reflexa direutamente l'arquiteutura y les instruiciones en llinguaxe de máquina de la CPU, y pueden ser bien distintes d'una arquiteutura de CPU a otra. Cada arquiteutura de microprocesador tien el so propiu llinguaxe de máquina, y en consecuencia'l so propiu llinguaxe ensamblador una y bones esti atópase bien amestáu a la estructura del hardware pal cual se programa. Los microprocesadores difieren nel tipu y númberu d'operaciones que soporten; tamién pueden tener distinta cantidá de rexistros, y distinta representación de los tipos de datos en memoria. Anque la mayoría de los microprocesadores son capaces de cumplir esencialmente les mesmes funciones, la forma en que lo faen difier y los respeutivos llinguaxes ensamblador reflexen tal diferencia.

### Instruiciones de CPU

La mayoría de les CPU tienen más o menos los mesmos grupos d'instruiciones, anque non necesariamente tienen toles instruiciones de cada grupu. Les operaciones que pueden realizase varien d'una CPU a otra. Una CPU particular puede tener instruiciones que nun tenga otru y viceversa. Los primeros microprocesadores de 8 bits nun teníen operaciones pa multiplicar o estremar númberos, por casu, y había que faer subrutinas pa realizar eses operaciones. Otres CPU pue que nun tengan operaciones de puntu flotante y habría que faer o consiguir biblioteques que realicen eses operaciones.

Les instruiciones de la CPU pueden arrexuntase, d'alcuerdu a la so funcionalidad, en:

**Operaciones con enteros:** (de 8, 16, 32 y 64 bits dependiendo de l'arquiteutura de la CPU, nos sistemes bien vieyos tamién de 12, 18, 24, 36 y 48 bits)

Estes son operaciones realizaes pola Unidá aritméticu lóxica de la CPU

* Operaciones aritmétiques. Como suma, resta, multiplicación, división, módulu, cambéu de signo *
Operaciones booleanas. Operaciones lóxiques bit a bit como AND, OR, XOR, NOT
* Operaciones de bits. Como desplazamientu o shift lóxicu y rotaciones o Operadores a nivel de bits (escontra la derecha o escontra la esquierda, al traviés del bit del acarretu o ensin él)
* Comparances

**Operaciones de mover datos:**

:**Ente los rexistros y la memoria:**

:Anque la instruición llámase "mover", na CPU, "mover datos" significa en realidá copiar datos, dende un orixe a un destín, ensin que'l datu suma del orixe.

:Pueden movese valores:
:* Dende un rexistru a otru :*
Dende un rexistru a un llugar de la memoria :*
Dende un llugar de la memoria a un rexistru :*
Dende un llugar a otru de la memoria :*
Un valor inmediatu a un rexistru :*
Un valor inmediatu a un llugar de memoria

:**Operaciones de [[Pila (informática)|pila]] (''stack'', n'inglés):**

:* PUSH (escribe datos escontra'l tope de la pila)
:* POP (llee datos dende'l tope de la pila)

:**Operaciones de [[entrada/salida]]:**

:Son operaciones que mueven datos d'un rexistru, dende y escontra un puertu; o de la memoria, dende y escontra un puertu

:* INPUT Llectura dende un puertu d'entrada :*
OUTPUT Escritura escontra un puertu de salida

**Operaciones pal control del fluxu del programa:**

* Llamaes y tornes de subrutinas
* Llamaes y tornes d'interrupciones
* Salto condicionales d'alcuerdu al resultáu de la comparances
* Saltos incondicionales

**Operaciones con númberos reales:**

L'estándar pa les operaciones con númberos reales nes CPU ta definíu pol IEEE 754.

Una CPU puede tener operaciones de puntu flotante con númberos reales por aciu el coprocesador numbéricu (si hai), como les siguientes:

* Operaciones aritmétiques. Suma, resta, multiplicación, división, cambéu de signu, valor absolutu, parte entera *
Operaciones trascendentales
** Operaciones trigonométriques. Senu, cosenu, tanxente, arcotangente
** Operaciones con logaritmo, potencies y raigaños
* Otros

El llinguaxe ensamblador tien mnemónicos pa caúna de les instruiciones de la CPU en adición a otros mnemónicos a ser procesaos pol programa ensamblador (como por casu macros y otres sentencies en tiempu de ensamblado).

### Ensamblado

El tresformamientu del llinguaxe ensamblador en código máquina realizar un programa ensamblador, y la traduición inversa poder efeutuar un desensamblador. A diferencia de los llinguaxes d'altu nivel, equí hai usualmente una correspondencia 1 a 1 ente les instruiciones simples del ensamblador y el llinguaxe de máquina. Sicasí, en dellos casos, un ensamblador puede aprovir "pseudo instruiciones" que s'espanden nun códigu de máquina más estensu con cuenta d'aprovir la funcionalidad necesaria y simplificar la programación. Por casu, pa un códigu máquina condicional como "si X mayor o igual que", un ensamblador puede utilizar una pseudoinstruición al grupu "faiga si menor que", y "si = 0" sobre la resultancia de la condición anterior. Los Ensambladores más completos tamién aproven un ricu llinguaxe de macros que s'utiliza pa xenerar códigu más complexu y secuencies de datos.

Pal mesmu procesador y el mesmu conxuntu d'instruiciones de CPU, distintos programes ensambladores pueden tener, cada unu d'ellos, variaciones y diferencies nel conxuntu de mnemónicos o na sintaxis del so llinguaxe ensamblador. Por casu, nun llinguaxe ensamblador pa l'arquiteutura x86, puede espresase la instruición pa mover `5` al rexistru `A EL` de la siguiente manera: `MOV AL, 5`, ente que pa otru ensamblador pa la mesma arquiteutura espresaríase al aviesu: `MOV 5, A EL`. Dambos llinguaxes ensambladores fadríen esautamente lo mesmo, solo que ta espresáu de manera distinta. El primeru usa la sintaxis d'Intel, ente que'l segundu usa la sintaxis de AT&T

L'usu del ensamblador nun resuelve definitivamente'l problema de cómo programar un sistema basáu en microprocesador de manera senciella yá que pa faer un usu eficiente del mesmu, hai que conocer a xeitu el microprocesador, los rexistros de trabayu de que dispón, la estructura de la memoria, y munches coses más referentes a la so estructura básica de funcionamientu.

### Exemplos

Un programa escritu en llinguaxe ensamblador consiste nuna serie d'instruiciones que correspuenden al fluxu d'ordes ejecutables por un microprocesador.

Por casu, nel llinguaxe ensamblador pa un procesador x86:

La sentencia *
`MOV AL, 61h`
Asigna'l valor hexadecimal `61` (97 decimal) al rexistru "`A EL`".

El programa ensamblador llee la sentencia de riba y produz el so equivalente binariu en llinguaxe de máquina
* Binariu: `10110000 01100001` (hexadecimal: `B61`)

El mnemónico `MOV` ye un *códigu d'operación* o "opcode". El *opcode* ye siguíu por una llista d'argumentos o *parámetros*, completando una típica instruición de ensamblador. Nel exemplu, `A EL` ye un rexistru de 8 bits del procesador, al cual va asignáse-y el valor hexadecimal 61 especificáu.

El códigu de máquina xeneráu pol ensamblador consiste de 2 bytes. El primer byte contién empaquetado la instruición MOV y el códigu del rexistru escontra onde se va a mover el datu:

 

Nel segundu byte especifícase'l númberu 61h, escritu en binariu como `01100001`, que se va asignar al rexistru `A EL`, quedando la sentencia ejecutable como:

* `10110000 01100001`

La cual puede ser entendida y executada direutamente pol procesador.

## Diseñu del llinguaxe

### Elementos básicos

Hai un grau grande de diversidá na manera en que los autores de los ensambladores categorizan les sentencies y na nomenclatura qu'usen. En particular, dalgunos describen cualquier cosa como pseudo-operación (pseudo-Op), con esceición del mnemónico de máquina o del mnemónico estendíu.

Un típicu llinguaxe ensamblador consiste en 3 tipos de sentencies d'instruición que son usaes pa definir les operaciones del programa:

* Mnemónicos d'opcode
* Seiciones de datos Direutives de ensamblador

#### Nemónicos de opcode y mnemónicos estendíos

A diferencia de les instruiciones (sentencies) de los llinguaxes d'altu nivel, les instruiciones nel llinguaxe ensamblador son xeneralmente bien simples. Xeneralmente, una mnemónico ye un nome simbólicu pa una sola instruición en llinguaxe de máquina ejecutable (un opcode), y hai a lo menos un mnemónico de opcode definíu pa cada instruición en llinguaxe de máquina. Cada instruición consiste típicamente nuna operación o opcode más cero o más operandos. La mayoría de les instruiciones refieren a un solu valor, o a un par de valores. Los operandos pueden ser inmediatos (típicamente valores d'un byte, codificados na mesma instruición), rexistros especificaos na instruición, implícitos o les direiciones de los datos alcontraos n'otra parte de la memoria. Esto ta determináu pola arquiteutura subxacente del procesador, l'ensamblador a cencielles reflexa cómo trabaya esta arquiteutura. Los mnemónicos estendíos son frecuentemente usaos pa especificar una combinación d'un opcode con un operando específicu, ej, l'ensamblador del System/360 usa a `B` como un mnemónico estendíu pal `BC` con una mázcara de 15 y `NOP` al `BC` con una mázcara de 0.

Los mnemónicos estendíos son frecuentemente usaos pa soportar usos especializaos d'instruiciones, de cutiu pa propósitos non obvios con respectu al nome de la instruición. Por casu, munchos CPU nun tienen una instruición esplícita de `NOP` (Non Operación), pero tienen instruiciones que puedan ser usaes pa tal propósitu. Nel CPU 8086, la instruición `XCHG AX,AX` (intercambia'l rexistru AX consigo mesmu) ye usada pal `NOP`, con `NOP` siendo un pseudo-opcode para codificar la instruición `XCHG AX,AX`. Dellos desensambladores reconocen esto y decodificarán la instruición `XCHG AX,AX` como `NOP`. Similarmente, los ensambladores de IBM pal System/360 usen los mnemónicos estendíos `NOP` y `NOPR` coles mázcares cero pa `BC` y `BCR`.

Dellos ensambladores tamién soporten simples macroinstruiciones incorporaes que xeneren dos o más instruiciones de máquina. Por casu, con dellos ensambladores pal Z80, la instruición
: `LD HL, BC`
xenera les instruiciones
: `LD L, C`
: `LD H, B`.

`LD HL, BC` ye un *pseudo-opcode*, que nesti casu asemeya ser una instruición de 16 bits, cuando s'espande prodúcense dos instruiciones de 8 bits qu'equivalen a la simulada de 16 bits.

#### Seiciones de datos

Hai instruiciones usaes pa definir elementos de datos pa remanar datos y variables. Definen el tipu de datu, el llargor y l'alliniación de los datos. Estes instruiciones tamién pueden definir si los datos tán disponibles pa programes esteriores (programes ensamblados xebradamente) o solamente pal programa nel cual la seición de datos ta definida. Dellos ensambladores clasifiquen estes instruición

#### Direutives del ensamblador

Les direutives del ensamblador, tamién llamaes los pseudo opcodes, pseudo-operaciones o pseudo-ops, son instruiciones que son executaes por un ensamblador nel tiempu de ensamblado, non por un CPU nel tiempu d'execución. Pueden faer al ensamblado del programa dependiente de parámetros entraos por un programador, de cuenta que un programa pueda ser ensamblado de distintes maneres, quiciabes pa diversos aplicaciones. Tamién pueden ser usaes pa manipoliar la presentación d'un programa pa faelo más fácil lleer y caltener.

Por casu, les direutives pudieren ser usaes p'acutar árees d'almacenamientu y opcionalmente el so p'asignar el so conteníu inicial. Los nomes de les direutives de cutiu empiecen con un puntu pa estremales de les instruiciones de máquina.

Los ensambladores simbólicos déxen-y a los programadores acomuñar nomes arbitrarios (etiquetes o símbolos) a posiciones de memoria. Usualmente, cada constante y variable tien un nome por que les instruiciones pueden referir a esos allugamientos por nome, asina promoviendo'l códigu autodocumentado. Nel códigu ejecutable, el nome de cada subprograma ye acomuñáu al so puntu d'entrada, asina que cualquier llamada a un subprograma puede usar el so nome. Dientro de subprogramas, a los destinos GOTO dánse-y etiquetes. Dellos ensambladores soporten símbolos locales que son léxicamente distintos de los símbolos normales (ej, l'usu de "10$" como un destín GOTO).

La mayoría de los ensambladores apurren un manexu flexible de símbolos, dexando a los programadores remanar diversos espacios de nomes, calcular automáticamente offsets dientro d'estructures de datos, y asignar etiquetes que refieren a valores lliterales o al resultáu de cálculos simples realizaos pol ensamblador. Les etiquetes tamién pueden ser usaes pa inicializar constantes y variables con direiciones rellocalizables.

Los llinguaxes ensambladores, como la mayoría de los otros llinguaxes d'ordenador, dexen que comentarios sían agregos al códigu fuente, que son inoraos pol programa ensamblador. El bon usu de los comentarios ye entá más importante con códigu ensamblador que con llinguaxes d'altu nivel, pos el significáu y el propósitu d'una secuencia d'instruiciones ye más duru de descifrar a partir del códigu en sí mesmu.

L'usu sabiu d'estes facilidaes puede simplificar grandemente los problemes de codificar y caltener el códigu de baxu nivel. El códigu fonte de llinguaxe ensamblador crudu xeneráu por compiladores o desensambladores - códigu ensin nengún comentariu, nin símbolos con dalgún sentíu, nin definiciones de datos - ye bien malo de lleer cuando tienen de faese cambeos.

### Macros

Munchos ensambladores soporten macros predefinidas, y otres soporten macros definíes (y repetidamente redefinibles) pol programador qu'impliquen secuencies de llinies del testu nes cualos les variables y les constantes tán empotraes. Esta secuencia de llinies de testu puede incluyir *opcodes* o direutives. Una vegada una macro defínese, el so nome puede usase en llugar d'un mnemónico. Cuando'l ensamblador procesa tal sentencia, reemplaza la sentencia peles llinia del testu acomuñaes a esa macro, entós procesar como si esistieren nel archivu del códigu fonte orixinal (incluyendo, en dellos ensambladores, la espansión de cualesquier macro qu'esista nel testu de reemplazu).

Yá que les macros pueden tener nomes curtios pero espandir a delles, o ello ye que munches llinies de códigu, pueden usase pa faer que los programes en llinguaxe ensamblador paezan ser muncho más curtios, riquiendo menos llinies de códigu fuente, como asocede colos llinguaxes d'altu nivel. Tamién pueden usase p'añader niveles d'estructura más altos a los programes ensamblador; opcionalmente introducen código de depuración empotráu vía parámetro y otres carauterístiques similares.

Munchos ensambladores tienen macros incorporaes (o predefinidas) pa les llamaes de sistema y otres secuencies especiales de códigu, tales como la xeneración y l'almacenamientu de los datos realizaos al traviés d'avanzaes operaciones *[[bitwise]]* y operaciones booleanas usaes en xuegos, software de seguridá, xestión de datos y criptografía.

Los macro ensambladores de cutiu dexen a les macros tomar parámetros. Dellos ensambladores inclúin llinguaxes macro bien sofisticaos, incorporando elementos de llinguaxes d'altu nivel tales como parámetros opcionales, variables simbóliques, condiciones, manipulaciones de *[[string]]s*, operaciones aritmétiques, toos usables mientres la execución d'una macro dada, y dexando a les macros guardar el contestu o intercambiar información. Asina una macro puede xenerar un gran númberu d'instruiciones o definiciones de datos en llinguaxe ensamblador, basaes nos argumentos de la macro. Esto podríase usar pa xenerar, por casu, estructures de datos d'estilu de récor o bucles "desenrollados", o podría xenerar algoritmos enteros basaos en parámetros complexos. Una organización, usando llinguaxe ensamblador, que foi fuertemente estendíu usando tal suite de macros, pue ser considerada que se ta trabayando nun llinguaxe d'altu nivel, yá que tales programadores nun tán trabayando colos elementos conceptuales de más so nivel del ordenador.

Les macros usar p'afaer sistemes de software de gran escala pa veceros específicos na era del *[[mainframe]]*, y tamién s'usaron pol personal del veceru pa satisfaer les necesidaes de los sos patrones faciendo versiones específiques de los sistemes operativos del fabricante. Esto foi fechu, por casu, polos programadores de sistema que trabayaben col *Conversational Monitor System / Virtual Machine (CMS/VM)* de IBM y colos complementos *real time transaction processing* de IBM, CICS, *Customer Information Control System*, el *airline/financial system* qu'empezó nos años 1970 ya inda cuerre con munchos sistemes de reservaciones computarizados (CRS) y sistemes de tarxeta de creitu de güei.

Tamién ye posible usar solamente les habilidaes de procesamientu de macros d'un ensamblador pa xenerar códigu escritu en llinguaxes dafechu distintos. Por casu, pa xenerar una versión d'un programa en COBOL usando un programa macro ensamblador puru conteniendo llinies de códigu COBOL dientro d'operadores de tiempu ensamblaxe dando instruiciones al ensamblador pa xenerar códigu arbitrariu.

Esto yera porque, como nos años 1970 foi reparáu, el conceutu de "procesamientu de macro" ye independiente del conceutu de "ensamblaxe", siendo l'anterior, en términos modernos, más un procesamientu de testos, qu'una xeneración de códigu oxetu. El conceutu de procesamientu de macro apaeció, y apaez, nel llinguaxe de programación C, que soporta "instruiciones de preprocesador" d'afitar variables, y fai pruebes condicionales nos sos valores. Repare qu'a diferencia de ciertos macroprocesadores previos dientro de los ensambladores, el preprocesador de C nun ye Turing-completu porque escarecía de la capacidá de bucle o *go to*, esto últimu dexando a los programes faer bucles.

A pesar del poder del procesamientu macro, ésti dexó d'usase en munchos llinguaxes d'altu nivel (una importante esceición ye C/C++) ente que siguía siendo perenne pa los ensambladores. Esto yera porque munchos programadores taben bastante confundíos pola sustitución de parámetros macro y nun estremaben la diferencia ente procesamientu macro, l'ensamblaxe y la execución.

La sustitución de parámetros macro ye puramente por nome: nel tiempu de procesamientu macro, el valor d'un parámetru ye sustituyíu testualmente pol so nome. La clase más famosa d'Error de software resultantes yera l'usu d'un parámetru qu'en sí mesmu yera una espresión y non un nome primariu cuando l'escritor macro esperaba un nome. Nel macro:

:foo: macro a :load a*b.

la intención yera que la rutina que llama apurriría'l nome d'una variable, y la variable o constante "global b" sería usada pa multiplicar a "a". Si foo llamar col parámetru `a-c`, asocede la espansión macro `load a-c*b`. Pa evitar cualesquier posible ambigüedá, los usuarios de macro procesadores pueden zarrar en paréntesis los parámetros formales dientro de les definiciones de macros, o les rutines que llamen pueden envolubrar en paréntesis los parámetos d'entrada. Asina, el macro correutu, colos paréntesis, sería:

:foo: macro a :load (a)*b.

y la so espansión, daría como resultáu: `load (a-c)*b`

El PL/I y el C/C++ ufierten macros, pero la esta facilidá solo puede manipoliar testu. Per otra parte, los llinguaxes homoicónicos, tales como Lisp, Prolog, y Forth, retienen el poder de los macros de llinguaxe ensamblador porque pueden manipoliar el so propiu códigu como datos.

### Soporte pa programación estructurada

Dellos ensambladores incorporaron elementos de programación estructurada para codificar el fluxu de la execución. L'exemplu más tempranu d'esti acercamientu taba nel Concept-14 macro set, orixinalmente propuestu pol Dr. H.D. Mills (marzu de 1970), ya implementáu por Marvin Kessler na *Federal Systems Division* de IBM, qu'estendió'l macro ensamblador del S/360 con bloques de control de fluxu IF/ELSE/ENDIF y similares. Esto yera una manera d'amenorgar o esaniciar l'usu d'operaciones GOTO nel códigu en llinguaxe ensamblador, unu de los principales factores que causaben códigu espagueti nel llinguaxe ensamblador. Esti acercamientu foi llargamente aceptáu a principios de los años 1980 (los últimos díes del usu de llinguaxe ensamblador en gran escala).

Un interesáu diseñu foi A-natural, un ensamblador "empobináu a la corriente" (stream-oriented) pa los procesadores 8080/Z80 de Whitesmiths Ltd. (desarrolladores del sistema operativu Idris, similar al Unix), y lo que foi reportáu como'l primera compilador C comercial). El llinguaxe foi clasificáu como un ensamblador, porque trabayaba con elementos de máquina crudos tales como opcodes, rexistros, y referencies de memoria; pero incorporaba una sintaxis d'espresión pa indicar l'orde d'execución. Los paréntesis y otros símbolos especiales, xunto con construcciones de programación estructurada empobinaes a bloques, controlaben la secuencia de les instruiciones xeneraes. A-natural foi construyíu como'l llinguaxe oxetu d'un compilador C, en cuenta de la codificación manual, pero la so sintaxis lóxica ganó dellos siguidores.

Hubo poca demanda aparente pa ensambladores más sofisticaos por cuenta de la declinación del desenvolvimientu de llinguaxe ensamblador de llarga escala. A pesar d'eso, inda se tán desenvolviendo y aplicando en casos onde les llimitaciones de recursos o les particularidaes na arquiteutura de sistema oxetivu previenen l'efeutivu usu de llinguaxes d'altu nivel.

## Usu del llinguaxe ensamblador

### Perspeutiva histórica

Los llinguaxes ensambladores fueron primeru desenvueltos nos años 1950, cuando fueron referíos como llinguaxes de programación de segunda xeneración. Por casu, el SOAP (Symbolic Optimal Assembly Program) yera un llinguaxe ensamblador de 1957 pal ordenador IBM 650. Los llinguaxes ensambladores esaniciaron muncha de la propensión a errores y del consumu de tiempu de la programación de los llinguaxes de primer xeneración, que se precisaba colos primeros ordenadores, lliberando a los programadores de l'aburrición tal como recordar códigos numbéricos y cálculu de direiciones. Una vegada fueron llargamente usaos pa tou tipu de programación. Sicasí, pelos años 1980 (1990 nos microcomputadores), el so usu fuera en gran parte suplantáu polos llinguaxes d'altu nivel, na busca d'una ameyorada productividá en programación. Anguaño, anque'l llinguaxe ensamblador ye casi siempres remanáu y xeneráu polos compiladores, inda s'usa pa la manipulación direuta del hardware, accesu a instruiciones especializaes del procesador, o pa resolver problemes de desempeñu críticu. Los usos típicos son controladores/manejadores (*drivers*) de dispositivu, sistemes enfiñíos de baxu nivel, y sistemes de tiempu real.

Históricamente, un gran númberu de programes fueron escritos dafechu en llinguaxe ensamblador. Los sistemes operativos fueron casi puramente escritos en llinguaxe ensamblador hasta l'aceptación amplia del llinguaxe de programación C nos años 1970 y principios de los 1980. Tamién, munches aplicaciones comerciales fueron escrites en llinguaxe ensamblador, incluyendo una gran cantidá del software escritu por grandes corporaciones pa mainframes de IBM. Los llinguaxes COBOL y FORTRAN eventualmente movieron enforma d'esti trabayu, anque un númberu d'organizaciones grandes caltuvieren les infraestructures d'aplicaciones en llinguaxe ensamblador hasta bien entraos los años 1990.

La mayoría de los primeres microcomputadores confiaron nel llinguaxe ensamblador codificado a mano, incluyendo la mayoría de los sistemes operativos y de les aplicaciones grandes. Esto yera porque estos sistemes teníen llimitaciones severes de recursos, impunxeron idiosincrátiques arquitectures de memoria y de pantalla, y apurrieron servicios de sistema llindaos y con errores. Quiciabes más importante yera la falta de compiladores de primer clase de llinguaxes d'altu nivel fayadizos pal usu nel microcomputador. Un factor psicolóxicu tamién pudo xugar un papel: la primer xeneración de programadores de los microcomputadores caltuvo una actitú d'aficionáu de "alambres y alicates".

Nun contestu más comercial, les más grandes razones pa usar el llinguaxe ensamblador yera faer programes con mínimu tamañu, mínima sobrecarga, mayor velocidá y confiabilidad.

Los típicos exemplos de programes grandes en llinguaxe ensamblador d'esi tiempu son los sistemes operativos IBM PC DOS y aplicaciones tempranes tales como la fueya de cálculu Lotus 1-2-3, y casi tolos xuegos populares pa la familia Atari 800 d'ordenadores personales. Inclusive nos años 1990, la mayoría de los videoxuegos de consola fueron escritos n'ensamblador, incluyendo la mayoría de los xuegos pa la Mega Drive/Genesis y el Super Nintendo Entertainment System. Según dellos insiders de la industria, el llinguaxe ensamblador yera'l meyor llinguaxe de programación a usar pa llograr el meyor desempeñu del Sega Saturn, una consola pa la cual yera notoriamente griespa desenvolver y programar xuegos. El popular xuegu d'arcade NBA Jam (1993) ye otru exemplu. L'ensamblador foi por llargu trechu, el llinguaxe de desenvolvimientu primariu nos ordenadores llariegos Commodore 64, Atari ST, según el ZX Spectrum. Esto foi asina en gran parte porque los dialeutos del BASIC nestos sistemes ufiertaron insuficiente velocidá d'execución, según insuficientes carauterístiques p'aprovechar dafechu'l hardware disponible. Dellos sistemes, más notablemente l'Amiga, inclusive tienen IDEs con carauterístiques de depuración y macros altamente avanzaos, tales como'l freeware *ASM-One assembler*, comparable a les del Microsoft Visual Studio (el ASM-Unu preciede al Microsoft Visual Studio).

L'ensamblador pal VIC-20 foi escritu por Don French y publicáu por French Silk. Con 1639 bytes de llargor, el so autor cree que ye'l más pequeñu ensamblador simbólicu enxamás escritu. L'ensamblador soportaba'l direccionamientu simbólicu avezáu y la definición de cadenes de calteres o cadenes hexadecimales. Tamién dexaba espresiones de direiciones que podíen combinase coles operaciones d'adición, sustraición, multiplicación, división, AND lóxicu, OR lóxicu, y exponenciación.

### Usu actual

Siempres hubo alderiques sobre la utilidá y el desempeñu del llinguaxe ensamblador relativu a llinguaxes d'altu nivel. El llinguaxe ensamblador tien nichos específicos onde ye importante (ver embaxo). Pero, polo xeneral, los modernos compiladores de optimización pa traducir llinguaxes d'altu nivel en códigu que puede correr tan rápido como'l llinguaxe ensamblador escritu a mano, a pesar de los contraejemplos que pueden ser atopaos. La complexidá de los procesadores modernos y del subsistema de memoria fai la optimización efeutiva cada vez más difícil pa los compiladores, según pa los programadores n'ensamblador. Adicionalmente, y pa la consternación de los amantes de la eficiencia, el desempeñu cada vez mayor del procesador significó que la mayoría de los CPU tean sacupaos la mayor parte del tiempu, con retardos causaos por embotellamientos predecibles tales como operaciones de entrada/salida y paxinación de memoria. Esto fizo que la velocidá d'execución cruda del códigu nun sía un problema pa munchos programadores.

Hai delles situaciones nes cualos los profesionales pudieren escoyer utilizar el llinguaxe ensamblador. Por casu cuando:

* Ye riquíu un ejecutable binariu independiente (stand-alone), ye dicir unu que tenga d'executase ensin recursos a componentes de tiempu d'execución o a biblioteques acomuñaes con un llinguaxe d'altu nivel; ésta ye quiciabes la situación más común. Son programes empotraos que solo almacenen una pequeña cantidá de memoria y el dispositivu ta dirixíu pa faer xeres pa un simple propósitu. Exemplos consisten en teléfonos, sistemes de combustible y ignición p'automóviles, sistemes de control del aire acondicionáu, sistemes de seguridá, y sensores
* Interactuando direutamente col hardware, por casu en controladores (*drivers*) de dispositivu y manejadores d'interrupción
* Usando instruiciones específiques del procesador ensin esplotar o disponibles pol compilador. Un exemplu común ye la instruición de rotación bitwise nel nucleu de munchos algoritmos de cifráu
* Creando funciones vectorizadas pa programes en llinguaxes d'altu nivel como C. Nel llinguaxe d'altu nivel esto ye dacuando ayudáu por funciones intrínseques del compilador que mapean direutamente a los mnemónicos del SIMD, pero sicasí resulta nuna conversión de ensamblador d'unu a unu pa un procesador de vector acomuñáu
* Ye riquida la optimización estrema, ej, nun bucle internu nun algoritmu intensivu nel usu del procesador. El programadores de xuegos tomen ventaya de les habilidaes de les carauterístiques del hardware nos sistemes, dexando a los xuegos correr más rápido. Tamién les grandes simulaciones científiques riquen algoritmos altamente optimizaos, ej, álxebra llinial con BLAS o la tresformada de cosenu discreta (ej, la versión SIMD n'ensamblador del x264, (una biblioteca pa codificar streams de video)
* Un sistema con severes llimitaciones de recursos (ej, un sistema empotráu) ten de ser codificado a mano pa maximizar l'usu de los llindaos recursos; pero esto ta aportando a menos común a midida que el preciu del procesador escai y el desempeñu ameyora *
Nun esiste nengún llinguaxe d'altu nivel, nun procesador nuevu o especializáu, por casu
* Escribiendo programes de tiempu real que precisen sincronización y respuestes precises, tales como sistemes de navegación de vuelu, y equipu médicu. Por casu, nun sistema fly-by-wire (vuelu por mandos llétricos), la telemetría tien de ser interpretada y hai qu'actuar dientro de llimitaciones estrictes de tiempu. Tales sistemes tienen d'esaniciar fontes de retrasos impredicibles, que pueden ser creaos por (dalgunos) llinguaxes interpretaos, recoyida de basura automática, operaciones de paxinación, o multitarea preventiva. Sicasí, dellos llinguaxes d'altu nivel incorporen componentes de tiempu d'execución y interfaces de sistema operativu que pueden introducir tales retrasos. Escoyer l'ensamblador o llinguaxes de baxu nivel pa tales sistemes da a los programadores mayor visibilidá y control sobre'l procesu de los detalles
* Ye riquíu control total sobre l'ambiente, en situaciones de seguridá desaxeradamente alta onde nada puede dase por sentáu.
* Escríbense virus d'ordenador, bootloaders, ciertos controladores/manejadores de dispositivu, o otros elementos mui cerca del hardware o al sistema operativu de baxu nivel
* Escríbense simuladores del conxuntu d'instruiciones pa monitoreo, trazáu y depuración d'errores onde la sobrecarga adicional ye caltenida al mínimu *
Faise inxeniería inversa en binarios esistentes que pueden o nun ser escritos orixinalmente nun llinguaxe d'altu nivel, por casu al crackear la proteición anticopia del software propietariu.
* Faise inxeniería inversa y cambéu de video xuegos (tamién denomináu ROM hacking), que ye posible per mediu de dellos métodos. El más llargamente implementáu ye alteriando'l códigu del programa a nivel de llinguaxe ensamblador
* Escríbese códigu automodificable, daqué para lo que'l llinguaxe ensamblador empréstase bien S'escriben xuegos y otros softwares para calculadores gráfiques
* Escríbese software compilador que xenera códigu ensamblador, y polo tanto los desarrolladores tienen de ser programadores de llinguaxe ensamblador
* Escríbense algoritmos criptográficos que siempres tienen de tomar puramente'l mesmu tiempu pa executar, previniendo ataques de tiempu

Sicasí, el llinguaxe ensamblador ye inda enseñáu na mayoría de los programes de ciencies de la computación y inxeniería electrónica. Anque anguaño, pocu programadores trabayen regularmente col llinguaxe ensamblador como una ferramienta, los conceutos fundamentales siguen siendo bien importantes. Tales tópicos fundamentales, como aritmética binaria, asignación de memoria, procesamientu del stack, codificación de conxuntu de calteres, procesamientu d'interrupciones, y diseñu de compiladores, seríen duros d'estudiar en detalle ensin la comprensión de cómo'l ordenador opera a nivel del hardware. Yá que el comportamientu del ordenador ye fundamentalmente definíu pol so conxuntu d'instruiciones, la manera lóxica d'aprender tales conceutos ye estudiar un llinguaxe ensamblador. La mayoría de los ordenadores modernos tienen un conxuntu d'instruiciones similares. Poro, estudiar un solu llinguaxe ensamblador ye abondu p'aprender: i) los conceutos básicos; ii) reconocer situaciones onde l'usu de llinguaxe ensamblador pue ser apropiáu; y iii) ver cómo'l códigu ejecutable eficiente pue ser creáu polos llinguaxes d'altu nivel

### Aplicaciones típiques

El llinguaxe ensamblador hard-coded ye típicamente usáu nel ROM d'arranque del sistema (BIOS nos sistemes compatible IBM PC). Esti códigu de baxu nivel ye usáu, ente otres coses, pa inicializar y probar el hardware del sistema antes de cargar el sistema operativu, y ta almacenáu nel ROM. Una vegada que tomó llugar un ciertu nivel de inicialización del hardware, la execución tresferir a otru códigu, típicamente escritu en llinguaxes d'altu nivel; pero'l códigu corriendo darréu dempués de que ye aplicada la enerxía usualmente ta escritu en llinguaxe ensamblador. Lo mesmo ye ciertu pa los boot loaders.

Munchos compiladores traducen llinguaxes d'altu nivel a llinguaxe ensamblador primeru, antes de la compilación completa, dexando que'l códigu n'ensamblador sía vistu pa propósitos de depuración y optimización. Llinguaxes de relativu baxu nivel, como C, con frecuencia aproven sintaxis especial pa empotrar llinguaxe ensamblador en cada plataforma de hardware. El códigu portable del sistema entós puede usar estos componentes específicos a un procesador al traviés d'una interface uniforme.

El llinguaxe ensamblador tamién ye pervalible n'inxeniería inversa, yá que munchos programes solamente son distribuyíos nuna forma de códigu de máquina. El códigu de máquina ye usualmente bono de treslladar escontra llinguaxe ensamblador pa depués ser curioso esamináu nesta forma, pero ye bien malo de treslladar escontra un llinguaxe d'altu nivel. Ferramientes como Interactive Disassembler, faen usu estensu del desensamblador para tales propósitos.

Un nichu que fai usu del llinguaxe ensamblador ye'l demoscene. Ciertes competiciones riquen a los concursantes acutar les sos creaciones a un bien pequeñu tamañu (ej, 256 bytes, 1 KB, 4 KB ó 64 KB), y el llinguaxe ensamblador ye'l llinguaxe de preferencia p'algamar esti oxetivu. Cuando los recursos son una esmolición, ye una necesidá la codificación n'ensamblador, especialmente en sistemes constreñidos pol procesamientu del CPU, como los primeros modelos del Amiga, y el Commodore 64. El códigu optimizáu n'ensamblador ye escritu "a mano" polos programadores nun intentu d'embrivir el númberu de ciclos de CPU usaos. Les llimitaciones del CPU son tan grandes que cada ciclu cunta. Usar tales métodos habilitó, a sistemes como'l Commodore 64, pa producir gráficos en 3D en tiempu real con efeutos avanzaos, una fazaña que puede ser considerada improbable o inclusive imposible pa un sistema con un procesador de 0.99 MHz.

## Detalles adicionales

Pa un determináu ordenador personal, mainframe, sistema empotráu, y consola de xuegos, tantu del pasáu como del presente, foi escritu siquier unu, y posiblemente docenes de ensambladores. Pa dellos exemplos, vea la llista de ensambladores.

Nos sistemes Unix, l'ensamblador ye llamáu tradicionalmente as, anque nun ye un simple cuerpu de códigu, siendo típicamente escritu unu nuevu por cada port. Un númberu de variantes de Unix usen el GAS

Dientro de los grupos de procesadores, cada ensamblador tien el so propiu dialeutu. Dacuando, dellos ensambladores pueden lleer el dialeutu d'otru, por casu, TASM puede lleer el vieyu códigu del MASM, pero non al aviesu. FASM y NASM tienen una sintaxis similar, pero cada unu soporta distintos macros que pueden ser malo de treslladar d'unu al otru. Les coses básiques son siempres les mesmes, pero les carauterístiques avanzaes van ser distintes

Tamién, los llinguaxes ensambladores dacuando pueden ser portables al traviés de distintos sistemes operativos nel mesmu tipu de CPU. Les convenciones de llamaes ente los sistemes operativos con frecuencia difieren llixeramente o en nada. y con cuidu ye posible ganar portabilidad nel llinguaxe ensamblador, usualmente al enllazar con una biblioteca de llinguaxe C que nun camuda ente sistemes operativos. Un simulador de conxuntu d'instruiciones (qu'idealmente sería escritu en llinguaxe ensamblador) puede, en teoría, procesar el códigu oxetu/binariu de *cualesquier* ensamblador) pa llograr la portabilidad inclusive al traviés de plataformes (con una sobrecargue non mayor que la d'un interpretador de bytecode típicu). Esto ye esencialmente lo que llogra'l microcódigo cuando una plataforma de hardware camuda internamente.

Por casu, munches coses en libc dependen del preprocesador pa faer, al programa antes de compilar, coses que son específiques del sistema operativu o específiques del C. Ello ye que delles funciones y símbolos nin siquier tán garantizaos qu'esistan fuera del preprocesador. Peor entá, el tamañu y l'orde de los campos de les estructures, tanto como'l tamañu de ciertes typedefs como *off_t*, nun tán disponibles en llinguaxe ensamblador ensin l'ayuda d'un script de configuración, y difieren inclusive ente versiones de Linux, faciendo imposible portar llamaes de funciones en libc distintes de los que tomen simples enteros o piqueros como parámetros. Pa remanar estos problemes, el proyeutu FASMLIB aprove una biblioteca de llinguaxe ensamblador portable pa les plataformes Win32 y Linux, pero inda ta bien incompleta.

Dellos llinguaxes de bien altu nivel, como C y Borland/Pascal, soporten ensamblado en llinia, onde relativamente seiciones curties de códigu n'ensamblador puede ser empotraes dientro del códigu del llinguaxe d'altu nivel. El llinguaxe Forth comúnmente contién un ensamblador usáu pa codificar pallabres.

La mayoría de la xente usa un emulador para depurar los sos programes en llinguaxe ensamblador.

## Exemplos de llinguaxe ensamblador

### Exemplu pa l'arquiteutura x86
El siguiente ye un exemplu del programa clásicu *[[Hola mundu]]* escritu pa l'arquiteutura de procesador x86 (sol sistema operativu DOS).


```asm
; ---------------------------------------------
; Programa qu'imprime un string na pantalla ;
---------------------------------------------
 .model small ; modelu de memoria

 .stack ; segmentu del stack

 .data ; segmentu de dato Cadena1
 DB 'Hola Mundu.$' ; string a imprimir (rematáu en $)

 .code ; segmentu del códigu

; ---------------------------------------------
; Entamu del programa ;
---------------------------------------------
 programa:
 ; ----------------------------------------------------------------------------------------------------
 ; empecipia'l segmentu de datos
 ; ----------------------------------------------------------------------------------------------------
 MOV AX, @data ; carga en AX la direición del segmentu de datos
 MOV DS, AX ; mueve la direición al rexistru de segmentu per mediu de AX
 
 ; ----------------------------------------------------------------------------------------------------
 ; Imprime un string en pantalla ;
 ----------------------------------------------------------------------------------------------------
 MOV DX, offset Cadena1 ; mueve a DX la direición del string a imprimir
 MOV AH, 9 ; AH = códigu pa indicar al MS DOS qu'imprima na pantalla, el string en DS:DX
 INT 21h ; llamada al MS DOS pa executar la función (nesti casu especificada n'AH)
 
 ; ----------------------------------------------------------------------------------------------------
 ; Remata'l programa ;
 ----------------------------------------------------------------------------------------------------
 INT 20h ; llamada al MS DOS pa rematar el programa

 end programa
```
.

### Exemplu pal ordenador virtual (POCA)
Una seleición d'instruiciones pa un ordenador virtual) coles correspondientes direiciones de memoria nes que se van allugar les instruiciones. Estes direiciones NUN son estátiques. Cada instruición acompañar del códigu en llinguaxe ensamblador xeneráu (códigu oxetu) que coincide cola arquiteutura d'ordenador virtual, o conxuntu d'instruiciones ISA.

### Exemplu pal µC Intel 8051
Códigu en llinguaxe ensamblador para µC Intel 80C51:


```asm
ORG 8030H
 include
 T05SEG:
 SETB TR0
 JNB uSEG,T05SEG ;esta subrutina ye utilizada CLR
 TR0 ;pa realizar una cuenta de CPL
 uSEG ;0,5 segundos por aciu la MOV
 R1,DPL ;interrupción del timer 0.
 INVOKE
 MOV R2,DPH
 CJNE R2,#07H,T05SEG
 CJNE R1,#78H,T05SEG
 MOV DPTR,#0
 RET
```


### Exemplu pal Microchip PIC16F84

Códigu en llinguaxe ensamblador pal microcontrolador 16F84 de Microchip:


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


## Ver tamién

## Referencies

## Bibliografía
* Dominic Sweetman: *See MIPS Run*. Morgan Kaufmann Publishers, 1999. ISBN 1-55860-410-3
* Robert Britton: *MIPS Assembly Language Programming*. Prentice Hall, 2003. ISBN 0-13-142044-5
* John Waldron: *Introduction to RISC Assembly Language Programming*. Addison Wesley, 1998. ISBN 0-201-39828-1
* ''ASM Community Book'' "An online book full of helpful ASM info, tutorials and code examples" by the ASM Community
* Jonathan Bartlett: *[http://programminggroundup.blogspot.com/ Programming from the Ground Up]*. Bartlett Publishing, 2004. ISBN 0-9752838-4-7Also available online 
* Paul Carter: *PC Assembly Language*. Free ebook, 2001.Website 
* Jeff Duntemann: *Assembly Language Step-by-Step*. Wiley, 2000. ISBN 0-471-37523-3
* Randall Hyde: *The Art of Assembly Language*. Non Starch Press, 2003. ISBN 1-886411-97-2Draft versions available online as PDF and HTML
* Peter Norton, John Socha, *Peter Norton's Assembly Language Book for the IBM PC*, Brady Books, NY: 1986.
* Michael Singer, *PDP-11. Assembler Language Programming and Machine Organization*, John Wiley & Sons, NY: 1980.

## Enllaces esternos

* The Art of Assembly Language Programming, *
Computer-Books.us, Online Assembly Language Brooks
* PC Assembly Tutorial using NASM and GCC  by Paul Carter
* Programming from the Ground Up by Jonathan Bartlett
* The ASM Book by the ASM Community
* Inline::ASM módulu Perl en CPAN pa programar en llinguaxe ensamblador dientro de programes Perl (n'inglés)
* Exemplos práuticos de ensamblador en GNU/Linux