Tema 3: El nivel de lenguaje máquina - Blearning

Tema 3: El nivel de lenguaje máquina 

• Introducción 

• Modos de direccionamiento 

• Tipos de instrucciones 

• Tipos y tamaños de los operandos 

• Formatos de las instrucciones 

• Procedimientos 

• Clasificación de las arquitecturas a nivel de lenguaje máquina 

• Caso de estudio: 

– Arquitectura del repertorio de instrucciones del procesador MIPS. 

Bibliografía básica: 

[Patt-95], [Henn-93] 

Fundamento de Computadores (1º II) Cap 2: El nivel de lenguaje máquina 1 de 64

Introducción 

• Nivel de lenguaje máquina o nivel ISA: 

– Interfaz crítico entre el software y el hardware. Nivel más bajo al que se 

puede programar un computador. 

Software 

Hardware 

Arquitectura del repertorio de instrucciones (o nivel ISA) 

• Instrucción: Orden primitiva que debe ejecutar el hardware. 

• Objetivo común de los diseñadores de computadores: 

– Encontrar un lenguaje que haga fácil la construcción del hardware y del 

compilador. 

– Maximizar el rendimiento y minimizar el coste o precio. 


Características del lenguaje máquina 

• Instrucción: Orden individual que ejecuta el hardware. 

– Información contenida en una instrucción: 

• Operación a realizar 

• Destino del resultado de la operación 

• Especificación de los operandos 

• Siguiente instrucción a realizar (implícitamente la siguiente o la que se 

especifique en instrucciones de ruptura de secuencia). 

• Las características del lenguaje máquina o nivel ISA de un 

computador vienen determinadas por: 

– El repertorio de instrucciones 

– Los modos de direccionamiento (formas de localizar los operandos) 

– La representación y tipos de datos que puede manejar 

– Formato de las instrucciones (modo en el que se codifican) 


Sintaxis típica de una instrucción en lenguaje 

ensamblador 

• Ejemplo: Lenguaje ensamblador del procesador MIPS R2000/3000 

– 4 campos básicos: etiqueta, nemónico de la instrucción, operandos (fuentes 

y destino) y comentarios (opcional). 

Operandos 

Etiqueta Instrucción Comentarios 

Destino Fuentes 

demo: add $t1, $s1, $v0 # $t1= $s1 + $v0 

sumai: addi $t5, $s2, 5 # $t5= $s2 + 5 

carga: lw $s3, 100($zero) 

# $s3= M[100+$zero] 

# $zero = 0 siempre! 


Modos de direccionamiento 

• ¿Qué se entiende por modo de direccionamiento? 

– Las diversas formas que tiene una arquitectura (procesador) de especificar 

la localización de los operandos (datos) a procesar. 

• ¿Dónde pueden estar los operandos de una instrucción? 

– Particularizando para una máquina de registros de propósito general los 

operandos pueden estar en: 

• En un registro del procesador: add r3,r1,r2 

• En la propia instrucción (forma inmediata): addi r2,r1,4 

• En memoria: add r2,r1,M 

– Dirección efectiva (EA: Effective address): Dirección real de memoria 

especificada por un modo de direccionamiento. 


Modos de direccionamiento: 

Ubicación de los operandos 

• En Registros , en la propia instrucción (inmediato) o en Memoria 

Procesador 

Control 

Registros 

 

ALU 

Memoria 

Dirección Contenido 

... 

[0x00001144] addi $t0, $t1, 9 

[0x00001148] lw $s0,1000($zero) 

... 

... 

[0x00001000] 0x00001998 

... 

... 

... 

... 



Interpretación de las direcciones de memoria 

• Convenios para clasificar los bytes de una palabra: 

– Little Endian: La dirección de un dato es la dirección de la parte menos significativa 

del dato. 

– Big Endian: La dirección de un dato es la dirección de la parte más significativa del 

dato. 

– Aspecto importante cuando se intercambia información entre distintas 

máquinas. 

Little Endian 

MSB LSB 

0x44332211 

55 

Memoria 

0 

. 

0x11 

0x22 

0x33 

0x44 

. 

2 n -1 

Big Endian 

MSB LSB 

0x11223344 



Alineación de los datos en memoria 

• Algunas arquitecturas exigen que los objetos mayores de un byte 

estén alineados en memoria. 

• Definición: 

– Un acceso a un objeto de tamaño t bytes en el byte de dirección D se alinea 

si D mod t = 0 (mod: resto de la división D/t). 

– Es decir, la dirección del objeto debe ser múltiplo de su tamaño en bytes. 

Objeto Bien alineado Mal alineado 

Byte 0,1,2,3,4,5,6,.. (nunca) 

Media palabra 0,2,4,6,8, ... 1,3,5,7, ... 

Palabra (4 bytes) 0,4,8,... 1,2,3,5,6,7,9,10,11,... 

Doble palabra 0,8, .. 1,2,3,4,5,6,7,9,10,11,12,13,14,15,.... 


Red de alineación 

Ejemplo 

Memoria: 

Registro: 

bit31 

bit31 

byte 3 byte 2 byte 1 byte 0 

bus 

Procesador 

. 

Red de alineación 

byte 3 byte 2 byte 1 byte 0 

Memoria 

Dirección Contenido 

0 Byte 0 

1 Byte 1 

2 Byte 2 

3 Byte 3 

4 Byte 4 

... .... 

Fundamento de Computadores (1º II) Cap 2: El nivel de lenguaje máquina 9 de 64 

bit0 

bit0 

bit0 

bit31


Tipos más frecuentes 

Modo Ejemplo Significado 

Registro add r4,r3 r4 = r3+r4 

Inmediato add r4,#5 r4 = r4+5 

Directo add r1, (100) r1 = r1+M[100] 

Base + desplazamiento add r4,28(r1) r4 = r4 + M[28+r1] 

