Lenguaje ensamblador para niños

Datos para niños Lenguaje ensamblador
Motorola MC6800 Assembler listing
?
Información general
Extensiones comunes	.asm
Paradigma	Imperative, unstructured
Apareció en	1949

Lenguaje de máquina del Intel 8088. El código de máquina en hexadecimal se resalta en rojo, el equivalente en lenguaje ensamblador en magenta, y las direcciones de memoria donde se encuentra el código, en azul. Abajo se ve un texto en hexadecimal y ASCII.

El lenguaje ensamblador (también conocido como assembler) es un tipo de lenguaje de programación que se usa para dar instrucciones directamente a los microprocesadores de una computadora. Es como el idioma más cercano que los humanos podemos entender para hablar con el cerebro de la computadora.

Cada tipo de procesador tiene su propio lenguaje ensamblador. Esto significa que un programa escrito en ensamblador para un procesador no funcionará en otro diferente sin ser modificado. Es como si cada marca de computadora tuviera su propio dialecto.

Para que la computadora entienda el lenguaje ensamblador, se usa un programa especial llamado ensamblador. Este programa traduce las instrucciones del ensamblador a un lenguaje de máquina, que son solo números binarios (ceros y unos) que la computadora puede ejecutar.

Este lenguaje fue muy importante al principio de la informática. Hoy en día, se usa en situaciones muy específicas. Por ejemplo, para controlar directamente el hardware (como los componentes físicos de la computadora) o cuando se necesita que un programa sea extremadamente rápido y use muy pocos recursos.

¿Qué es el Lenguaje Ensamblador?

El lenguaje ensamblador es un lenguaje de programación de "bajo nivel". Esto significa que está muy cerca de cómo funciona la computadora por dentro. A diferencia de los lenguajes de "alto nivel" (como Python o Java), que son más fáciles de leer para los humanos, el ensamblador usa símbolos y abreviaturas que representan las instrucciones básicas del procesador.

¿Por qué se usa el Lenguaje Ensamblador?

Aunque es más difícil de aprender, el lenguaje ensamblador tiene algunas ventajas:

• Control total: Permite controlar cada parte del procesador.
• Velocidad: Los programas pueden ser muy rápidos porque se comunican directamente con el hardware.
• Tamaño pequeño: Los programas ocupan menos espacio en la memoria.

Sin embargo, también tiene desventajas:

• Dificultad: Es complicado de escribir y entender.
• No es portable: Un programa hecho para un tipo de procesador no funciona en otro.

El Programa Ensamblador

Un programa ensamblador (o assembler) es una herramienta que convierte el código que escribimos en lenguaje ensamblador a código máquina. El código máquina es lo que la computadora realmente entiende y ejecuta.

Cuando escribes un programa en ensamblador, usas nombres simbólicos (como "MOV" para "mover" o "ADD" para "sumar") en lugar de números binarios. El ensamblador se encarga de traducir esos nombres a los números correctos.

¿Cómo funciona un Ensamblador?

La mayoría de los ensambladores modernos trabajan en dos pasos:

• Primer paso: Leen todo el código para encontrar y guardar los nombres simbólicos y sus ubicaciones.
• Segundo paso: Usan esa información para traducir las instrucciones a código máquina.

Esto permite que los programadores usen nombres en cualquier parte del código, haciendo que sea más fácil de leer y mantener.

Ensambladores Avanzados

Algunos ensambladores más avanzados ofrecen características que facilitan la programación. Por ejemplo, pueden incluir "macros". Una macro es una pequeña pieza de código que representa una secuencia de instrucciones más larga. Al usar una macro, el programador escribe menos, pero el ensamblador genera muchas instrucciones. Esto hace que el código ensamblador parezca más corto y organizado.

El Lenguaje en Sí

El lenguaje ensamblador refleja directamente cómo está construido un microprocesador y las instrucciones que puede ejecutar. Por eso, cada tipo de procesador tiene su propio lenguaje ensamblador.

Instrucciones del Procesador

Los procesadores tienen diferentes tipos de instrucciones que pueden realizar. Estas se agrupan por su función:

• Operaciones con números enteros: Son cálculos básicos como sumar, restar, multiplicar, dividir. También incluyen operaciones lógicas (como AND, OR) y de bits (mover o rotar bits).
• Operaciones para mover datos: Sirven para copiar información de un lugar a otro dentro de la computadora. Por ejemplo, de un registro (un espacio de almacenamiento temporal en el procesador) a la memoria, o viceversa.
• Operaciones de pila (stack): La pila es un lugar especial en la memoria donde se guardan y recuperan datos de forma ordenada (como una pila de platos). Las instrucciones "PUSH" guardan datos y "POP" los leen.
• Operaciones de entrada/salida: Permiten que el procesador se comunique con dispositivos externos, como el teclado, la pantalla o una impresora.
• Operaciones para el control del programa: Deciden el orden en que se ejecutan las instrucciones. Por ejemplo, pueden hacer que el programa salte a otra parte del código o que repita una sección.
• Operaciones con números reales: Algunas CPU tienen instrucciones especiales para trabajar con números con decimales (números de punto flotante), como los que se usan en cálculos científicos o gráficos 3D.

El lenguaje ensamblador usa abreviaturas (mnemónicos) para cada una de estas instrucciones.

Traducción (Ensamblado)

El programa ensamblador es el que convierte el lenguaje ensamblador en código máquina. Generalmente, una instrucción en ensamblador se convierte en una sola instrucción de código máquina.

