|
El término '''ensamblador''' (del inglés ''assembler'') se refiere a un tipo de [[Programa (computación)|programa informático]] que se encarga de traducir un [[fichero fuente]] escrito en un [[lenguaje ensamblador]], a un [[fichero objeto]] que contiene [[código máquina]], ejecutable directamente por la [[Microprocesador | máquina]] para la que se ha generado. El propósito para el que se crearon este tipo de aplicaciones es la de facilitar la escritura de programas, ya que escribir directamente en [[código binario]], que es el único código entendible por la computadora, es en la práctica imposible. La evolución de los lenguajes de programación a partir del lenguaje ensamblador originó también la evolución de este programa ensamblador hacia lo que se conoce como programa [[compilador]].
[[Imagen:Codigo de maquina.png|thumbnail|400px|[[Lenguaje de máquina]] del [[Intel 8088]]. El código de máquina se resalta en rojo, el equivalente en lenguaje assembler en magenta, y las direcciones de memoria donde se encuentra el código, en azul.]]
== Funcionamiento ==
El '''lenguaje Assembly''' (a veces mal llamado "Ensamblador" por su traducción literal al español) es un tipo de [[lenguaje de bajo nivel]] utilizado para escribir [[programas informáticos]], y constituye la representación más directa del [[lenguaje de máquina|código máquina]] específico para cada [[arquitectura de computadoras]] legible por un programador.
El programa lee el fichero escrito en lenguaje ensamblador y sustituye cada uno de los códigos [[Código nemotécnico|nemotécnicos]] que aparecen por su [[código de operación]] correspondiente en sistema binario para la plataforma que se eligió como destino en las opciones específicas del ensamblador.cc
== Tipos de ensambladores ==
Fue usado principalmente en los inicios del desarrollo de [[software]], cuando aun no se contaba con los potentes lenguajes de alto nivel. Actualmente se lo utiliza particularmente en ambientes académicos y de investigación, especialmente cuando se requiere la manipulación directa de [[hardware]], se pretenden altos rendimientos o un uso de recursos controlado y reducido. Muchos dispositivos programables (como los microcontroladores) aun cuentan con el Assembly como la única manera de ser manipulados.
{{AP|Ensamblador de alto nivel}}
Podemos distinguir entre tres tipos de ensambladores:
* '''Ensambladores básicos'''. Son de muy bajo nivel, y su tarea consiste básicamente en ofrecer nombres simbólicos a las distintas [[instrucción|instrucciones]], parámetros y cosas tales como los modos de direccionamiento. Además, reconoce una serie de '''directivas''' (o [[meta instrucciones]]) que indican ciertos parámetros de funcionamiento del ensamblador.
== Características ==
* el código escrito en lenguaje Assembly posee una cierta dificultad de ser entendido directamente por un ser humano ya que su estructura se acerca mas bien al lenguaje máquina (lenguaje de bajo nivel).
* El lenguaje Assembly es dificilmente portable, es decir, un código escrito para un microprocesador en particular necesita ser modificado muchas veces en su totalidad para poder usado en otro microprocesador.
* Los programas hechos en lenguaje Assembly son generalmente más rápidos y consumen menos recursos del sistema (memoria RAM y ROM). Al programar cuidadosamente en lenguaje Assembly se pueden crear programas que se ejecutan más rápidamente y ocupan menos espacio que con lenguajes de alto nivel.
* Con el lenguaje Assembly se tiene un control muy preciso de las tareas realizadas por un [[microprocesador]] por lo que se pueden crear segmentos de código difíciles de programar en un lenguaje de alto nivel.
* '''Ensambladores modulares''', o [[macro ensamblador]]es. Descendientes de los ensambladores básicos, fueron muy populares en las décadas de los [[1950s|50]] y los [[1960s|60]], antes de la generalización de los [[lenguaje de alto nivel|lenguajes de alto nivel]]. Hacen todo lo que puede hacer un ensamblador, y además proporcionan una serie de directivas para definir e invocar [[macroinstrucción|macroinstrucciones]] (o simplemente, '''macros'''). ''Véase [[X86]]''.</li>
== Ensambladores ==
Un [[Ensamblador]] (Assembler en inglés) es un programa que crea [[código objeto]] traduciendo instrucciones [[Mnemónicos|mnemónicas]] de un programa fuente escrito en Assembly a códigos ejecutables e interpretando los nombres simbólicos para direcciones de memoria y otras entidades (ensamblado). El uso de referencias simbólicas es una característica básica del lenguaje Assembly, evitando tediosos cálculos y direccionamiento manual después de cada modificación del programa. La mayoría de los Ensambladores también incluyen facilidades para crear [[macro]]s, a fin de generar series de instrucciones cortas que se ejecutan en tiempo real, en lugar de utilizar subrutinas.<ref>David Salomon, ''Assemblers and Loaders''. 1993 [http://www.davidsalomon.name/assem.advertis/asl.pdf]</ref>
* '''Ensambladores modulares 32-bits''' o '''de alto nivel'''. Son ensambladores que aparecieron como respuesta a una nueva arquitectura de procesadores de 32 bits, muchos de ellos teniendo ''compatibilidad hacia atrás'' pudiendo trabajar con programas con estructuras de 16 bits. Además de realizar la misma tarea que los anteriores, permitiendo también el uso de macros, permiten utilizar estructuras de programación más complejas propias de los lenguajes de alto nivel.
Los Ensambladores son por lo general más fáciles de programar que los [[compilador]]es de lenguajes de alto nivel, y han estado disponibles desde la década de [[1950]]. Los Ensabladores modernos, especialmente para arquitecturas basadas en [[RISC]], como por ejemplo [[MIPS]], [[SPARC]] y [[PA-RISC]] optimizan las instrucciones para explotar al máximo la eficiencia de [[segmentación (informática)|segmentación]]<ref>''Pipeline'' en inglés.</ref> del [[CPU]].
Los Ensambladores avanzados ofrecen posibilidades de abstracción que incluyen:
* Control avanzado de estructuras.
* Procedimientos de alto nivel, declaración de funciones.
* Tipos de datos que incluyen estructuras, registros, uniones, clases y conjuntos.
* Sofisticado procesamiento de macros.
== Lenguaje ==
Un programa escrito en lenguaje Assembly consiste en una serie de instrucciones que corresponden al flujo de órdenes ejecutables que pueden ser cargadas en la memoria de un sistema basado en microprocesador.
Por ejemplo, un procesador [[x86]] puede ejecutar la siguiente instrucción [[binario|binaria]] como se expresa en código de máquina:
* Binario: 10110000 01100001 (Hexadecimal: 0xb061)
La representación equivalente en lenguaje Assembly es más fácil de recordar:
* MOV al, 061h
Esta instrucción significa:
* Asigna el valor [[hexadecimal]] 61 (97 [[decimal]]) al registro "al".
El mnemónico "mov" es un ''código de operación'' u "[[opcode]]", elegido por los diseñadores de la colección de instrucciones para abreviar "move" (mover, pero en el sentido de copiar valores de un sitio a otro).
El ''opcode'' es seguido por una lista de argumentos o ''parámetros'', completando una instrucción de Assembly típica.
La transformación del lenguaje Assembly en código máquina la realiza un programa Ensamblador, y la traducción inversa la puede efectuar un desensamblador. A diferencia de los lenguajes de alto nivel, aquí hay usualmente una correspondencia 1 a 1 entre las instrucciones simples del Assembly y el lenguaje de máquina. Sin embargo, en algunos casos, un Assembly puede proveer "pseudo instrucciones" que se expanden en un código de máquina más extenso a fin de proveer la funcionalidad necesaria. Por ejemplo, para un código máquina condicional como "si X mayor o igual que" , un Assembly puede utilizar una pseudoinstrucción al grupo "haga si menor que" , y "si = 0" sobre el resultado de la condición anterior. Los Ensambladores más completos también proveen un rico lenguaje de macros que se utiliza para generar código más complejo y secuencias de datos.
El uso del Assembly no resuelve definitivamente el problema de cómo programar un sistema basado en microprocesador de modo sencillo ya que para hacer un uso eficiente del mismo, hay que conocer a fondo el [[microprocesador]], los registros de trabajo de que dispone, la estructura de la memoria, y muchas cosas más referentes a su estructura básica de funcionamiento.
Cada [[arquitectura de microprocesadores]] tiene su propio lenguaje de máquina, y en consecuencia su propio lenguaje Assembly ya que este se encuentra muy ligado al la estructura del hardware para el cual se programa. Los microprocesadores difieren en el tipo y número de operaciones que soportan; también pueden tener diferente cantidad de registros, y distinta representación de los tipos de datos en memoria. Aunque la mayoría de los microprocesadores son capaces de cumplir esencialmente las mismas funciones, la forma en que lo hacen difiere y los respectivos lenguajes Assembly reflejan tal diferencia.
Pueden existir múltiples conjuntos de mnemónicos o [[sintáxis]] de lenguaje Assembly para un mismo conjunto de instrucciones, instanciados típicamente en diferentes programas Assembly. En estos casos, la alternativa más popular es la provista por los fabricantes, y usada en los manuales del programa.
== Código máquina ==
El código máquina, o [[lenguaje de máquina]], está formado por instrucciones sencillas, que -dependiendo de la estructura del procesador- pueden especificar:
* Registros específicos para operaciones aritméticas, direccionamiento o control de funciones.
* Posiciones de memoria específicas (''offset'').
* Modos de direccionamiento usados para interpretar operandos.
Las operaciones más complejas se realizan combinando estas instrucciones sencillas, que pueden ser ejecutadas secuencialmente o mediante instrucciones de control de flujo.
Las operaciones disponibles en la mayoría de los conjuntos de instrucciones incluye:
* mover
** llenar un registro con un valor constante
** mover datos de una posición de memoria a un registro o viceversa
** escribir y leer datos de dispositivos
* computar
** sumar, restar, multiplicar o dividir los valores de dos registros, colocando el resultado en uno de ellos o en otro registro
** realizar operaciones binarias, incluyendo operaciones lógicas (AND/OR/XOR/NOT)
** comparar valores entre registros (mayor, menor, igual)
* afectar el flujo del programa
** saltar a otra posición en el programa y ejecutar instrucciones allí
** saltar si se cumplen ciertas condiciones (IF)
** saltar a otra posición, pero guardar el punto de salida para retornar (CALL, llamada a subrutinas)
Algunas computadoras incluyen instrucciones complejas dentro de sus capacidades. Una sola instrucción compleja hace lo mismo que en otras computadoras puede requerir una larga serie de instrucciones, por ejemplo:
* salvar varios registros en la pila de una sola vez
* mover grandes bloques de memoria
* operaciones aritméticas complejas o de punto flotante ([[seno]], [[coseno]], [[raíz cuadrada]])
Mientras que una computadora reconoce la [[instrucción de máquina]] IA-32
10110000 01100001
para los [[programador]]es de microprocesadores [[x86]] es mucho más fácil reconocer dicha instrucción empleando lenguaje Assembly :
movb 0x61,%al
(que significa mover el valor [[hexadecimal]] 61 (97 [[decimal]]) al [[registro]] 'al'.)
== Ejemplos de lenguaje Assembly ==
=== Ejemplo 1 ===
El siguiente es un ejemplo del programa clásico ''[[Hola mundo]]'' escrito para la arquitectura de procesador [[x86]] (bajo el sistema operativo [[DOS]]).
.model small
.stack
.data
Cadena1 DB 'Hola Mundo.$'
.code
programa:
mov ax, @data
mov ds, ax
mov dx, offset Cadena1
mov ah, 9
int 21h
end programa
=== Ejemplo 2 ===
Una selección de instrucciones para una computadora virtual<ref name=wwwPOCA>[http://iiusaedu.com/~murdocca/POCA Principles of Computer Architecture] (POCA) – ARCTools computadora virtual disponible para descarga y ejecución del código, acceso el 24 de agosto de 2005</ref>) con las correspondientes direcciones de memoria en las que se ubicarán las instrucciones. Estas direcciones NO son estáticas. Cada instrucción se acompaña del código en lenguaje Assembly generado (código objeto) que coincide con la arquitectura de computador virtual, o conjunto de instrucciones [[ISA]].
{| class="wikitable"
! Dir.
! Etiqueta
! Instrucción
! Código máquina<ref>Murdocca, Miles J. y Heuring, Vincent P.:''Principles of Computer Architecture'' (2000), Prentice Hall, ISBN 0-201-43664-7</ref>
|-
|
|
|<tt>.begin</tt>
|
|-
|
|
|<tt>.org 2048</tt>
|
|-
|
|<tt>a_start</tt>
|<tt>.equ 3000</tt>
|
|-
|<tt>2048</tt>
|
|<tt>ld length,%</tt>
|-
|<tt>2064</tt>
|
|<tt>be done</tt>
|<tt>00000010 10000000 00000000 00000110</tt>
|-
|<tt>2068</tt>
|
|<tt>addcc %r1,-4,%r1</tt>
|<tt>10000010 10000000 01111111 11111100</tt>
|-
|<tt>2072</tt>
|
|<tt>addcc %r1,%r2,%r4</tt>
|<tt>10001000 10000000 01000000 00000010</tt>
|-
|<tt>2076</tt>
|
|<tt>ld %r4,%r5</tt>
|<tt>11001010 00000001 00000000 00000000</tt>
|-
|<tt>2080</tt>
|
|<tt>ba loop</tt>
|<tt>00010000 10111111 11111111 11111011</tt>
|-
|<tt>2084</tt>
|
|<tt>addcc %r3,%r5,%r3</tt>
|<tt>10000110 10000000 11000000 00000101</tt>
|-
|<tt>2088</tt>
|<tt>done:</tt>
|<tt>jmpl %r15+4,%r0</tt>
|<tt>10000001 11000011 11100000 00000100</tt>
|-
|<tt>2092</tt>
|<tt>length:</tt>
|<tt>20</tt>
|<tt>00000000 00000000 00000000 00010100</tt>
|-
|<tt>2096</tt>
|<tt>address:</tt>
|<tt>a_start</tt>
|<tt>00000000 00000000 00001011 10111000</tt>
|-
|
|
|<tt>.org a_start</tt>
|
|-
|<tt>3000</tt>
|
|<tt>a:</tt
|
|}
=== Ejemplo 3 ===
Código en lenguaje Assembly para [[microcontrolador|µC]] [[Intel 8051|Intel 80C51]]
ORG 8030H
T05SEG:
SETB TR0
JNB uSEG,T05SEG ;esta subrutina es utilizada
CLR TR0 ;para realizar una cuenta de
CPL uSEG ;0,5 segundos mediante la
MOV R1,DPL ;interrupción del timer 0.
MOV R2,DPH
CJNE R2,#07H,T05SEG
CJNE R1,#78H,T05SEG
MOV DPTR,#0000H
RET
=== Ejemplo 4 ===
Código en lenguaje Assembly para [[microcontrolador|µC]] [[PIC16F84|16F84]] de [[Microchip (Empresa)|Microchip]]
ORG 0
Inicio
bsf STATUS,RP0
clrf PORTB
movlw 0xFF
movwf PORTA
bcf STATUS,RP0
Principal
movf PORTA,W
movwf Contador
movf Contador,F
btfsc STATUS,Z
goto PuntoDecimal
sublw d'9'
btfss STATUS,C
END
== Referencias ==
{{listaref}}
== Bibliografía ==
* Dominic Sweetman: '''See MIPS Run'''. Morgan Kaufmann Publishers. ISBN 1-55860-410-3
* Robert Britton: '''MIPS Assembly Language Programming'''. Prentice Hall. ISBN 0-13-142044-5
* John Waldron: '''Introduction to RISC Assembly Language Programming'''. Addison Wesley. ISBN 0-201-39828-1
== Véase también ==
{{wikibooks|Programación* en lenguaje[[Lenguaje ensamblador}} ]]
* [[Lenguaje de máquina]]
*[[Tipos de datos máquina]]
== Enlaces externos ==
* [http://cs.smith.edu/~thiebaut/ArtOfAssembly/artofasm.html The Art of Assembly Language Programming], [http://www.arl.wustl.edu/~lockwood/class/cs306/books/artofasm/toc.html] by [[Randall Hyde]]
* [http://www.computer-books.us/assembler.php Computer-Books.us], Online Assembly Language Brooks
* [http://www.drpaulcarter.com/pcasm/pcasm-book-spanish.zip PC Assembly Language(español)] by [[Dr Paul Carter]]; *[http://drpaulcarter.com/pcasm/ PC Assembly Tutorial using NASM and GCC] by Paul Carter
* [http://savannah.nongnu.org/projects/pgubook/ Programming from the Ground Up] by Jonathan Bartlett
* [http://www.asmcommunity.net/board/index.php?action=book The ASM Book] by the [http://www.asmcommunity.net ASM Community]
* [http://search.cpan.org/perldoc?Inline::ASM Inline::ASM] módulo [[Perl]] en [[CPAN]] para programar en lenguaje ensamblador dentro de programas Perl (en inglés)
[[Categoría:Lenguajes de programación]]
[[Categoría:Lenguajes de bajo nivel]]
==Enlaces externos==
[[Categoría:Lenguajes de programación]]
* http://masm32.com/
[[Categoría:Lenguajes de bajo nivel]]
* http://webster.cs.ucr.edu/
* http://godevtool.com/
* http://flatassembler.net/
* http://nasm.sourceforge.net/
* http://betov.free.fr/RosAsm.html
* http://luxasm.sourceforge.net/
* http://eji.com/a86/
* http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002
* [http://www.mis-algoritmos.com/asm.html Ejemplos en ensamblador para IBM PC y compatibles]
* [http://www.lawebdelprogramador.com/codigo/masvotados.php?id=29&texto=Ensamblador]
[[Categoría:Ensambladores| ]]
[[Categoría:Programas de código objeto]]
[[arda:??? ??????Assembler]]
[[de:Assembler (Informatik)]]
[[bg:????????]]
[[en:Assembly language#Assembler]]
[[bn:??????????? ????]]
[[bset:Assembler]]
[[fi:Assembler]]
[[ca:Llenguatge assemblador]]
[[fr:Programme assembleur]]
[[cs:Jazyk symbolických adres]]
[[dahe:Assemblersprogאסמבלר]]
[[dehsb:AssemblerspracheAssembler]]
[[hu:Assembler]]
[[el:Assembly (???ssa p????aµµat?sµ??)]]
[[enid:Assembly languageAssembler]]
[[eoit:Asembla lingvoAssembler]]
[[etko:Assemblerkeel어셈블러]]
[[filb:AssemblyAssembler (ohjelmointikieliInformatik)]]
[[frlt:AssembleurAsembleris]]
[[henl:??? ??Assembler]]
[[hipl:???????? ????Asembler]]
[[hrpt:Asemblerski jezikMontador]]
[[ru:Ассемблер]]
[[hu:Assembly]]
[[issk:SmalamálAsembler]]
[[itsv:AssemblyAssembler]]
[[tg:Забони ассемблер]]
[[ja:???????]]
[[kotr:?????Assembler]]
[[ltuk:Asemblerio kalbaАсемблер]]
[[lv:Asamblervaloda]]
[[no:Assembler]]
[[pt:Linguagem de montagem]]
[[ro:Limbaj de asamblare]]
[[ru:???? ??????????]]
[[sh:Asemblerski jezik]]
[[si:????????? ?????]]
[[simple:Assembly language]]
[[sl:Zbirni jezik]]
[[sq:Assembly]]
[[sr:????????]]
[[th:?????????????]]
[[tr:Çevirici diller]]
[[vi:H?p ng?]]
[[zh:????]]
| 