Indirecto por registro add r2, (r5) r2= r2 + M[r5] 

Indirecto por memoria add r1, @(r3) r1= r1 + M[M[r3]] 

Indexado add r3, (r1+r2) r3= r3+M[r1+r2] 

Autoincremento add r1,(r3)+ r1= r1 + M[r3] 

r3=r3+d 

(d:tamaño del elemento) 

Autodecremento add r1, -(r3) r3=r3-d 

r1= r1 + M[r3] 

(d:tamaño del elemento) 

Escalado o índice add r1, 50(r2)[r3] r1= r1+M[50+r2+r3xd] 

(d: tamaño del elemento) 

Ruptura de secuencia Saltos directos, relativos al PC, llamadas a 

subrutinas, etc.. 


Breve descripción de la arquitectura MIPS 

Características generales 

• Máquina de carga-almacenamiento. 

– Los operandos de las operaciones que realiza la ALU tienen que estar en 

registros. No pueden estar en memoria. Los datos se tienen que mover a los 

registros (instrucciones de carga/almacenamiento) para procesarlos. 

• Repertorio reducido tanto de instrucciones como de tipos de 

datos. 

• Todas las instrucciones son de la misma longitud. 

• Número pequeño de modos de direccionamiento. 

– 3 para acceso a operandos 

– 2 para ruptura de secuencia (saltos y bifurcaciones) 

• Número reducido de formatos de instrucciones. 


Breve descripción de la arquitectura MIPS 

Registros 

• 32 registros de 32 bits: $0 - $31. 

– $1 - $31: Registros de propósito general. 

– $0: Registro cuyo contenido siempre es 0. 

• Contador de Programa: PC 

• 32 registros de punto flotante. 

– 16 doble precisión (64 bits): F0-F2-....-F30 

– 16 simple precisión (32 bits): F0-F2- ...- F30 (direcciones pares) 

• Registros HI y LO para resultados aritméticos de 64 bits. 

– HI,LO: 64 bits. Producto aritmética entera (multiplicación) 

– LO: Cociente y HI: Resto para la división 


Modos de direccionamiento del procesador MIPS 

• Sólo 5 modos de direccionamiento: 

– Registro 

• add $t0,$s0,$s1 # $t0= $s0 + $s1 

– Inmediato 

• addi $t0,$t1,3 # $t0= $t1 +3 

– Base + desplazamiento 

• lw $t6, 100($s0) # Carga: t6 = M[100+$s0] 

• sw $t6, 100($s0) # Almacenamiento: M[100+$s0] = t6 

– Relativo al contador de programa 

• beq $t0,$t1,loop # Salto: si ($t0 = $t1) ir a loop 

– Pseudodirecto 

• j 1000 # Bifurcación a la posición 1000 (dentro del 

# segmento actual de 256 Mb) 


Codificación de los modos de direccionamiento 

• La codificación de los modos de direccionamiento de los operandos 

depende de: 

– Número de modos de direccionamiento 

– Grado de independencia entre modos y códigos de operación 

• Alternativas para la codificación según el número de modos de 

direccionamiento que tenga una arquitectura: 

– Bajo: Codificación en el propio código de operación de la instrucción. 

In 

Código de operación ........... ............ .......... .......... 

– Alto: Utilización de especificadores de direcciones que indican el modo de 

direccionamiento que utiliza cada operando. 

In 

Cód. Oper. Especificador ............ .......... .......... 


Modos de direccionamiento y registros: 

Impacto en el tamaño de las instrucciones 

• El número de modos de direccionamiento y el número de registros de 

una arquitectura influyen directamente en el tamaño de las 

instrucciones. 

– Cuanto mayor es el número de registros y modos de direccionamiento más 

bits se necesitarán para la codificación de los mismos. Por ejemplo: 32 

registros necesitarán como mínimo 5 bits para su codificación en la 

instrucción: 00000 (R0) ………. 11111 (R31). 

• Fuerzas que debe equilibrar el arquitecto de computadores: 

– El deseo de tener muchos registros y modos de direccionamiento 

– El impacto en el tamaño de las instrucciones -> tamaño de los programas 

– El deseo de tener instrucciones codificadas en longitudes fáciles de manejar 

o decodificar por una implementación determinada (hardware que ejecuta el 

repertorio de instrucciones). 


Tipos de instrucciones 

• Las operaciones soportadas por la mayoría de las arquitecturas pueden 

clasificarse según la siguiente tabla: 

Tipo de instrucción Ejemplos Comentarios 

Aritmética y lógica Operaciones aritméticas y lógicas: suma, 

resta, and, or, ... 

Transferencia de datos Transferencia de datos entre memoria y 

registros: Carga/almacenamiento. 

Control Salto, bifurcación, llamadas a subrutinas, 

retorno de subrutinas, excepciones, 

Sistema Llamadas al Sistema operativo, gestión 

de la memoria virtual. 

Categorías presente en todas las 

máquinas con un repertorio completo de 


Varían entre las distintas arquitecturas 

pero todas proporcionan algún soporte de 

instrucciones para funciones del sistema. 

Punto Flotante operaciones en punto flotante: +, -, * y / . En máquinas destinadas a realizar 

muchas operaciones en punto flotante 

Decimal Suma y multiplicación decimal, 

conversiones de decimal a caracteres. 

Cadenas Comparar, mover, copiar o buscar en 

strings o cadenas de caracteres. 

En algunas arquitecturas (VAX, 80x86) 

forman parte del repertorio de 

instrucciones y en otras las sintetiza el 

compilador a partir de instrucciones mas 

sencillas. 


Instrucciones para el control de flujo 

• Nomenclaturas más aceptadas 

– Saltos: 

• Rupturas de secuencias CONDICIONALES 

– Bifurcaciones: 

