• Los compiladores generan código en lenguaje ensamblador, porque:
  
• Es más simple.
• Podemos utilizar el mismo ensamblador para varios compiladores.
• Dejamos los detalles de la codificación y acceso al hardware al ensamblador.

• Más razones:
• Separación de responsabilidades, el compilador se encarga de traducir hacia ensamblador, y el ensamblador de traducir a binario. 
• Podemos intercambiar un ensamblador por otro, sin ningún problema.
• Es más fácil generar texto, sin preocuparnos por el endianness (big-endian, little-endian, ...).

• Responsable de:
• Conversiones de MAL a TAL
• Calcular desfases para saltos condicionales.
• Dejar referencias de saltos y llamadas a funciones para el Linker.
• Codificar todo a binario.
• Leer y aplicar directivas.
• Generar object file (archivo de salida).

• Comandos para el ensamblador.
• No generan instrucciones para la máquina.
• .text
• .data
• .asciiz
• etc.

• El ensamblador debe traducir estas instrucciones a instrucciones reales.

• Reemplaza la pseudo-instrucción, por una o más instrucciones reales.

• Utiliza $at para almacenar posibles resultados intermedios.

• Para instrucciones simples (aritméticas, lógicas, etc.)
• Es el caso más fácil, la instrucción incluye todo lo necesario para codificarla (nombre de los registros, operandos, etc.)

• Utilizamos una estructura de datos, llamada Tabla de Símbolos.
• Parecido a un hash.
• La llave es un identificador numérico.
• El valor es la dirección a la que una etiqueta apunta.

• Cuando encontramos la declaración de una etiqueta:
• Asociamos esa etiqueta a un identificador en la tabla.
• Apuntamos la dirección de la etiqueta bajo ese identificador.

• Asumimos que comenzamos en 0:
  
• El área de texto comienza en 0.
• El área de data también comienza en 0.

• Optimización para arquitecturas con Pipelining.

• Consiste en siempre ejecutar la instrucción que sigue a un branch.

fact: addi $sp $sp -8
      sw $ra 4($sp)
      sw $s0 0($sp)
      mov $s0 $a0
      beqi $s0 1 else
      addi $a0 $a0 -1
      jal fact
      mul $v0 $v0 $s0
      j done
else: li $v0 1
done: lw $s0 0($sp)
      lw $ra 4($sp)
      addi $sp $sp 8
      jr $ra

• Necesitamos una segunda pasada para calcular los offsets de todos los saltos condicionales.

• Ahora codificamos el programa a binario.

• El resultado es un archivo objeto (.o), el cual contiene el binario, y la tabla de símbolos.

• La tabla es importante para el linker.
  

• El linker se encarga de juntar el programa y cualquier otro programa necesario, como librerías externas.

• No necesita modificar los saltos condicionales, porque
• Estos saltos se expresan de forma relativa.
• Estos offsets ya fueron calculados, y no se ven afectados por el cambio de la dirección inicial.

• Ahora el ensamblador agrega una rutina de inicio (normalmente en la dirección 0x00400000 para MIPS), la cual configura el programa y hace el salto a la función main.

• ¿El ensamblador sabe dónde están las instrucciones/datos de un programa respecto a otro?
• No, de eso se encarga el linker. El ensamblador sólo sabe de un programa a la vez.