Lenguaje de máquina - Muriel627/1ELE01 GitHub Wiki

imagen

Esta imagen ilustra el proceso de compilación y ejecución de un programa en lenguaje C, desglosado en varios pasos importantes:

  1. C Program: El proceso comienza con el código fuente escrito en lenguaje C.

  2. Compiler: El compilador traduce el código fuente en lenguaje C a un programa en lenguaje ensamblador.

  3. Assembly Language Program: Este es el código generado por el compilador en lenguaje ensamblador.

  4. Assembler: El ensamblador convierte el programa en lenguaje ensamblador en un módulo de lenguaje máquina, conocido como objeto.

  5. Object: Machine Language Module: Este es el código máquina generado por el ensamblador que corresponde al código fuente original en C.

  6. Object: Library Routine (Machine Language): Este es un módulo de biblioteca en lenguaje máquina que puede ser utilizado por el programa.

  7. Linker: El enlazador (linker) toma los módulos de lenguaje máquina generados por el ensamblador y los módulos de biblioteca, y los combina en un programa ejecutable.

  8. Executable: Machine Language Program: Este es el programa en lenguaje máquina combinado y listo para ser ejecutado.

  9. Loader: El cargador (loader) carga el programa ejecutable en la memoria del sistema.

  10. Memory: Finalmente, el programa en lenguaje máquina está cargado en la memoria y listo para ser ejecutado por el procesador.

Este proceso implica la traducción del código fuente a código máquina, la combinación de varios módulos de código y la carga del programa resultante en la memoria para su ejecución.

Otros códigos

imagen

imagen

imagen

imagen

imagen

Claro, aquí tienes una tabla que describe las instrucciones de MIPS según su categoría:

Categoría Instrucción Ejemplo Significado Comentarios
Aritmética add add $t0, $t1, $t2 Suma de $t1 y $t2, guarda en $t0 $t0 = $t1 + $t2
sub sub $t0, $t1, $t2 Resta de $t2 a $t1, guarda en $t0 $t0 = $t1 - $t2
addi addi $t0, $t1, 10 Suma de $t1 y 10, guarda en $t0 $t0 = $t1 + 10
mult mult $t1, $t2 Multiplica $t1 por $t2 Producto de $t1 y $t2 en registros hi/lo
div div $t1, $t2 Divide $t1 entre $t2 Cociente en lo, residuo en hi
Transferencia de Datos lw lw $t0, 4($t1) Carga palabra desde memoria a $t0 $t0 = Mem[$t1 + 4]
sw sw $t0, 4($t1) Guarda palabra desde $t0 a memoria Mem[$t1 + 4] = $t0
lb lb $t0, 4($t1) Carga byte desde memoria a $t0 $t0 = Mem[$t1 + 4] (byte)
sb sb $t0, 4($t1) Guarda byte desde $t0 a memoria Mem[$t1 + 4] = $t0 (byte)
Lógica and and $t0, $t1, $t2 AND bit a bit entre $t1 y $t2, guarda en $t0 $t0 = $t1 & $t2
or or $t0, $t1, $t2 OR bit a bit entre $t1 y $t2, guarda en $t0 $t0 = $t1 | $t2
xor xor $t0, $t1, $t2 XOR bit a bit entre $t1 y $t2, guarda en $t0 $t0 = $t1 ^ $t2
nor nor $t0, $t1, $t2 NOR bit a bit entre $t1 y $t2, guarda en $t0 $t0 = ~($t1 | $t2)
sll sll $t0, $t1, 2 Desplaza a la izquierda $t1 por 2 bits, guarda en $t0 $t0 = $t1 << 2
srl srl $t0, $t1, 2 Desplaza a la derecha $t1 por 2 bits, guarda en $t0 $t0 = $t1 >> 2
Branch Condicional beq beq $t0, $t1, label Salta a label si $t0 es igual a $t1 if ($t0 == $t1) goto label
bne bne $t0, $t1, label Salta a label si $t0 no es igual a $t1 if ($t0 != $t1) goto label
blez blez $t0, label Salta a label si $t0 es menor o igual a cero if ($t0 <= 0) goto label
bgtz bgtz $t0, label Salta a label si $t0 es mayor que cero if ($t0 > 0) goto label
Salto Incondicional j j label Salta a la dirección especificada por label goto label
jr jr $ra Salta a la dirección contenida en $ra goto $ra
jal jal label Salta a la dirección especificada por label y guarda la dirección de retorno en $ra $ra = PC + 4; goto label