• Rupturas de secuencia NO CONDICIONALES. 

• Tipos de cambios de flujo 

– Saltos condicionales 

– Bifurcaciones 

– Llamadas a procedimientos 

– Retornos de procedimiento 


Saltos condicionales 

• Normalmente, los saltos son relativos al PC 

– La dirección de destino se da como un desplazamiento que se suma o resta 

al Contador de Programa (PC). 

• Código independiente de la posición 

– Puede ejecutarse independientemente de su posición en memoria. 

• Un salto se realiza si la condición probada es verdadera 

• la condición que se prueba puede ser: 

– Un bit especial de estado que se activa en función del resultado de la ALU. 

» add r1,r2,r3 

» bz label # si (bit de estado “zero” está activo) ir a label 

– Registro arbitrario que toma el valor del resultado de una comparación. 

» sub r1,r2,r3 

» beqz r1,label # si (r1==0) ir a label 

– En la propia instrucción de salto se realiza la comparación. 

» beq $1,$2,label # si ($1==$2) ir a label 

• Los saltos suelen ser cortos -> pocos bits para especificar la 

dirección. 


Bifurcaciones 

• La dirección de la siguiente instrucción a ejecutar es la especificada por 

el campo de operandos de la instrucción de bifurcación. 

– Ejemplo: J 2000 # ir a la dirección 2000 de memoria 

• La dirección de salto puede especificarse de las siguientes formas: 

– Directa 

• El campo de operandos de la instrucción especifica directamente la 

siguiente instrucción que se ha de ejecutar. 

– J 1000 

– Indirecta 

• Saltos indirectos por registros 

– jr $5 

• Retornos de procedimientos o subrutinas 

– RET # I8086: La dirección de retorno la recupera del “stack”. 


Procedimientos (o subrutinas) 

• Concepto de procedimiento o subrutina 

– Puede considerarse como una herramienta del programador para 

estructurar los programas y permitir que un programa desarrollado pueda 

ser reutilizado. 

– Librerías de subrutinas 

• Llamada y retorno de procedimientos: Funcionamiento simplificado 

Programa principal 

D1: instrucción 1 


D3: Llamada a “pru “ pru” 


. 

. 

Dn: instrucción n 

Guarda 

dirección 

D4 

Registro 

o 

Stack 

Procedimiento Pru 

Instrucción 1 

instrucción 2 

instrucción 3 

inst. inst. 

retorno 

Recupera 

D4 


Instrucciones de llamada y retorno de 

procedimientos 

• Incluyen la transferencia del control y guardar algún estado. 

– Como mínimo, debe guardarse la dirección de retorno en algún lugar que 

normalmente es: Un registro del procesador o la pila (stack). 

• Algunas arquitecturas proporcionan mecanismos para guardar los 

registros. En otras, es el propio compilador quien genera las 

instrucciones para guardar los registros. 

• Convenios básicos para guardar los registros: 

– Guarda llamador (caller-saving) 

• Antes de llamar al procedimiento, se guardan los registros cuyo 

contenido se quiere preservar después de la llamada. 

– Guarda el llamado (called-saving) 

• El procedimiento llamado guarda los registros que quiera a utilizar. 


Frecuencia de uso de las instrucciones 

Ejemplo: Top 10 80x86 Instructions 

Rank instruction Integer Average Percent total executed 

1 load 22% 

2 conditional branch 20% 

3 compare 16% 

4 store 12% 

5 add 8% 

6 and 6% 

7 sub 5% 

8 move register-register 4% 

9 call 1% 

10 return 1% 

Total 96% 

Simple instructions dominate instruction frequency 


etur 

Operaciones básicas 

• Conclusión: Soportar las siguientes operaciones porque son las 

que predominan en el conjunto de instrucciones ejecutadas. 

Tipo de instrucción Instrucción del procesador MIPS 

load lw $a0, -30($t5) # $a0=M[-30+$t5] 

store sw $t2, 100($s5) # M[100+$s5]=$t2 

add add $t0,$t1,$t2 # $t0= $t1+t2 

subtract sub $a0,$s0,$s1 # $a0= $s0-$s1 

move register-register add $t0,$zero,$t1 # $t0=$t1 

and and $t0,$t1,$t2 # $t0= $t1&$t2 

shift sll $t0,$t1,5 # $t0=$t1

Tipos y tamaños de los operandos 

• Tipos de operandos 

– Bit: 

• 0,1 

– Carácter 

• ASCII de 7 u 8 bits (extensiones gráficas) 

• EBCDIC de 8 bits (utilizado por los grandes computadores IBM) 

– Enteros 

• Números positivos y negativos representados en complemento a 2. 

• Byte: 8 bits 

• Media palabra (half-word): 16 bits 

• Palabra: 32 bits 

– Punto flotante 

• IEEE 754: Estándar para la representación en punto flotante. 

• Simple precisión (32 bits) y doble precisión (64 bits). 

– Decimal 

• Decimal empaquetado: Decimal codificado en binario (BCD), 4 bits para 

cada dígito, dos dígitos por byte. Ejemplo: 01001001 -> 49 

• Decimal no empaquetado. Ejemplo: 00000100 00001001 -> 4 9 


Especificación del tipo de operando 

• Dos alternativas: 

– Codificarlo en el código de operación de la instrucción (caso más frecuente). 

– Añadir identificadores al dato que posteriormente serán interpretados por el 

hardware (método raramente utilizado) 

• Tagged architectures: Máquina de Burroughs 


Frecuencia de uso de los tamaños de operandos 

Doubleword 

Word 

Halfword 

Byte 

0% 

0% 

0% 

7% 

19% 

31% 

• Es importante que las arquitecturas soporten: 

– Números enteros de 8, 16 y 32 bits. 

– Números en punto flotante de 32 y 64 bits (estándar IEEE754). 