Es importante saber que, incluso para el mismo tipo de procesador, diferentes programas ensambladores pueden usar abreviaturas o formas de escribir las instrucciones ligeramente distintas. Por ejemplo, para mover el valor 5 al registro AL, un ensamblador podría usar `MOV AL, 5` y otro `MOV 5, AL`. Ambos hacen lo mismo, pero se escriben diferente.

Ejemplos de Lenguaje Ensamblador

Un programa en lenguaje ensamblador es una lista de instrucciones que el procesador ejecutará.

Por ejemplo, en un procesador x86: La instrucción `MOV AL, 61h` significa "Mueve el valor hexadecimal 61 (que es 97 en decimal) al registro AL".

El programa ensamblador traduce esto a código binario, que es lo que la computadora entiende: `10110000 01100001`.

• `1011` es el código para la instrucción "MOV" (mover).
• `0000` indica el registro "AL".
• `01100001` es el número 61h en binario.

Así, el procesador puede ejecutar directamente `10110000 01100001`.

Ejemplo para la arquitectura x86

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              ; modelo de memoria

        .stack                    ; segmento del stack

        .data                     ; segmento de datos
        Cadena1 DB 'Hola Mundo. ; string a imprimir (finalizado en $)

        .code                     ; segmento del código

        programa:
                ; ----------------------------------------------------------------------------------------------------
                ; inicia el segmento de datos
                ; ----------------------------------------------------------------------------------------------------
                MOV AX, @data          ; carga en AX la dirección del segmento de datos
                MOV DS, AX             ; mueve la dirección al registro de segmento por medio de AX
                
                ; ----------------------------------------------------------------------------------------------------
                ; Imprime un string en pantalla
                ; ----------------------------------------------------------------------------------------------------
                MOV DX, offset Cadena1 ; mueve a DX la dirección del string a imprimir
                MOV AH, 9              ; AH = código para indicar al MS DOS que imprima en la pantalla, el string en DS:DX
                INT 21h                ; llamada al MS DOS para ejecutar la función (en este caso especificada en AH)
                
                ; ----------------------------------------------------------------------------------------------------
                ; Finaliza el programa
                ; ----------------------------------------------------------------------------------------------------
                INT 20h                ; llamada al MS DOS para finalizar el programa

        end programa

Ejemplo para el computador virtual (POCA)

Una selección de instrucciones para una computadora virtual) 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 ensamblador generado (código objeto) que coincide con la arquitectura de computador virtual, o conjunto de instrucciones ISA.

Ejemplo para el computador virtual (ARC)

ARC es un subconjunto del modelo de arquitectura basado en el procesador SPARC. ARC ( A RISC Computer) contiene la mayoría de las características

importantes de la arquitectura SPARC.

Ejemplo para el µC Intel 8051

Código en lenguaje ensamblador para µC Intel 80C51:

 
 ORG    8030H
 include
 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.
        INVOKE
        MOV R2,DPH
        CJNE R2,#07H,T05SEG
        CJNE R1,#78H,T05SEG
        MOV DPTR,#0
 RET

Ejemplo para el Microchip PIC16F84

Código en lenguaje ensamblador para el microcontrolador 16F84 de Microchip:

 ORG    0
 Inicio
        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

Uso del Lenguaje Ensamblador Hoy en Día

Aunque los lenguajes de alto nivel son los más usados para crear programas, el lenguaje ensamblador sigue siendo importante en algunos campos.

¿Cuándo se usa actualmente?

Los profesionales eligen el lenguaje ensamblador en situaciones específicas:

• Controladores de dispositivos: Para que el sistema operativo se comunique con el hardware (como una impresora o una tarjeta de video).
• Sistemas pequeños: En dispositivos con poca memoria o procesadores limitados, como teléfonos básicos o sistemas de control en coches.
• Optimización extrema: Cuando un programa necesita ser lo más rápido posible, por ejemplo, en videojuegos o simulaciones científicas.
• Sistemas en tiempo real: Donde la respuesta debe ser inmediata y precisa, como en sistemas de navegación de aviones o equipos médicos.
• Seguridad: Para tener un control total sobre el funcionamiento del sistema.
• Ingeniería inversa: Para entender cómo funciona un programa cuando solo se tiene su código máquina.
• Desarrollo de compiladores: Los creadores de compiladores a menudo necesitan entender y trabajar con ensamblador.

Importancia en la Educación

El lenguaje ensamblador se sigue enseñando en las carreras de ciencias de la computación e ingeniería electrónica. Aprenderlo ayuda a entender cómo funciona una computadora a un nivel muy básico. Esto incluye cómo se guardan los datos, cómo se procesan las instrucciones y cómo se comunica el software con el hardware.

|

Véase también

En inglés: Assembly language Facts for Kids

• Lenguaje ensamblador x86
  • Anexo:Listados de instrucciones x86
• Ensamblador
• Macro ensamblador
• Ensamblador de alto nivel
• Desensamblador
• Compilador
• Decompilador
• Intérprete (informática)
• Depurador
• Lenguaje de alto nivel
• Lenguaje de bajo nivel
• Lenguaje de máquina
• Conjunto de instrucciones
• Tipos de datos máquina
• Little man computer

Ensambladores

• Comparación de ensambladores
• High Level Assembly
• Netwide Assembler
• Flat assembler
• GNU Assembler
• Microsoft Macro Assembler
• RosASM
• A86 y A386 assemblers
• Turbo Assembler
• GNU toolchain

Desensambladores

• Interactive Disassembler

Depuradores

• SoftICE
• GNU Debugger
• OllyDbg
• Valgrind
• RosASM
• A86 y A386 assemblers
• Data Display Debugger

Otros

Sistemas operativos escritos completamente en assembler:

• MenuetOS
• KolibriOS
• BareMetal OS