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ódigo fuente escritu nel llinguaxe ensamblador a códigu oxeto que depués va ser enllazáu pa producir llinguaxe de máquina). Los dos espresiones siguientes utilicen el términu "ensamblador":

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 primeres 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 (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:

1011 0000 01100001
 | | |
 | | +---- Númberu 61h en binariu |
 | 
 | +--- Rexistru A LA Instruición MOV

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.

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

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ódigo 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 strings, 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 oxeto. 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 l'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 textualmente 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 :aponderái 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 aponderái 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.^[4] Asina, el macro correutu, colos paréntesis, sería:

foo: macro a :aponderái (a)*b.

y la so espansión, daría como resultáu: aponderái (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.^[5] 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^{[ensin referencies]} 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 oxeto 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.^[6] 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.^[7]

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,^{[ensin referencies]} 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.^{[ensin referencies]} 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.^[8] 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.^[9]

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.^[10][11][12] 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.^[13][14] 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,^[15] (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, recueya 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^[16]
• 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^[17]

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.^[18] 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.^{[ensin referencies]}

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).

; ---------------------------------------------
; 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^[21]) 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 oxeto) 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:

 
 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:

 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