69% 

74% 

0% 20% 40% 60% 80% 

Frequency of reference by size 

Int Avg. 

FP Avg.

Formatos de las instrucciones 

• La información autocontenida en una instrucción se codifica con 

unos y ceros y se empaqueta en grupos de bits que definen los 

diferentes campos de una instrucción. 

• Campos de una instrucción 

Campo 1 Campo 2 ............... Campo n 

11110011 11010 ................ 110000 

• Alternativas de diseño: 

– Instrucciones de longitud variable 

• Alta densidad de código. 

• Programas compactos o de tamaño reducido. 

• Difícil implementación hardware. 

– Instrucciones de longitud fija 

• Mayor rendimiento (vía segmentación de las instrucciones) 

• Los programas son de mayor tamaño. 

• Fácil implementación hardware. 


Formatos de las instrucciones en el procesador 

MIPS 

Sólo tres formatos: 

• Formato R: add rd,rs,rt 

op rs rt rd shamt funct Formato de instrucciones aritméticas 

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits Todas las instrucciones MIPS de 32 bits 

000000 01010 11111 00011 00000 100000 0x015f1820 add $3,$10,$31 

• Formato I: lw rt,inmediato(rs) 

op rs rt Dirección/inmediato Formato de instrucciones carga 

6 bits 5 bits 5 bits 16 bits Todas las instrucciones MIPS de 32 bits 

100011 00011 00101 0000000000100000 0x8c650020 lw $5,32($3) 

• Formato J: j dirección 

op Dirección objetivo Formato de instrucciones bifurcación 

6 bits 26 bits Todas las instrucciones MIPS de 32 bits 

000010 00000100000000000000000000 0x08100000 j 0x400000 


Ejemplo de arquitectura CISC 

(Complex Instruction Set Computer) 

• Máquina representativa CISC: VAX 11/780 

– Objetivos de VAX: 

• Compiladores sencillos y alta densidad de código. 

– Estos objetivos dieron lugar a: 

• Formato de instrucciones de longitud variable. 

• Potentes modos de direccionamiento. 

• Potentes instrucciones y codificación de las mismas. 

• Arquitectura altamente ortogonal: El código de operación es independiente 

de los modos de direccionamiento que son independientes de los tipos de 

datos e incluso del número de operandos. Una instrucción puede utilizar 

cualquier modo de direccionamiento y tipo de dato de los soportados. 

– Ejemplo: SUMA 

(código de operación) (tipos de datos:byte, word, ...)(nº de operandos: 2,3) 

addb2 addw2 addl2 addf2 addd2 

addb3 addw3 addl3 addf3 addd3 

Cientos de operaciones se expanden a miles de instrucciones! 


Ejemplo de arquitectura RISC 

(Reduced Instruction Set Computer) 

• Ejemplo de procesador RISC: MIPS 

– Objetivos de MIPS 

• Alto rendimiento vía segmentación. 

• Facilitar la implementación hardware de las instrucciones. 

• Compatibilidad con compiladores altamente optimizados. 

– Estos objetivos dieron lugar a: 

• Instrucciones sencillas. 

• Modos de direccionamiento sencillos. 

• Formato de instrucciones de longitud fija. 

• Gran número de registros. 


Procedimientos 

• Definición: Fragmento de código que realiza una tarea concreta y que 

puede ser llamado o activado desde otra parte del programa. 

• Ventajas del uso de procedimientos 

– Estructuración modular de los programas: 

• Nos permite descomponer un programa complejo en otros más sencillos 

que se pueden editar, compilar y depurar de forma independiente. 

– Código reutilizable 

• Librerías de procedimientos 

Llamada a un procedimiento 

nombre_proc (pa1, pa2,...) p 1, p 2,..: parámetros actuales 

Formato 

Procedimiento nombre_proc(p1, p2,..) declaraciones 

inicio 

 

fin 

p1, p2,..: parámetros formales 


Pasos en la llamada a un procedimiento 

Programa principal 

• 

Paso 1: Paso de parámetros. Colocar los 

parámetros de paso al procedimiento (en 

registros o stack). 

Paso 2: Llamada al procedimiento 

• 

• 

Procedimiento 

Paso 3: Salvar registros. Crear bloque de 

activación (adquirir los recursos de 

almacenamiento necesitados por el 

procedimiento). Guardar en el stack los 

registros que se deseen preservar (callee 

saving). Gestión del bloque de activación. 

Paso 4: Cuerpo del Procedimiento. Ejecuta 

tarea a realizar. 

Paso 5: Colocar los resultados para pasarlos 

al programa principal. Restaurar registros. 

Destruye bloque de activación. 

Paso 6: Retorno al procedimiento. 

Regresa al programa principal (dirección 

siguiente a la llamada de procedimiento). 


Tipos de procedimientos 

• Procedimiento anidado 

– Un procedimiento A llama a otro B que a su vez llama a otro C y ...... 

• Procedimiento recursivo 

– Procedimiento que se llama a si mismo 

• Procedimiento reentrante 

Guardar Guardar 

Proc A Proc B Proc C 

Recuperar 

Recuperar 

Procedimiento FACTORIAL (N) 

integer N, FACTORIAL 

if N

La Pila (o stack) 

• Estructura de datos tipo LIFO (Last Input First Output) útil para: 

– Contener valores pasados a un procedimiento como parámetros. 

– Salvar la información que se desee preservar en llamadas a procedimientos. 

• Por ejemplo, registros que el invocador no quiere cambiar. 

– Proporcionar a un procedimiento espacio para variables locales 

• Operaciones básicas: 

• Guardar (push) y recuperar (pop). 

• Normalmente, la estructura de datos crece hacia posiciones más bajas 

de memoria. 

• Puntero de pila (Stack Pointer, SP) 

