From Wikipedia, the free encyclopedia
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.
 | |
| Estensión de ficheru |
.asm .s |
|---|---|
| Versión inicial | 1949 |
| Tipu | llinguaxe de programación |
| Etiqueta de Stack Exchange | Stack Exchange |
 | |
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.
Xeneralmente, un programa ensamblador (assembler n'inglés) modernu crea códigu oxeto traduciendo instruiciones mnemónicas de llinguaxe ensamblador en opcodes, y resolviendo los nomes simbólicos pa les llocalizaciones de memoria y otres entidaes.[1] 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.
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.[2]
Los más sofisticaos ensambladores d'altu nivel apurren astraiciones del llinguaxe tales como:
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 oxeto que depués va ser enllazáu pa producir llinguaxe de máquina). Los dos espresiones siguientes utilicen el términu "ensamblador":
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.
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 booleanas. Operaciones lóxiques bit a bit como AND, OR, XOR, NOT
Operaciones de mover datos:
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
OUTPUT Escritura escontra un puertu de salida
Operaciones pal control del fluxu del programa:
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 trascendentales
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).
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.
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
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 01100001La cual puede ser entendida y executada direutamente pol procesador.
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:
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, BCxenera les instruiciones
LD L, CLD H, B.[3]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.
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
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.
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 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 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:
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:
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.
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]
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]
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:
Nun esiste nengún llinguaxe d'altu nivel, nun procesador nuevu o especializáu, por casu
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.
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]
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]
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[19]
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 oxeto/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.[20]
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.
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
.
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.
| Dir. | Etiqueta | Instruición | Código máquina[22] |
|---|---|---|---|
| .begin | |||
| .org 2048 | |||
| a_start | .equ 3000 | ||
| 2048 | ld length,% | ||
| 2064 | be done | 00000010 10000000 00000000 00000110 | |
| 2068 | addcc %r1,-4,%r1 | 10000010 10000000 01111111 11111100 | |
| 2072 | addcc %r1,%r2,%r4 | 10001000 10000000 01000000 00000010 | |
| 2076 | ld %r4,%r5 | 11001010 00000001 00000000 00000000 | |
| 2080 | ba loop | 00010000 10111111 11111111 11111011 | |
| 2084 | addcc %r3,%r5,%r3 | 10000110 10000000 11000000 00000101 | |
| 2088 | done: | jmpl %r15+4,%r0 | 10000001 11000011 11100000 00000100 |
| 2092 | length: | 20 | 00000000 00000000 00000000 00010100 |
| 2096 | address: | a_start | 00000000 00000000 00001011 10111000 |
| .org a_start | |||
| 3000 | a:</tt |
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
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
Ensambladores
Desensambladores
Depuradores
Otros
Sistemes operativos escritos dafechu en assembler:
Seamless Wikipedia browsing. On steroids.
Every time you click a link to Wikipedia, Wiktionary or Wikiquote in your browser's search results, it will show the modern Wikiwand interface.
Wikiwand extension is a five stars, simple, with minimum permission required to keep your browsing private, safe and transparent.
