Ir al contenido

Lenguaje ensamblador

De Wikipedia, la enciclopedia libre
Esta es una versión antigua de esta página, editada a las 18:18 9 oct 2007 por 213.96.126.183 (discusión). La dirección URL es un enlace permanente a esta versión, que puede ser diferente de la versión actual.
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.

El lenguaje Assembly es un tipo de lenguaje de bajo nivel utilizado para escribir programas informáticos, y constituye la representación más directa del código máquina específico para cada arquitectura de computadoras legible por un programador.

Fue usado ampliamente en el pasado para el desarrollo de software, pero actualmente sólo se utiliza en contadas ocasiones, especialmente cuando se requiere la manipulación directa del hardware o se pretenden rendimientos inusuales de los equipos.

Ensambladores

Un ensamblador crea código objeto traduciendo instrucciones mnemónicas a códigos operativos, e interpretando los nombres simbólicos para direcciones de memoria y otras entidades. El uso de referencias simbólicas es una característica básica de los ensambladores, 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 macros , a fin de generar series de instrucciones cortas que se ejecutan en tiempo real, en lugar de utilizar subrutinas[1]​.

Los ensambladores son por lo general más fáciles de programar que los compiladores de lenguajes de alto nivel, y han estado disponibles desde la década de 1950. Los ensambladores 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[2]​ del CPU.

Los ensambladores de alto nivel 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 una computadora. Por ejemplo, un procesador x86 puede ejecutar la siguiente instrucción binaria como se expresa en código maquina:

  • Binario: 10110000 01100001 (Hexadecimal: 0xb061)

La representación equivalente en Assembly es más fácil de recordar:

  • mov al, 061h

Esta instrucción significa:

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).- El opcode es seguido por una lista de argumentos o parámetros, completando una instrucción de ensamblador 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 ensamblador y el lenguaje máquina. Sin embargo, en algunos casos, un ensamblador 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 ensamblador 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.

Cada arquitectura de computadoras tiene su propio lenguaje de máquina, y en consecuencia su propio lenguaje Assembly. Los ordenadores 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 las computadoras 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 Assembly para un mismo conjunto de instrucciones, instanciados típicamente en diferentes programas ensamblador. 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 (o lenguaje de máquina)

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

El nivel de lenguaje Assembly tiene aspectos importantes de los niveles de microarquitectura, en los cuales se encuentra (ISA y sistema operativo) estos dos se utilizan para la traducción en lugar de la interpretación. Algunas características del lenguaje se describen a continuación Los programas que sirven para traducir algún programa para el usuario se llama traductores, el lenguaje en que esta escrito el programa original se llama lenguaje fuente, el lenguaje original que sea modificado se llama lenguaje objeto.

Se usa la traducción cuando se cuenta con un procesador (ya sea hardware o un interprete) para el lenguaje objeto pero no para el lenguaje fuente, Si la traducción se realiza correctamente, la ejecución del programa traducido dará exactamente los mismos resultados que habría dado la ejecución del programa fuente. Hay dos diferencias entre traducción e interpretación, en la traducción no se ejecuta directamente el programa original, en el lenguaje fuente se convierte en un programa equivalente llamado programa objeto o programa binario ejecutable y este funciona solo cuando se ha acabado la traducción.

El código máquina, un simple patrón de bits, es hecho legible reemplazando valores crudos por símbolos denominados mnemónicos. Se inventó para facilitar la tarea de los primeros programadores que hasta ese momento tenían que escribir directamente en código binario. antes aún era peor, ya que el código de ceros y unos (el programa) debía introducirse en una tarjeta perforada. La posición ocupada por cada punto equivalía a un "1" o a un "0" según hubiera un hueco o no. Lo cual suponía una forma casi idéntica en la que hoy se escriben los datos binaros en soportes tales como los CDs y DVDs.

Mientras que una computadora reconoce la instrucción de máquina IA-32 

 10110000 01100001

para los programadores de microprocesadores x86 es mucho más fácil reconocer dicha instrucción empleando lenguaje Assembly: 

 mov  %al, 0x61

(que significa mover el valor hexadecimal 61 (97 decimal) al registro 'al'.)

Cada instrucción de la máquina se transforma en una única instrucción en código simbólico.

Pero además, para mejorar la legibilidad del programa, el código simbólico introduce instrucciones adicionales, que no corresponden a ninguna instrucción de la máquina y que proporcionan información. Se llaman "pseudoinstrucciones".

El código simbólico puede parecer de difícil acceso, pero es más fácil de recordar e interpretar que el binario o el hexadecimal.

Los lenguajes simbólicos no resuelven definitivamente el problema de cómo programar un ordenador de la manera más sencilla posible. Para utilizarlos, hay que conocer a fondo el microprocesador, los registros de trabajo de que dispone, la estructura de la memoria, y muchas cosas más.

Además, el lenguaje Assembly está demasiado ligado al microprocesador para que sea posible escribir programas independientes de la máquina en que van a ejecutarse.

Este código simbólico no puede ser ejecutado directamente por un ordenador, por lo que es preciso traducirlo previamente. Pero la traducción es un proceso mecánico y repetitivo, que se presta a su realización por un programa de ordenador.

Los programas que traducen código simbólico al lenguaje de máquina se llaman ensambladores ("assembler", en inglés), porque son capaces de ensamblar el programa traducido a partir de varias piezas, procedimientos o subrutinas a código binario ("1" y "0") que entiende el procesador.

Ejemplos de lenguaje Assembly

=== Ejemplo 1 === bea esto esun coñazo

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[3]​) 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 ensamblador generado (código objeto) que coincide con la arquitectura de computador virtual, o conjunto de instrucciones ISA.

Dir. Etiqueta Instrucción Código objeto [4]​
.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


Ejemplo 3

Assembly para μC 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

Assembly para μC 16F84 de 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

  1. ↑ David Salomon, Assemblers and Loaders. 1993 [1]
  2. ↑ Pipeline en inglés.
  3. ↑ Principles of Computer Architecture (POCA) – ARCTools computadora virtual disponible para descarga y ejecución del código, acceso el 24 de agosto de 2005
  4. ↑ Murdocca, Miles J. y Heuring, Vincent P.:Principles of Computer Architecture (2000), Prentice Hall, ISBN 0-201-43664-7

Bibliografía

Véase también

Enlaces externos

Obtenido de «https://es.wikipedia.org/eswiki/w/index.php?title=Lenguaje_ensamblador&oldid=11938938»