– Puntero o registro cuyo contenido apunta a la cima de la pila. 

– Ejemplo: MIPS utiliza el registro 29 ($29 o $sp) como puntero de pila. 


Operaciones sobre la pila 

sp-4 

sp 

Guardar (push) 

1. Decrementar puntero 

2. Escribir en memoria (store) 

MIPS: 

addi $sp,$sp,-4 

sw $reg, 0($sp) 

Memoria Dirección 

Valor guardado 

Baja 

Alta 

Recuperar (pop) 

1. Leer de memoria (load) 

2. Incrementar puntero 

MIPS: 

lw $reg, 0($sp) 

addi $sp,$sp,4 

Memoria Dirección 

Valor leído 


sp 

sp+4 

Baja 

Alta

Bloque de activación antes, durante y después de 

la llamada a un procedimiento 

# Programa principal 

..... 

Llamar_a B(p1,p2,..) 

Antes 

Dirección baja 

de memoria Durante Después 

sp -> Variables locales 

Registros 

guardados 

Dirección de retorno 

fpOLD sp -> 

Ejemplo: Soporte a procedimientos de la 

arquitectura MIPS 

• Convenio de los programadores para el uso de los registros 

– $a0 - $a3: Registros para paso de hasta 4 parámetros. 

– $v0 - $v1: Registros para la devolución de resultados. 

– $gp: puntero global que apunta a un segmento de datos estáticos. 

– $sp: Puntero de pila. 

– $fp: Puntero de encuadre (frame pointer). 

– $ra: Registro para guardar la dirección de retorno al realizar la llamada. 

• Instrucción MIPS para llamada a procedimientos 

– Jump - and - Link (jal) 

• jal ProcedureAddress # $ra= PC+ 4; ir a ProcedureAddress 

• jalr registro # $ra= PC+ 4; ir a (registro) 

• Instrucción MIPS para el retorno de procedimientos 

– Jump Register (jr) 

• jr $ra # ir a la dirección dada por $ra 


Arquitectura MIPS: Convenio para el uso de los 

registros en llamadas a procedimientos 

Nombre Nº reg. Uso 

Preservado 

en llamadas? 

$zero 0 Constante 0 - 

$at 1 Reservado para el ensamblador - 

$v0-$v1 2-3 Valores de resultados y evaluación de expresiones no 

$a0-$a3 4-7 Paso de parámetros (hasta cuatro; más a través de la pila) no 

$t0-$t7 16-23 Registros temporales no 

$s0-$s7 16-23 Registros que deben preservarse si 

$t8-$t9 24-25 Registros temporales no 

$k0-$k1 26-27 Reservado para el Sistema Operativo - 

$gp 28 Puntero global (global pointer) si 

$sp 29 Puntero de pila (stack pointer) si 

$fp 30 Puntero de encuadre (frame pointer) si 

$ra 31 Dirección de vuelta (return address) si 

Las abreviaciones de dos letras y nombre de los registros reflejan los usos pensados para ellos en el convenio. 


Ejemplo para MIPS 

SP 

SP=SP-20 

# Ejemplo para MIPS 

# Programa principal 

main: li $a0,5 

li $a1,8 

jal multi 

.................... 

# comienzo del procedimiento 

multi: addi $sp,$sp,-20 # Crea bloque de activación. 

# Salva registros. Crea variables locales si se necesitan. 

sw $fp, 16($sp) # guarda fp antiguo 

sw $ra, 12($sp) # guarda dirección de retorno 

sw $s0, 8($sp) # guarda $s0 

sw $s1, 4($sp) # guarda $s1 

sw 

addi 

$s2, 0($sp) # guarda $s2 

$fp,$sp,16 # nuevo fp 

# cuerpo procedimiento 

..... 

# Restaura registros 

lw $s2, 0($sp) # recupera $s2 



lw $ra, 12($sp) # recupera dirección de retorno 

lw $fp, 16($sp) # recupera fp antiguo 

addi $sp,$sp,20 # Destruye bloque activación 

jr $ra # retorna al programa principal 


$s2 

$s1 

$s0 

Registros salvados 

$ra: dir. retorno 

$fp: frame pointer 

Dirección baja 

de memoria 

Clasificación de las arquitecturas a nivel de 

lenguaje máquina 

• La clasificación puede realizarse atendiendo a varios criterios entre los 

que destacamos: 

– Almacenamiento de los operandos en la CPU. 

• Además de en memoria ¿dónde se encuentran los operandos? 

– Número de operandos explícitos por la instrucción. 

– Posición del operando. 

– Tipo de instrucciones 

– Tipo y tamaño de los operandos 

• Almacenamiento de los operandos en la CPU. 

– Criterio más importante que nos permite diferenciar una arquitectura de otra. 


Clasificación de las arquitecturas atendiendo al 

almacenamiento de operandos en la CPU 

• Alternativas para almacenar operandos en la CPU 

Arquitectura Operandos Destino de Procedimiento para acceder a 

explícitos resultados 

operandos explícitos 

Arquitectura de Pila 0 Pila Introducir y sacar de la pila 

Arquitectura de Acumulador 1 Acumulador Cargar/almacenar acumulador 

Arquitectura de Registros de 

Propósito General 

2 ó 3 Registros o 

memoria 

• Ejemplo: C= A + B (C,A y B variables en memoria) 

Pila Acumulador Registros 

PUSH A LOAD A LOAD R1, A 

PUSH B ADD B ADD R1, B 

ADD STORE C STORE C,R1 

POP C 

Cargar/almacenar registro o memoria 


Ventajas y desventajas de cada una de las 

arquitecturas 

Tipo de máquina Ventaja Desventaja 

Pila Modelo sencillo para la evaluzación 

de expresiones. 

Instrucciones cortas. Buena densidad 

de código 

Acumulador Instrucciones cortas. 