Esta tabla proporciona una visión general de las instrucciones de MIPS y su uso en diferentes categorías. Cada categoría tiene ejemplos y comentarios que explican el propósito y el comportamiento de cada instrucción. Goto label es una manera simplificada de describir su comportamiento, indicando que el control se transfiere a la instrucción ubicada en la etiqueta label.

Tabla de registros en x86-64 bits

Claro, aquí tienes una tabla con los registros más comunes en la arquitectura x86-64, junto con sus definiciones y ejemplos de uso en lenguaje ensamblador.

Tabla de Registros en x86-64

Registro Descripción Ejemplo ASM Comentario
rax Registro acumulador principal mov rax, 10 Usado para operaciones aritméticas y de propósito general
rbx Registro de base mov rbx, rax Usado frecuentemente para apuntar a datos en memoria
rcx Registro contador mov rcx, 5 Usado en operaciones de conteo y bucles
rdx Registro de datos mov rdx, rax Usado en operaciones aritméticas y de entrada/salida
rsi Registro de fuente de cadena mov rsi, rdi Usado en operaciones con cadenas y copiado de datos
rdi Registro de destino de cadena mov rdi, rsi Usado en operaciones con cadenas y copiado de datos
rsp Puntero de pila mov rsp, rax Apunta a la cima de la pila
rbp Puntero de base de pila mov rbp, rsp Usado para apuntar al marco actual de la pila
r8 Registro de propósito general mov r8, rax Registro extendido en x86-64
r9 Registro de propósito general mov r9, rax Registro extendido en x86-64
r10 Registro de propósito general mov r10, rax Registro extendido en x86-64
r11 Registro de propósito general mov r11, rax Registro extendido en x86-64
r12 Registro de propósito general mov r12, rax Registro extendido en x86-64
r13 Registro de propósito general mov r13, rax Registro extendido en x86-64
r14 Registro de propósito general mov r14, rax Registro extendido en x86-64
r15 Registro de propósito general mov r15, rax Registro extendido en x86-64
rip Puntero de instrucción call func Apunta a la siguiente instrucción a ejecutar
eflags Registro de indicadores pushfq Contiene indicadores del estado del CPU
cs Segmento de código mov cs, ax Selector del segmento de código
ds Segmento de datos mov ds, ax Selector del segmento de datos
ss Segmento de pila mov ss, ax Selector del segmento de pila
es Segmento adicional de datos mov es, ax Selector de segmento adicional de datos
fs Segmento adicional de datos mov fs, ax Selector de segmento adicional de datos
gs Segmento adicional de datos mov gs, ax Selector de segmento adicional de datos
cr0 Registro de control mov cr0, rax Controla varias operaciones del CPU
cr2 Registro de control mov cr2, rax Contiene la dirección de la última falla de página
cr3 Registro de control mov cr3, rax Contiene la dirección base de la tabla de páginas
cr4 Registro de control mov cr4, rax Controla varias extensiones del CPU

Descripciones y Ejemplos:

  • Registros de propósito general (rax, rbx, rcx, rdx):

    • Usados para almacenamiento temporal de datos y para operaciones aritméticas y lógicas.
    • Ejemplo: mov rax, 10 almacena el valor 10 en el registro rax.
  • Registros de cadena (rsi, rdi):

    • Usados para operaciones con cadenas, donde rsi es el registro de fuente y rdi es el registro de destino.
    • Ejemplo: mov rsi, rdi copia el valor de rdi a rsi.
  • Registros de pila (rsp, rbp):

    • rsp (Stack Pointer) apunta a la cima de la pila, y rbp (Base Pointer) apunta al marco actual de la pila.
    • Ejemplo: mov rsp, rax copia el valor de rax al puntero de la pila rsp.
  • Registros extendidos (r8-r15):

    • Registros adicionales introducidos en la arquitectura x86-64 para almacenamiento y operaciones de propósito general.
    • Ejemplo: mov r8, rax copia el valor de rax al registro r8.
  • Puntero de instrucción (rip):

    • Apunta a la siguiente instrucción a ejecutar.
    • Ejemplo: call func guarda la dirección de retorno en la pila y salta a la dirección de func.
  • Registro de indicadores (eflags):

    • Contiene indicadores que representan el estado del CPU.
    • Ejemplo: pushfq guarda el valor actual del registro de indicadores en la pila.

Estos son algunos de los registros y su uso común en la programación en ensamblador para la arquitectura x86-64. Cada uno tiene un propósito específico que permite al procesador manejar operaciones complejas de manera eficiente.