Minimiza los estados internos de la 

máquina 

Registro Modelo más general para la 

generación de código. 

Uso efectivo de los registros por los 

compiladores. 

Acceso no aleatorio a la pila. Difícil 

generación de código eficiente. 

Dificulta una implementación 

eficiente. 

Como el acumulador es sólo 

almacenamiento temporal, el tráfico 

de memoria es el más alto. 

Todos los operandos deben ser 

nombrados -> instrucciones más 

largas. 

- Años 60: Arquitecturas de pila. 

- Años 70: Arquitecturas CISC (ej. VAX) 

- Años 80: Arquitecturas RISC (ej. MIPS) 

Las arquitecturas de registros son las que dominan hoy día! 


Clasificación de las arquitecturas de registros de 

propósito general 

• Clasificación de las arquitecturas de registros atendiendo a: 

– Número de operandos: 2 o 3. 

• add r1,r2 # r1=r1 + r2 

• add r1,r2,r3 # r1=r2 + r3 

– Número de operandos en memoria: de 0 a 3. 

• add r1,r2,r3 # r1=r2 + r3 

• add r1,r2,B # r1=r2 + EA(A) 

• add r1,B,A # r1=EA(A) + EA(B) 

• add C,B,A # EA(C)=EA(B) + EA(A) 

• Las arquitecturas de registros dominan hoy día. 

– Los registros son más rápidos que la memoria 

– Los registros son fáciles de usar por el compilador. 

– Los registros pueden almacenar variables: 

• Reducción del tráfico de memoria. Disminución del tiempo de ejecución. 

• Mejor densidad de código: unos cuantos bits son suficientes para 

especificar un registro. En cualquier caso, menos que los necesarios 

para indicar una dirección de memoria. 


Arquitecturas de registros de propósito general 

más frecuentes 

Registro-Registro 

(0,3) 

Registro-Memoria 

(1,2) 

Memoria-Memoria 

(3,3) 

Tipo Ventajas Desventajas 

Instrucciones longitud fija. 

Fácil codificación. 

Modelo simple de generación de 

código. 

Los datos pueden ser accedidos sin 

cargarlos primero en registros. 

Fácil formato de instrucción. 

Buena densidad de código. 

Más compacta. 

No emplean registros para datos 

temporales 

Recuento de instrucciones más alto que las 

arquitecturas con referencias a memoria. 

La codificación de una dirección de 

memoria y un registro en cada instrucción 

puede restringir el número de registros. 

Los ciclos por instrucción varían por la 

posición del operando. 

Notación (m,n). m: Número de operandos en memoria; n: Número de operandos totales. 

Gran variación en el tamaño de las 


Los accesos a memoria crean cuellos de 

botella importantes. 


Número de registros en arquitecturas populares 

Máquina 

Número de registros de 

propósito general 

Estilo de arquitectura Año 

EDSAC 1 Acumulador 1949 

IBM701 1 Acumulador 1953 

IBM360 16 Registro-memoria 1964 

DEC PDP11 8 Registro-memoria 1970 

INTEL 8008 1 Acumulador 1972 

MOTOROLA 6800 2 Acumulador 1974 

DEC VAX 16 Registro-memoria, 

memoriamemoria- 

1977 

INTEL 8086 1 Acumulador extendido 1978 

MOTOROLA 68000 16 Registro-memoria 1980 

INTEL 80386 8 Registro-memoria 1985 

MIPS 32 Registro-Registro 

(carga/almacenamiento) 

1985 

HP PA-RISC 32 “ 1986 

SPARC 32 “ 1987 

PowerPC 32 “ 1992 

DEC ALPHA 32 “ 1992 


Lenguaje ensamblador 

• Introducción. 

• Ventajas e inconvenientes del lenguaje ensamblador. 

• Funcionamiento del ensamblador. 

• El montador de enlaces (o linker). 

• Utilidades de los ensambladores. 

• Lenguaje ensamblador del procesador MIPS R2000 


Ventajas e inconvenientes del lenguaje 

ensamblador 

• Ventajas del lenguaje ensamblador 

– Útil cuando es crítico alguno de los siguientes factores: 

• Tiempo de ejecución del programa. 

• Tamaño del programa. 

– El programador puede seleccionar instrucciones específicas de la 

arquitectura para realizar una determinada operación. 

• Inconvenientes del lenguaje ensamblador 

– Los programas son específicamente inherentes a la máquina. 

– Son de mayor tamaño que los programas equivalentes escritos en lenguaje 

de alto nivel. Menor productividad del desarrollo software. 

– Los programas son difíciles de leer, escribir y pueden contener más errores. 

• Soluciones híbridas para aprovechar la fortaleza de cada lenguaje 

– La mayor parte del programa se escribe en alto nivel. 

– Las secciones críticas en lenguaje ensamblador. 


Funcionamiento del ensamblador 

• Un ensamblador traduce un archivo con sentencias en lenguaje 

ensamblador a un archivo de instrucciones máquina y datos binarios. 

• Traducción en dos pasadas: 

– Primera pasada: 

• Calcula las posiciones de memoria que corresponden a los nombres 

simbólicos que aparecen en el programa para que sean conocidas 

cuando de traduzcan las instrucciones. Crea tabla de símbolos. 

– Segunda pasada: 

• Traduce cada sentencia del lenguaje ensamblador al combinar los 

equivalentes numéricos de los códigos de operación, especificadores de 

registros y rótulos de la tabla de símbolos en una instrucción legal. 

• Rótulos o etiquetas 

– Externos o globales: Pueden ser referenciados desde otro archivo distinto 

de aquél en el que se define (hay que declararlos como tales). 

– Internos o locales: Sólo puede ser referenciado en el archivo en el que se 

define (locales por defecto). 


El montador de enlaces (linker) 

• El ensamblador procesa cada archivo de un programa de forma 

individual. Solamente se conocen las direcciones de los rótulos locales. 

• Necesidad de otra herramienta: El montador de enlaces (o linker). 

– Combina una colección de archivos objetos y librerías (opcional) en otro 

archivo ejecutable al resolver los rótulos externos. 

– El ensamblador asiste al montador suministrándole una tabla de símbolos o 

rótulos y referencias no resueltas. 

Archivo 

fuente 

Archivo 

fuente 

Archivo 

fuente 

Ensamblador 

Ensamblador 

Ensamblador 

Archivo 

objeto 

Archivo 

objeto 

Archivo 

objeto 

Enlazador 

Librería 

Archivo 

ejecutable 


Utilidades de los ensambladores 

• Los ensambladores proporcionan diversas características (utilidades) 

que facilitan al programador la escritura de los programas. 

• Utilidades: 

– Directivas para organizar datos en memoria. 

• Permite al programador describir los datos de una manera más concisa 

y natural que la representación binaria: decimal, ASCII, hexadecimal,... 

– Macros 

• Permiten nombrar una secuencia de instrucciones frecuentemente 

utilizada. No confundir con procedimiento o subrutina. 

– Pseudoinstrucciones 

• Son proporcionadas por algunos lenguajes ensambladores y no forman 

parte del repertorio de instrucciones del procesador. El ensamblador las 

sintetiza a partir de instrucciones puras del procesador. 

– Utilización de símbolos 

• Muy útil en instrucciones de control de flujo o para hacer referencia a los 

datos. 


Lenguaje ensamblador MIPS R2000 

• Componentes de un procesador MIPS 

• Modos de direccionamiento 

• Sintaxis del ensamblador 

• Directivas del ensamblador soportadas por el simulador SPIM. 

• Formato de las instrucciones. 

• Repertorio de instrucciones 

– Aritméticas 

– Lógicas 

– Transferencia de datos 

– Movimiento de datos 

– Comparación 

– Salto y bifurcación 

• Ejemplo de programa en ensamblador 


Componentes de un procesador MIPS 

• Componentes 

– CPU 

– Dos coprocesadores: 0 y 1. 

• CPU: 32 registros de propósito general 

– $0: Siempre contiene 0 

– $1-$31: Propósito general 

• C0: 4 registros 

– BadVAddr (reg. Nº 8), Status (reg. Nº 12) 

– Cause (reg. Nº 13), EPC (reg. Nº 14) 

• C1: 32 registros para punto flotante 

– 16 registros simple precisión 

• $f0, $f2, …. $f30 (32 bits) 

– 16 registros doble precisión (64 bits 

• $f0-$f1, $f2-$f3, …. $f30-$f31 


CPU 

Arithmetic 

unit 

Registers 

$0 

$31 

Memory 

Multiply 

divide 

Lo Hi 

Coprocessor 1 (FPU) 

Coprocessor 0 (traps and memory) 

Registers 

BadVAddr 

Status 

Cause 

EPC 

Registers 

$0 

$31 

Arithmetic 

unit

Convenio para el uso de la memoria en sistemas 

basados en el procesador MIPS 

0x7FFFFFFF Pila Segmento de pila 

0x10000000 

0x00400000 

0x00000000 

Datos dinámicos 

Datos estáticos 

Segmento de datos 

Código Segmento de texto 

Reservada 


Modos de direccionamiento 

Register (direct) 

Immediate 

Base+index 

PC-relative 

op rs rt rd 

register 

op rs rt 

op rs rt 

register 

op rs rt 

PC 

immed 

immed 

immed 


+ 

+ 

Memory 

Memory

Sintaxis del ensamblador 

• Líneas de comentarios 

– Todo lo que haya a partir del simbolo # hasta el final de línea se ignora. 

• Directivas 

– Secuencia de caracteres, (_) y (.) que no empiezan por un número. 

• Etiquetas 

– Se declaran colocándolas al principio de línea y terminadas en (:). 

• Número decimales y hexadecimales 

– Números en base 10 por defecto. 

– Hexadecimales o en base 16 precedidos por 0x. 

• Cadenas o strings 

– Las cadenas están encerradas entre dos comillas (“). 

– Caracteres especiales: 

• \n Nueva línea 

• \t Tab 

• \” Comillas 


Ejemplo de sintaxis 

############################################################################ 

# Sintaxis del ensamblador # 

############################################################################ 

# Comienzo del segmento de datos 

.data 0x10000000 

init: .word 0x10,25,0x11223344 # declaración de 3 variables tipo word (4 bytes) 

string: .asciiz “Soy una cadena \n” # declaración de una cadena 

# Comienzo del segmento de código 

.text 0x400000 

.globl main # declaramos la etiqueta “main” como global 

main: lw $t0,-8($s0) # comentario 

addi $t0,$t0,1 # comentario 


Directivas del ensamblador de MIPS soportadas 

por el simulador SPIM 

•SPIM soporta un subconjunto de las directivas del ensamblador MIPS 

– .align n 

– .ascii str 

– .asciiz str 

– .byte b1,b2,... 

– .half h1,h2,... 

– .word w1,w2,... 

– .float f1,f2,... 

– .double d1,d2,... 

– .space n 

– .data 

– .text 

– .ktext 

– .kdata 

 

– .globl símbolo 

– .extern símbolo size 

– .set noat 

– .set at 


Formato de las instrucciones 

Sólo tres tipos de formatos: 

• Formato R: add rd,rs,rt 

op rs rt rd shamt funct Formato de instrucciones aritméticas 

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits Todas las instrucciones MIPS de 32 bits 

000000 01010 11111 00011 00000 100000 0x015f1820 add $3,$10,$31 

• Formato I: lw rt,inmediato(rs) 

op rs rt Dirección/inmediato Formato de instruciones de carga 

6 bits 5 bits 5 bits 16 bits Todas las instrucciones MIPS de 32 bits 

100011 00011 00101 0000000000100000 0x8c650020 lw $5,32($3) 

• Formato J: j dirección 

op Dirección objetivo Formato de instrucciones de bifurcación 

6 bits 26 bits Todas las instrucciones MIPS de 32 bits 

000010 000000000010000000000000000 0x08010000 j 0x400000 


Repertorio de instrucciones MIPS: 

Instrucciones aritméticas 

Instrucción Ejemplo Significado Comentarios 

sumar add $1,$2,$3 $1= $2+$3 Posible excepción por desbordamiento 

sumar sin signo addu $1,$2,$3 $1=$2+$3 - 

sumar inmediato addi $1,$2,10 $1=$2+10 Posible excepción por desbordamiento 

sumar inmediato sin signo addiu $1,$2,10 $1=$2+10 - 

restar sub $1,$2,$3 $1=$2-$3 Posible excepción por desbordamiento 

restar sin signo subu $1,$2,$3 $1=$2-$3 - 

dividir div $1,$2 

Lo=$1÷$2 

Hi=$1mod$2 

Posible excepción por desbordamiento 

dividir sin signo divu $1,$2 

Lo=$1÷$2 

- 

Hi=$1mod$2 

multiplicar mult $1,$2 Hi,Lo=$1*$2 - 

multiplicar sin signo multu $1,$2 Hi,Lo=$1*$2 - 

Pseudoinstrucciones 

valor absoluto abs 

dividir div $1,$2,$3 

$1=$2÷$3 

(cociente) 

dividir sin signo divu $1,$2,$3 

$1=$2÷$3 

- 

(cociente) 

Posible excepción por desbordamiento 

multiplicar mul $1,$2,$3 $1=$2*$3 - 

multiplicar mulo $1,$2,$3 $1=$2*$3 Posible excepción por desbordamiento 

multiplicar sin signo mulou $1,$2,$3 $1=$2*$3 Posible excepción por desbordamiento 



Instrucciones lógicas 


and and $1,$2,$3 $1= $2&$3 

or andi $1,$2,10 $1=$2&10 

xor xor $1,$2,$3 $1=$2⊕$3 

nor nor $1,$2,$3 $1=~($2|$3) 

andi andi $1,$2,10 $1=$2&10 

ori ori $1,$2,10 $1= $2|10 

xori xori $1,$2,10 $1=$2|10 

shift left logical sll $1,$2,10 $1= $2$3 

shift right arithmetic sra $1,$2,10 $1=$2>>10 

shift right arithmetic variable srav $1,$2,$3 $1=$2>>$3 



Instrucciones de transferencia de datos 


carga byte lb $1,10($2) $1=M[10+$2] Extiende el bit de signo 

carga byte sin ext. signo lbu $1,10($2) $1=M[10+$2] No extiende el bit de signo 

carga media palabra lh $1,10($2) $1=M[10+$2] Extiende el bit de signo 

carga media palabra sin 

extensión de signo 

lhu $1,10($2) $1=M[10+$2] No extiende el bit de signo 

carga palabra lw $1,10($2) $1=M[10+$2] 

carga inmediata de la 

parte más significativa 

“load upper inmediate” 

Carga registro del 

coprocesador z 

16 Carga un dato de 16 bits en la parte más 

lui $1,50 $1=50*2 

significativa del registro. 

lwc1 $f0,10($2) $f0= M[10+$2] 

almacena byte sb $1,10($2) M[10+$2]=$1 

almacena media palabra sh $1,10($2) M[10+$2]=$1 

almacena palabra sw $1,10($2) M[10+$2]=$1 

almacena registro en 

memoria registro del swc1 $f0,10($2) M[10+$2]=$f0 

coprocesador z 


Carga inmediata li $1,1000 $1=1000 Carga de un dato de 32 bits 

Carga dirección la $3,label 

$3=dirección de 

label 

Transfiere la dirección de memoria no el 

contenido. 



Instrucciones de movimiento de datos 


mover desde Hi mfhi $1 $1= Hi 

mover desde Lo mflo $1 $1= Lo 

mover a Hi mthi $1 Hi=$1 

mover a Lo mtlo $1 Lo=$1 

mover desde coprocesador z mfcz $1,$f0 $1=$f0 $f0-$f30: Registros del coprocesador 1 

mover al coprocesador z mtcz $1,$f0 $f0=$1 


transfiere o mueve move $1,$2 $1=$2 

transfiere doble desde coproc. 1 mfc1.d $4,$f0 

$4=$F0 

$5=$F1 



Instrucciones de comparación 

Instrucción Ejemplo Significado 

if ($2


Instrucciones de salto y bifurcación 


salta sobre igual beq $1,$2,100 si($1==$2) ir a PC+4 +100 

salta sobre no igual bne $1,$2,100 si($1!=$2) ir a PC+4 +100 

salta sobre mayor o igual que cero bgez $1,100 si($1>=0) ir a PC+4 +100 

salta sobre mayor o igual que cero y 

bgezal $1,1000 si($1>=0) $31=PC+4; ir a 1000 

enlaza 

..... 

bifurcar j 2000 ir a 2000 

bifurcar registro jr $1 ir a $1 

Bifurcar y enlazar jal 10000 $31=PC+4; ir a 10000 

bifurcar y enlazar registro jalr $1 $31=PC+4; ir a $1 


salta sobre mayor o igual bge $1,$2,100 si($1>=$2) ir a PC+4 +100 

salta sobre mayor que bgt $1,$2,100 si($1>$2) ir a PC+4 +100 

salta sobre menor o igual ble $1,$2,100 si($1

Tema 3: El nivel de lenguaje máquina - Blearning

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?