ISA - Key

543.
426
Arquitectura de Computadores Miguel Figueroa!

! Oficina 235!
Email:
Arquitectura de conjunto de miguel.figueroa@udec.cl
instrucciones (ISA)
1
Arquitectura de conjunto de instrucciones
❖ Instruction Set Architecture (ISA)!
❖ Comúnmente conocido como “lenguaje de
máquina”!
❖ Define la interfaz entre el hardware y el
software!
❖ Compatibilidad binaria!
❖ No son solamente las instrucciones del
lenguaje!
❖ Registros internos! ISA soporta el software!
❖ Organización de la memoria!
!
Hardware soporta ISA durante muchas
❖ Tipo y formato de datos! generaciones de la arquitectura!
!
❖ Codificación de instrucciones! Ej. Intel IA32 (x86), ARM, MIPS.
❖ Excepciones
Universidad de Concepción, Departamento de Ingeniería Eléctrica 2 Arquitectura de Computadores - 543426 - Miguel Figueroa, 2014
Arquitectura de conjunto de instrucciones
❖ Definición de la arquitectura fuertemente afectada por la tecnología!
❖ ¿Cuántos registros internos puede alojar el procesador? ¿Cuánta memoria puede
direccionar un programa? ¿Qué capacidad tienen los compiladores de generar código
eficiente?!
❖ “Brecha semántica”!
❖ Diferencia entre nivel de abstracción de lenguaje de alto nivel y del lenguaje de
máquina. Arquitecturas antiguas favorecían cerrar la brecha con un lenguaje de máquina
con instrucciones “poderosas”!
❖ Ej. VAX: instrucciones para multiplicar polinomios!
❖ Arquitectura Intel (IA32) definida en los ‘70 posee pocos registros internos, operandos en
memoria, códigos de instrucción compactos!
❖ Filosofía Reduced Instruction Set Computer (RISC) en los ’80 favorece más registros,
instrucciones sencillas y pocas, operandos en registro e instrucciones load/store
Compilando un programa
Programa
en C
compilador
Assembly
ensamblador
Objeto Biblioteca
linker
linker
Ejecutable
loader
Memoria
Ejecutando el programa
Programa en memoria
PC: program counter

(contador de
programa)!
!
Puntero a siguiente
instrucción a ejecutar
en memoria
PC: program counter

(contador de
programa)!
!
Puntero a siguiente
en memoria
PC: program counter

(contador de
programa)!
!
Puntero a siguiente
en memoria
Arquitectura MIPS
❖ Buen ejemplo de arquitectura RISC,
creada comercialmente en los ’80 a
partir de proyecto de investigación
en Stanford!
❖ No se usa mucho en computadores
hoy, pero común en procesadores
embebidos!
❖ Más limpia y fácil de entender que
Intel x86!
❖ Muchas arquitecturas modernas en
uso son similares!
❖ Ej. IBM POWER, PowerPC, ARM
Arquitectura MIPS de 32 bits
❖ Registros de propósito general!
❖ 32 registros enteros de 32 bits (1 palabra).
Almacenan datos y direcciones!
❖ Registros específicos! MIPS
CPU Coprocesador 1
❖ PC: contador de programa. HI, LO: $0 $f0
resultados de multiplicación y división! $1 $f1
. .
ALU Aritmética
❖ Dos coprocesadores! .
.
. FP
.
$31
❖ Coprocesador 0: Excepciones y memoria $f31
virtual. Coprocesador 1: Unidad de punto HI

Mult/Div
flotante! LO Enteros Coprocesador 0
32 Cause
❖ Memoria de 4GB (2 bytes) almacena datos e PC Status
instrucciones! BadVAddress
EPC
❖ Qué significa que MIPS32 sea una arquitectura
de “32 bits”?!
Memoria
❖ Instrucciones tienen un largo de 32 bits!
❖ Instrucciones operan sobre datos de 32 bits!
❖ Direcciones de memoria son de 32 bits
Mapa de memoria
❖ En modo usuario: programas regulares!
❖ Texto: Código del programa! 0xFFFF FFFF
Reservado S. O.
❖ Datos: Variables globales y memoria 0x7FFF FFFF
Segmento stack
dinámica!
❖ Stack: Datos de funciones o
procedimientos activos!
Segmento datos
❖ En modo supervisor: sistema operativo! 0x1000 0000
Segmento
de texto
❖ Primeros 256KB, últimos 2GB!
0x0040 0000
❖ Datos y código del sistema Reservado S. O.
operativo!
0x0000 0000
❖ Interfaz a dispositivos de entrada/
salida
Almacenamiento de datos en memoria
❖ Registros de dirección indican posiciones de bytes!
❖ Normalmente acceso a datos es alineado!
❖ Datos e instrucciones de 32 bits almacenados a partir de direcciones múltiplos de 4!
❖ Datos de 16 bits almacenados a partir de direcciones múltiplos de 2!
❖ Puede ser configurado en modo “big endian” (lo normal) o “little endian”
Dato de 32 bits en dirección “DIR” 02 DIR + 3

1A DIR + 2
24 38 1A 02 Memoria
38 DIR + 1
big endian
24 DIR
Dato de 32 bits en dirección “DIR” 24 DIR + 3

Memoria 38 DIR + 2 little endian
24 38 1A 02 1A DIR + 1
02 DIR
Convención de uso de registros MIPS
$0 zero constante cero $16 s0 variables locales
Deben almacenarse antes de
$1 at reservado para ensamblador
sobreescribir y restaurarse antes
retornar
$2 v0 evaluación de expresiones y $23 s7
$3 v1 resultados de funciones
$24 t8 temporales (adicionales)
$25 t9
$4 a0 argumentos a funciones
$5 a1
$6 a2 $26 k0 reservados para sistema operativo
$7 a3 $27 k1
$8 t0 variables temporales
Pueden sobreescribirse $28 gp puntero a variables globales
$29 sp puntero a tope del stack
$30 fp puntero a base del stack
$15 t7
$31 ra dirección de retorno de función
Sólo $zero y $ra tienen funciones definidas por la ISA!

No usar $at, ensamblador puede usarlo entre instrucciones
¿Por qué usar registros y no sólo memoria?
❖ Ventajas de usar registros!
❖ Velocidad de acceso: banco de registros es pequeño, rápido en VLSI!
❖ Versatilidad de acceso: como banco de registros es pequeño, acceso es más poderoso!
❖ Múltiples puertas de lectura y escritura. Puede al menos leerse dos registros y
escribir un tercero simultáneamente!
❖ Compilador puede realizar optimizaciones más agresivas con datos en registros!
❖ Desventajas!
❖ Son pocos registros, programa necesita acceso a más almacenamiento!
❖ Necesario transferir datos entre registros y memoria!
❖ Compilador debe planificar cuidadosamente uso de registros para minimizar
accesos a memoria
Instrucciones assembly
❖ Instrucciones assembly ejecutan un conjunto reducido de operaciones simples usado un
conjunto limitado de operados!
❖ En MIPS, operandos son siempre registros o constantes de 16 bits. Ejemplos:!
❖ add $s0, $s5, $s2 #suma contenido de $s5 y $s2 y almacena en $s0!
❖ addi $s0, $s5, 25 #suma $s5 y la constante 25 y almacena en $s0!
❖ Excepción: instrucciones load y store transfieren datos de memoria a registro y
viceversa!
❖ Sintaxis de instrucciones es rígida. !
❖ Ejemplos: 3 operandos: registro destino y dos registros fuente; o registro destino,
registro fuente y constante. Regularidad simplifica el hardware y el compilador!
❖ Imprimir resumen de ISA MIPS (MIPS_Green_Sheet.pdf). Detalles en manuales MIPS
también en InfoDA
Suma y resta de enteros
Suma de variables en assembly: add! comentario
!
Ejemplo:! ! add $s0, $s1, $s2! ! # en MIPS!
Equivalente a:! a = b + c; ! ! ! // en C!
!
Compilador asoció registros $s0, $s1 y $s2 a variables a, b y c
Resta de variables en assembly: sub!

!
Ejemplo:! ! sub $s3, $s4, $s5! ! # en MIPS!
Equivalente a:! f = g - h; ! ! ! // en C!
!
Compilador asoció registros $s3, $s4 y $s5 a variables f, g y h
Suma de una variable y una constante en assembly: addi!
Constante es “operando inmediato” porque su valor está incluido en la instrucción!
Por lo mismo, tamaño de la constante restringido a 16 bits. Se extiende a 32 bits
repitiendo el bit de signo hacia la izquierda!
!
Ejemplo:! ! addi $s0, $s1, 25! ! # en MIPS!
Equivalente a:! a = b + 25; ! ! ! // en C!
!
Compilador asoció registros $s0 y $s1 a variables a y b
Resta de una variable y una constante en assembly: no existe!!!!
Por qué? Innecesario, puede usarse suma con valor inverso de la constante. Simplificar
la ISA simplifica el hardware y el trabajo del compilador!
!
Ejemplo:! ! addi $s3, $s4, -120! ! # en MIPS!
Equivalente a:! f = g - 120; ! ! ! // en C!
!
Compilador asoció registros $s3 y $s4 a variables f y g
Suma con/sin signo
¿Cuánto es 120+120 en aritmética de 8 bits?
En aritmética sin signo:!
120 —> 0b01111000!
0b01111000 + 0b01111000 = 0b11110000!
0b11110000 —> 240 OK!!!
En aritmética con signo complemento a dos:!

0b01111000 + 0b01111000 = 0b11110000!
0b11110000 —> -16 NO OK!!!!
240 no existe en el código complemento a 2 de 8 bits. Operación provoca overflow
❖ MIPS soporta aritmética con signo y sin signo!

❖ add y addi son con signo, y provocan una excepción de overflow si resultado
excede el código.!
❖ addu y addiu hacen exactamente la misma operación, pero no generan excepción!
❖ addiu extiende la constante a 32 bits repitiendo ceros hacia la izquierda
Cómo traducimos expresiones más complejas?!
Si expresión tiene más de dos operados origen, usar temporales!
!
Ejemplo:! ! a = b - c + d - 87;! ! // en C!
Implementar en assembly como múltiples instrucciones!

Si a, b, c, d están asociados a $s0, $s1, $s2, $s3:!
!
! ! ! ! sub $t0, $s1, $s2! ! # temp = b - c!
! ! ! ! add $t0, $t0, $s3! ! # temp = temp + d!
! ! ! ! addi $s0, $t0, -87!! # a = temp - 87!
!
En general, una línea de código en C puede generar múltiples
líneas de código en assembly
El registro $zero
❖ La ISA define que el registro $zero siempre contiene el valor “cero”!
❖ Cualquier asignación a $zero no tiene efecto!
❖ Útil para sintetizar algunas instrucciones a partir de instrucciones aritméticas
existentes!
❖ Ejemplos
a = b;! ! ! ! ! // En C!
add $s0, $s1, $zero! ! # En MIPS, a y b asignadas a $s0 y $s1
a = 25;! ! ! ! ! // En C!
addi $s0, $zero, 25! ! # En MIPS, a asignada a $s0
;! ! ! ! ! ! // En C!
add $zero, $zero, $zero! # En MIPS. Esta instrucción se llama “nop” en otras ISA
Multiplicación y división
❖ Resultado de multiplicación y división entera es de 64 bits!!!
❖ El producto de dos números de 32 bits usa 64 bits!
❖ La división de dos números de 32 bits genera un cuociente y un resto, ambos de 32 bits!
❖ Resultados se almacenan en registros HI y LO. Instrucciones mfhi, mflo, mthi, mtlo
transfieren datos entre registros generales y registros HI y LO
a * b;! ! ! ! // En C!
mult $s0, $s1! ! ! # mitad más significativa en HI, menos significativa en LO
c = a/b;! ! ! ! // En C!
d = a%b!
div $s0, $s1! ! ! # cuociente en LO, resto en HI!
mflo $s2!
mfhi $s3
c = a*b;! ! ! ! // En C!
mul $s2, $s0, $s1! ! # mitad menos significativa en LO, más significativa se pierde
También existe multu y divu (no es lo mismo que mult y div). No existe multi ni divi
Ejemplo
❖ Generar código assembly para la siguiente expresión en C. Asuma que
todas las variables son de tipo “int”
a = (a + 4) * (b + 3) - (c - 8)/126;
Instrucciones lógicas
❖ Tratan a contenido de registros como vector de bits en vez de números!
❖ Usadas para!
❖ Manipular bits individuales (máscaras)!
❖ Interacción con variables lógicas externas en microcontroladores!
❖ Imágenes y códigos!
❖ Compresión de datos!
❖ Simplificar operaciones aritméticas!
❖ Ej. Multiplicar por potencia de dos es equivalente a desplazar
operando a la izquierda
Instrucciones lógicas
and $t1, $t2, $t3 00110110 $t2 or $t1, $t2, $t3 00110110 $t2
11010100 $t3 11010100 $t3
00010100 $t1 11110110 $t1
xor $t1, $t2, $t3 00110110 $t2 andi $t1, $t2, 10 00110110 $t2
11010100 $t3 00001010
11100010 $t1 00000010 $t1
Constante se extiende en ceros
Desplazamientos de bits
sll $t1, $t2, 3 00000111 $t2 (7) srl $t1, $t2, 3 10111101 $t2 (189) (-67)
00010111 $t1 (23) (23)

00111000 $t1 (56)
Equivalente a multiplicación por 23 Equivalente a división por 23?

Sólo para números sin signo
sra $t1, $t2, 3 10111101 $t2 (-67) sra $t1, $t2, 3 00111101 $t2 (61)
11110111 $t1 (-9) 00000111 $t1 (7)
!n "
“Equivalente” a división entera con signo. !# 2m "$
Desplazamiento variable:!! sllv $t1, $t2, $t3!

! ! ! ! ! ! ! srlv $t1, $t2, $t3
Ejercicios
Instrucciones de transferencia de datos
❖ Instrucciones aritméticas y lógicas operan con datos en registros!
❖ ¿Pero cómo hacemos llegar los datos a un registro?!
❖ Instrucción de transferencia de datos permite copiar un dato a un registro. Necesita
especificar registro (ej. $t0), y dato!
❖ Modo de direccionamiento indica cómo se especifica el dato. Algunos ya los hemos visto:!
❖ Inmediato: valor del dato en instrucción!
❖ ori $t0, $zero, 125 # (li $t0, 125)!
❖ Registro directo: valor del dato en un registro indicado en instrucción!
❖ ori $t0, $zero, $t8 # (move $t0, $t8)!
❖ En los otros modos de direccionamiento, el dato está en memoria. Cómo especificar en
qué dirección?
Instrucciones de acceso a memoria en MIPS
❖ Load: Transfiere dato de memoria a registro.!
❖ lw copia una palabra de 32b de memoria a registro.!
❖ Store: Transfiere dato de registro a memoria.!
❖ sw copia una palabra de 32b de registro a memoria!
❖ Modo de direccionamiento único: Base más desplazamiento!
❖ Dirección de memoria se especifica como contenido de un registro sumado a
un desplazamiento constante con signo de 16 bits.!
❖ Desplazamiento ≠ 0 usado para accesar arreglos o estructuras
lw $t0, 0($s2) # $t0 <— M[$s2 + 0]
sw $t0, 4($s2) # M[$s2 + 4] <— $t0
$s2 es el registro base, 0 o 4 es el desplazamiento

lw: lectura de memoria
Memoria
1000
1004
$t0 1008 1008 100
+4 1012 25
$t1 245
100 1016
1020
$t2 1208
25 1024
lw $t1, 0($t0)
lw $t2, 4($t0)
sw: escritura en memoria
Memoria
1000
1004
$t0 1008 1008 245
100
+4 1012 1208
25
$t1 245 1016
1020
$t2 1208 1024
sw $t1, 0($t0)
sw $t2, 4($t0)
Otras instrucciones load y store
sw $t3, 500($t2) # Mem[500+$t2] ← $t3. Almacena 32b
sh $t3, 500($t2) # Mem[500+$t2] ← $t3. Almacena 16b
sb $t3, 500($t2) # Mem[500+$t2] ← $t3. Almacena 8b
!
lw $t3, 500($t2) # $t3 ← Mem[500+$t2]. Carga 32b
lh $t3, 500($t2) # $t3 ← Mem[500+$t2]. Carga 16b
lhu $t3, 500($t2) # $t3 ← Mem[500+$t2]. Carga 16b sin signo
lb $t3, 500($t2) # $t3 ← Mem[500+$t2]. Carga 8b
lbu $t3, 500($t2) # $t3 ← Mem[500+$t2]. Carga 8b sin signo
lui $t3, 4097 # $t331…16 ← 409716b. Carga constante de 16b en
# mitad más significativa de registro, escribe ceros en
# mitad menos significativa
Pseudoinstrucciones
❖ Algunas instrucciones comunes en otros ISA pueden implementarse a partir de
instrucciones existentes en el ISA de MIPS!
❖ Algunos de estos casos son tan comunes que el ensamblador permite escribirlas
como si fueran instrucciones, y las traduce a instrucciones del ISA (usando a veces el
registro $at)!
❖ “Pseudoinstrucciones”, porque pueden usarse en assembly, pero no existen en el
lenguaje de máquina (binario)
move $t4, $t5 # $t4 ← $t5
# or $t4, $zero, $t5
!
li $t4, 100 # $t4 ← 100
# ori $t4, $zero, 100
!
la $t4, LABEL # $t4 ← LABEL LABEL: Texto que representa una constante en el
# lui $t4, LABEL16bsuperiores programa. Puede ser un número o una dirección
# ori $t4, $t4, LABEL16binferiores de memoria.
!
mul $t4, $t5, 10 # $t4 ← $t5 x 10
# ori $at, $zero, 10
# mul $t4, $t5, $at
Ejemplo # Dirección de memoria de ‘a’ en rótulo DIR_A
# Dirección de memoria de ‘b’ en rótulo DIR_B
# Dirección de memoria ‘acum’ en rótulo DIR_ACUM
!
la $t6, DIR_A # cargar dirección de a
la $t7, DIR_B # cargar dirección de b
!
lw $t0, 0($t6) # leer a
lw $t1, 0($t7) # leer b
!
mult $t2, $t0, $t1 # t2 = a * b
int a, b, acum; !
… la $t8, DIR_ACUM # cargar dirección de acum
lw $t3, 0($t8) # leer acum
acum = acum + a * b; !
add $t3, $t3, $t2 # $t3 = acum + a * b
sw $t3, 0($t8) # guardar acum
a
Memoria
1000 10 DIR_A
1004
b $t6 1000 $t0 10 $t3 70
50
1008
1012 2 DIR_B
$t7 1012 $t1 2
1016
1020
$t8 1024 $t2 20
1024 70
50 DIR_ACUM
acum
Ejemplo
# Dirección de memoria de ‘c1’ en rótulo DIR_C1
# Dirección de memoria de ‘c2’ en rótulo DIR_C2
typedef struct { # Dirección de memoria de ‘dist’ en rótulo DIR_DIST
int x; !
int y; la $t6, DIR_C1 # cargar dirección de c1
la $t7, DIR_C2 # cargar dirección de c2
} coord; !
! lw $t0, 0($t6) # leer c1.x
coord c1, c2; lw $t1, 0($t7) # leer c2.x
sub $t2, $t1, $t0 # t2 = c2.x – c1.x
… abs $t3, $t2 # t3 = abs(c2.x – c1.x)
int dist; !
dist = abs(c2.x – c1.x) + lw $t0, 4($t6) # leer c1.y
lw $t1, 4($t7) # leer c2.y
abs(c2.y – c1.y); sub $t2, $t1, $t0 # t2 = c2.y – c1.y
abs $t4, $t2 # t4 = abs(c2.y – c1.y)
!
Memoria add $t3, $t3, $t4 # t3 = abs(c2.x – c1.x) +
DIR_C1 c1.x # abs(c2.y – c1.y)
!
DIR_C1 + 4 c1.y la $t6, DIR_DIST # cargar dirección de dist
Direcciones de sw $t3, 0($t6) # dist = abs(c2.x – c1.x) +
DIR_C2 c2.x memoria # abs(c2.y – c1.y)
DIR_C2 + 4 c2.y
DIR_DIST dist
En general: modos de direccionamiento
❖ Disponibles en otras ISA como VAX, Intel, ARM!
❖ Registro directo: R3!
❖ Inmediato: 25!
❖ Base + desplazamiento: M[R3 + 10000]!
❖ Memoria directo (absoluto): M[10000]!
❖ Registro indirecto: M[R3]!
❖ Base + índice: M[R3 + R4]!
❖ Índice escalado: M[R3 + R4*d + 10000]!
❖ Autoincremento: M[R3++]!
❖ Autodecremento: M[R3--]!
❖ Memoria indirecto: M[ M[R3] ]
Limitaciones de MIPS
❖ Modos de direccionamiento menos generales que otras ISA!
❖ Menos modos de direccionamiento disponibles !
❖ Operandos inmediatos (desplazamiento) limitados a 16b!
❖ Mediciones en uso de VAX en los años ’80 mostraron que:!
❖ Modos registro directo, inmediato, directo, registro indirecto y base +
desplazamiento constituyen el 88% de todos los usos!
❖ Inmediato de 16b suficiente 75%-80% del tiempo!
❖ Desplazamiento de 16b suficiente 99% del tiempo!
❖ Estas estadísticas fueron decisivas en el diseño del ISA de MIPS y otros
procesadores RISC de la época
Modos de direccionamiento en ARM
Name! ! ! Alternative Name! ARM Examples!
------------------------------------------------------------------------!
Register to register Register direct! ! MOV R0, R1!
------------------------------------------------------------------------!
Absolute! ! Direct! ! ! LDR R0, MEM!
------------------------------------------------------------------------!
Literal! ! ! Immediate! ! MOV R0, #15!
! ! ! ! ! ! ADD R1, R2, #12!
------------------------------------------------------------------------!
Indexed, base! ! Register indirect ! LDR R0, [R1]!
------------------------------------------------------------------------!
Pre-indexed,! ! Register indirect ! LDR R0, [R1, #4]!
base with displacement with offset!
------------------------------------------------------------------------!
Pre-indexed,! ! Register indirect! LDR R0, [R1, #4]!!
autoindexing! ! pre-incrementing!
------------------------------------------------------------------------!
Post-indexing,!! Register indirect! LDR R0, [R1], #4!
autoindexed! ! post-increment!
------------------------------------------------------------------------!
Double Reg indirect! Register indirect! LDR R0, [R1, R2]!
! ! ! Register indexed!
------------------------------------------------------------------------!
Double Reg indirect! Register indirect! LDR R0, [R1, r2, LSL #2]!
with scaling! ! indexed with scaling!
------------------------------------------------------------------------!
Program counter relative! ! ! LDR R0, [PC, #offset]!
------------------------------------------------------------------------!
Modos de direccionamiento en Intel x86
Ejemplos:!
add eax, 4
add ebx, [eax]
add ebx, LABEL[eax]
add ebx, LABEL[eax*4]
add ecx, [eax+ebx]
add ecx, [eax+ebx*4]
Control de flujo
❖ Recordar: registro PC almacena dirección de siguiente
instrucción a ejecutar!
❖ Después de cada instrucción aritmético/lógica o
load/store, PC <— PC + 4!
❖ Instrucciones de control de flujo permiten cambiar el
flujo del programa!
❖ Salto asigna un nuevo valor a PC
Tipos de salto
❖ Condicionalidad!
❖ Saltos incondicionales saltan cada vez que se ejecutan!
❖ Equivalente a instrucción goto en C!
❖ Saltos condicionales saltan sólo si se cumple una condición, si no, PC <— PC + 4!
❖ Usados para implementar if-else, while, for, switch!
❖ Ejemplo de condición: contenido de registro igual a cero!
❖ Dirección destino!
❖ Saltos absolutos especifican dirección destino como una constante!
❖ Saltos relativos especifican un desplazamiento respecto de dirección actual!
❖ Instrucciones de salto más comunes!
❖ jump: absoluto e incodicional!
❖ branch: relativo y condicional
Saltos en MIPS
❖ Saltos incondicionales (jump)!
❖ Instrucción usa rótulo, ensamblador calcula dirección destino!
! ! j DESTINO # PC = DESTINO
❖ Salto absoluto a procedimiento (jump-and-link)!

❖ Almacenan dirección de retorno en registro $ra ($31)!
! ! jal DESTINO # $ra = PC; PC = DESTINO
❖ PC almacena dirección de siguiente instrucción a ejecutar!
❖ Saltos indexados: saltar a dirección almacenada en registro!
❖ Usado para retorno de procedimientos y estructuras switch!
! ! jr $ra # PC = $ra
Saltos en MIPS
❖ Saltos condicionales (branch)!
❖ Assembly especifica dirección destino como un rótulo (label)!
❖ Ensamblador calcula desplazamiento y lo reemplaza en el branch
beq $t1,$t2,DESTINO # if ($t1 == $t2) PC = DESTINO

bgez $t1, DESTINO # if ($t1 >= 0) PC = DESTINO
bgtz $t1, DESTINO # if ($t1 > 0) PC = DESTINO
blez $t1, DESTINO # if ($t1 <= 0) PC = DESTINO
bltz $t1, DESTINO # if ($t1 < 0) PC = DESTINO
bne $t1,$t2,DESTINO # if ($t1 != $t2) PC = DESTINO
b DESTINO # PC = DESTINO (pseudoinstrucción)
¿Cómo especificar más condiciones?
❖ Instrucciones branch de MIPS especifican pocas condiciones!
❖ Instrucciones de comparación modifican registro en base a condición!
❖ Otras ISA (ej. Intel, ARM) usan códigos de condición
slt $t1,$t2,$t3 # if ($t2 < $t3) $t1= 1 else $t1 = 0

sltu $t1,$t2,$t3 # if ($t2 < $t3) $t1 = 1 else $t1 = 0 (sin signo)
slti $t1, $t2, 100 # if ($t2 < 100) $t1 = 1 else $t1 = 0
sltiu $t1, $t2, 100 # if ($t2 < 100) $t1 = 1 else $t1 = 0 (sin signo)
!
Pseudoinstrucciones (se traducen en más de una instrucción de máquina):
!
seq $t1, $t2, $t3 $if ($t2 == $t3) $t1 = 1 else $t1 = 0
sne $t1, $t2, $t3 $if ($t2 != $t3) $t1 = 1 else $t1 = 0
sgt $t1, $t2, $t3 $if ($t2 > $t3) $t1 = 1 else $t1 = 0
sge $t1, $t2, $t3 $if ($t2 >= $t3) $t1 = 1 else $t1 = 0
sle $t1, $t2, $t3 $if ($t2 <= $t3) $t1 = 1 else $t1 = 0
!
Y otras…
Ejemplo: if-else
!
Código assembly para el siguiente código C:
! li $s0, 10 # a = 10
int a = 10, b = 5; li $s1, 5 #b=5
int c;
… sle $t3, $s0, $s1 # a <= b ?
if (a > b) bne $t3, $zero, ELSE # if a <= b goto ELSE
c = a – b;
else sub $s2, $s0, $s1 #c=a-b
c = b – a; b FIN_IF # goto FIN_IF
c = c + 10; ELSE: sub $s2, $s1, $s0 #c=b-a
FIN_IF: addi $s2, $s2, 10 # c = c + 10
Versión con goto:
int a = 10, b = 5;
if (a <= b) goto ELSE;
c = a – b;
goto FIN_IF;
ELSE: c = b – a;
FIN_IF: c = c + 10;
Suponer que compilador asigna:

a à $s0
b à $s1
c à $s2
Ejemplo: do-while
Código assembly para el
siguiente código C: li $t0, 0 # i = 0;
! li $t1, 0 # sum = 0
i = 0; la $t2, SUM # $t2 = dirección de sum
sum = 0; sw $t1, 0($t2) # sum = 0
do { LOOP: la $t3, A # $t3 = dirección a[0]
sum = sum + a[i] * b[i]; la $t4, B # $t4 = dirección b[0]
i++;
} while (i < 100) sll $t5, $t0, 2 # $t5 = i*4
add $t6, $t3, $t5 # $t6 = dirección a[i]
lw $t7, 0($t6) # $t7 = a[i]
Versión con goto: add $t6, $t4, $t5 # $t6 = dirección b[i]
! lw $t8, 0($t6) # $t8 = b[i]
int i = 0;
mul $t8, $t7, $t8 # $t8 = a[i]*b[i]
int sum = 0
add $t1, $t1, $t8 # $t1 = sum + a[i]*b[i]
LOOP: sum = sum + a[i] * b[i];
i++; la $t2, SUM
if (i < 100) goto LOOP; sw $t1, 0($t2) # sum = sum + a[i] * b[i]
Vectores a y b y variable sum comienzan a addi $t0, $t0, 1 #i=i+1

partir de direcciones de memoria indicadas
slti $t7, $t0, 100 # i < 100?
por rótulos A, B y SUM. Memoria debe
actualizarse. bne $t7, $zero, LOOP
Asumir que variable i no es relevante
después del segmento de código ¿Posible mejorar código?
Ejemplo: do-while (mejorado)
Código assembly para el
siguiente código C: li $t0, 0 # i = 0; ($t0 = 4*i)
! li $t1, 0 # sum = 0
i = 0; la $t3, A # $t3 = dirección a[0]
sum = 0; la $t4, B # $t4 = dirección b[0]
do {
sum = sum + a[i] * b[i]; LOOP: add $t6, $t3, $t0 # $t6 = dirección a[i]
i++; lw $t7, 0($t6) # $t7 = a[i]
} while (i < 100)
add $t6, $t4, $t0 # $t6 = dirección b[i]
lw $t8, 0($t6) # $t8 = b[i]
Versión con goto:
mul $t8, $t7, $t8 # $t8 = a[i]*b[i]
! add $t1, $t1, $t8 # sum = sum + a[i]*b[i]
int i = 0;
int sum = 0 addi $t0, $t0, 4 #i=i+1
LOOP: sum = sum + a[i] * b[i];
slti $t7, $t0, 400 # i < 100?
i++;
bne $t7, $zero, LOOP
if (i < 100) goto LOOP;
la $t2, SUM
Vectores a y b y variable sum comienzan a
partir de direcciones de memoria indicadas
sw $t1, 0($t2) # sum = sum + a[i] * b[i]
por rótulos A, B y SUM. Memoria debe
actualizarse.
Asumir que variable i no es relevante
después del segmento de código
Ejemplo: while
int i;
li $t0, 0 # i = 0;
int a[100], b[100]
la $t1, A
i = 0;
la $t2, B
while (i < 100) {
tmp = a[i]; LOOP: slti $t7, $t0, 100 # i < 100?
a[i] = b[i]; beq $t7, $zero, FIN # if (i >= 100)
b[i] = tmp; sll $t3, $t0, 2 # $t3 = i*4
i++; add $t4, $t1, $t3 # $t4 = dirección A[i]
} lw $t5, 0($t4) # tmp = A[i]
Versión con goto: add $t6, $t2, $t3 # B[i]
! lw $t7, 0($t6)
int i; sw $t7, 0($t4) # A[i] = B[i]
int a[100], b[100]
i = 0; sw $t5, 0($t6) # B[i] = tmp
LOOP: if (i >= 100) goto FIN; addi, $t0, $t0, 1 #i=i+1
tmp = a[i];
a[i] = b[i]; b LOOP # beq $0, $0, LOOP
b[i] = tmp;
FIN: …
i++;
goto LOOP;
}
FIN: …
Variable i asignada a registro $t0; tmp y otros temporales asignados a registros $t3 - $t7.
Vectores a y b almacenados en memoria a partir de direcciones indicadas por rótulos A y B
Ejemplo: Llamado a función
la $a0, A # $a0 = &(a[0])
la $a1, B # $a1 = &(b[0])
int a[100], b[100]
li $a2, 100 # $a2 = 100
…
jal PUNTO # resultado en $v0
res = punto(a, b, 100);
la $t0, RES
…
sw $v0, 0($t0)
!
int punto(int v1[], int v2[], int n)
…
{
int i = 0; PUNTO: li $t0, 0 #i=0
int suma = 0; li $v0, 0 # suma = 0
do { WHILE: sll $t1, $t0, 2 # $t1 = i*4
suma = suma + v1[i] * v2[i]; add $t2, $a0, $t1 # $t2 = &(v1[i])
i++; lw $t3, 0($t2) # $t3 = v1[i]
} while (i < n) add $t2, $a1, $t1 # $t2 = &(v2[i])
return suma; lw $t4, 0($t2) # $t4 = v2[i]
} mult $t3, $t3, $t4 # $t3 = v1[i] * v2[i]
add $v0, $v0, $t3 # suma = suma +…
Recordar convención estándar de uso de registros MIPS:   addi $t0, $t0, 1 #i=i+1
Argumentos en $a0-$a3
Valor de retorno en $v0 slt $t3, $t0, $a2 # i < n?
No es necesario salvar valor de $t0-$t8 antes de usarlos bne $t3, $zero, WHILE
jr $ra
Ejemplo: strlen
int strlen(char *str) STRLEN: li $v0, 0 # len = 0
{
int len = 0; WHILE: lb $t0, 0($a0) # $t0 = *str
! beq $t0, $zero, FIN_W # if (*str == 0) goto FIN_W
while (*str != 0) { addi $a0, $a0, 1 # str = str + 1
str = str + 1; addi $v0, $v0, 1 # len = len + 1
len = len + 1;
} b WHILE # goto WHILE
!
return len; FIN_W: jr $ra # return len
}
Recordar convención estándar de uso de registros MIPS:  

Argumentos en $a0-$a3
Valor de retorno en $v0
No es necesario salvar valor de $t0-$t8 antes de usarlos
Ejemplo: strcpy
char *strcpy(char *dest, char *src) STRCPY: move $v0, $a0 # orig_dest = dest
{
char *orig_dest = dest; WHILE: lb $t0, 0($a1) # $t0 = *src
! beq $t0, $zero, FIN_W # if (*src == 0) goto FIN_W
while (*src != 0) {
*dest = *src; sb $t0, 0($a0) # *dest = *src
dest = dest + 1; addi $a0, $a0, 1 # dest = dest + 1
src = src + 1; addi $a1, $a1, 1 # src = src + 1
}
*dest = 0; b WHILE
!
return orig_dest; FIN_W: sb $zero, 0($a0) # *dest = 0
}
jr $ra
Ejercicio en clases
int streq(char *s1, char *s2)
{
char tmp;
do {
tmp = *s1;
if (tmp != *s2)
return 0;
s1++;
s2++;
} while (tmp != 0);
return 1;
}
Otras instrucciones
❖ Llamados al sistema operativo (syscall)!
❖ Generación de excepciones (trap, break)!
❖ Retorno de excepciones (eret)!
❖ No-operación (nop) (pseudoinstrucción)!
❖ Instrucciones al TLB para manejo de memoria virtual!
❖ Acceso no alineado a memoria
Códigos de condición en Intel x86
❖ Almacenados en registro PSW!
❖ ZF: cero!
❖ CF: carry!
❖ SF: negativo!
❖ OF: overflow!
❖ PF: paridad!
❖ Afectados por instrucciones artimético/lógicas o de comparación!
❖ Utilizados en instrucciones de salto (JUMP) y en instrucciones load/store (MOV)
Instrucciones condicionales en ARM
❖ Basados en bits de condición en registro CPSR!
❖ N: Resultado de última operación fue negativo!
❖ Z: Resultado de última operación fue cero.!
❖ C: Carry o borrow de última suma o resta (overflow sin signo)!
❖ V: Overflow (con signo)!
❖ Modificados como resultado de operaciones aritméticas y lógicas!
❖ Instrucciones de comparación pueden modificar bits de condición sin
generar resultados!
❖ Ej. CMP R4, #0
❖ Varias condiciones posibles
Code! Suffix!! Description! ! ! ! ! ! ! ! Flags!

0000! EQ! ! ! Equal / equals zero! ! ! ! ! ! Z!
0001! NE! ! ! Not equal! ! ! ! ! ! ! ! ! !Z!
0010! CS / HS! Carry set / unsigned higher or same! C!
0011! CC / LO! Carry clear / unsigned lower! ! ! !C!
0100! MI! ! ! Minus / negative! ! ! ! ! ! ! N!
0101! PL! ! ! Plus / positive or zero! ! ! ! ! !N!
0110! VS! ! ! Overflow! ! ! ! ! ! ! ! ! V!
0111! VC! ! ! No overflow! ! ! ! ! ! ! ! !V!
1000! HI! ! ! Unsigned higher! ! ! ! ! ! ! C and !Z!
1001! LS! ! ! Unsigned lower or same! ! ! ! ! !C or Z!
1010! GE! ! ! Signed greater than or equal! ! ! N == V!
1011! LT! ! ! Signed less than! ! ! ! ! ! ! N != V!
1100! GT! ! ! Signed greater than! ! ! ! ! ! !Z and (N == V)!
1101! LE! ! ! Signed less than or equal! ! ! ! Z or (N != V)!
1110! AL! ! ! Always (default)! ! ! ! ! ! ! any
❖ Saltos condicionales saltan basados en bits de condición!
❖ beq LABEL!
❖ bne LABEL!
❖ bge LABEL!
❖ blt LABEL!
❖ etc.!
❖ Pero casi todas las instrucciones también se pueden ejecutar en forma condicional!
❖ subgt R4, R1, R10!
❖ sublt R1, R2, R3!
❖ addhi R4, R10, E2!
❖ moveq R4, #10!
❖ Ejecución condicional (o predicada) es poderosa cuando se realiza especulación por software
o hardware, y está presente en otras ISA
Registros son recurso limitado
❖ Dirección de retorno en $ra!
❖ Qué hacer si se va a llamar a otro procedimiento? !
❖ Paso de argumentos a función en $a0 - $a3!
❖ Qué pasa cuando hay más argumentos?!
❖ Valor de retorno en $v0 - $v1!
❖ Qué pasa cuando se retorna una estructura de más de dos palabras?!
❖ Registros para variables locales $s0 - $s7!
❖ Qué hacer cuando se quiere escribir sobre ellos?!
❖ Registros temporales $t0 - $t9!
❖ Qué hacer cuando se quiere preservar su valor antes de invocar a un procedimiento?
Todos estos valores deben respaldarse en memoria. Pero cómo y dónde?
Alternativa 1: Estática
Almacenar datos en área de
memoria asociada a procedimiento
PROC1: move $t0, $a0 $ra

…
la $s0, PROC1_MEM PROC1_MEM $t0
sw $t0, 0($s0) Direcciones
sw $ra, 4($s0) de memoria
jal PROC2
lw $t0, 0($s0)
lw $ra, 4($s0)
…
jr $ra
!
Ahora PROC2 puede sobreescribir
$t0 y $ra sin problemas
Pero qué pasaría si PROC1 fuera recursivo?
Alternativa 2: Stacks
❖ Definir un área de memoria asociada a cada activación del procedimiento!
❖ Llamado a procedimiento crea una nueva área de memoria sobre la anterior!
❖ Retorno de procedimiento retrocede al área anterior!
❖ Estructura de datos asimila una pila (stack), también llamada LIFO (last in, first out)
A:
call B A
B: A B
call C
C: A B C
ret
B:
A B
ret
A: A
Soporte ISA para stacks
❖ Stack pointer (SP)!
FP
❖ Apunta al tope del stack!
❖ Utilizado para agregar y remover datos del stack!
Argumentos
❖ Operaciones PUSH y POP!
❖ Frame pointer (FP)!
❖ Apunta a base del bloque de activación (stack frame)!
❖ Usado para accesar variables locales y argumentos sin Registros salvados
removerlos del stack! por el llamado
❖ Algunos compiladores utilizan sólo un registro!
❖ Soporte ISA para stacks!
❖ En el lenguaje de máquina: VAX, Intel! Variables
locales
❖ Defineregistros específicos para SP y FP, e instrucciones
para mover datos entre stack y registros!
❖ Por convención de software: MIPS! Evaluación de
❖ Registros
expresiones
$fp y $sp! (dinámico)
❖ Soporte mínimo: jal, jr
SP
Ejemplo: Cadena de llamados
Estructura de código
Cadena de llamados
p1(…)
{
• p1
•
p2(); p2(…)
• { p2
• • • •
} p3();
• • • p3 p3
p3();
• • •
} p3(…) p3
{
•
• p3
p3();
•
Procedimiento p3 es recursivo •
}
•
•
Frame! •
Pointer!
Cadena de llamados $fp !
p1(…) p1
{ Stack!
• p1 Pointer!
• $sp
p2();
•
•
}
•
•
•
Cadena de llamados !
p2(…) p1
{ Frame!
• • • p1 Pointer!
p3(); $fp !
• • • p2
p3(); p2 Stack!
• • • Pointer!
} $sp
•
•
•
p3(…) p1
{
• p1
•
!
p2
p3(); Frame!
• p2
Pointer!
• $fp !
} p3 p3
Stack!
Pointer!
$sp
•
•
•
p3(…) p1
{
• p1
•
!
p2
p3();
• p2
• !
} p3 p3
Frame!
Pointer!
p3 $fp !
p3
Stack!
Pointer!
$sp
•
•
•
p3(…) p1
{
• p1
•
!
p2
p3();
p2
•
• !
} p3 p3
p3 !
p3
Frame!
p3 Pointer!
$fp !
p3
Stack!
Pointer!
$sp
•
•
•
p3(…) p1
{
• p1
•
!
p2
p3();
p2
•
• !
} p3 p3
Frame!
Pointer!
p3 $fp !
p3
Stack!
p3 Pointer!
$sp
•
•
•
p3(…) p1
{
• p1
•
!
p2
p3(); Frame!
p2
• Pointer!
• $fp !
} p3 p3
Stack!
Pointer!
p3 $sp
p3
•
•
•
p2(…) p1
{ Frame!
p3(); $fp !
• • • p2
p3(); p2 Stack!
} $sp
p3
p3
p3
•
•
•
p3(…) p1
{
• p1
•
!
p2
• Frame!
p2
• Pointer!
} $fp !
p3 p3 p3
Stack!
Pointer!
p3 $sp
p3
•
•
•
p2(…) p1
{ Frame!
p2(); $fp !
• • • p2
p2(); p2 Stack!
} $sp
p3 p3
p3
p3
•
•
Frame! •
Pointer!
Cadena de llamados $fp !
p1(…) p1
{ Stack!
• p1 Pointer!
• $sp
p2(); p2
•
•
} p3 p3
p3
p3
Ejemplo: Factorial recursivo
int factorial(int n)
{
if (n == 0)
return 1;
else
return n * factorial(n-1);
}
int factorial(int n) FACT: bne $a0, $0, L1 # saltar si n != 0
{ li $v0, 1 # retornar 1
jr $ra
if (n == 0)
return 1;
else
return n * factorial(n-1);
}
dir
$sp
$a0
$fp
$ra
$fp
jr $ra
if (n == 0) !
return 1; L1: sw $fp, -4($sp) # salvar valor de $fp en stack
else addi $fp, $sp, -4 # $fp apunta a base de nuevo frame
return n * factorial(n-1); sw $ra, -4($fp) # almacenar $ra en el stack
} sw $a0, -8($fp) # almacenar n en el stack
addi $sp, $fp, -8 # $sp apunta a nuevo tope de stack
$sp $a0 dir

$ra
$fp $fp
$sp
$a0
$fp
$ra
$fp
jr $ra
if (n == 0) !
addi $a0, $a0, -1 # n – 1

jal FACT # resultado en $v0
!
$sp $a0 dir

$ra
$fp $fp
$a0
$ra
$fp
jr $ra
if (n == 0) !
addi $a0, $a0, -1 # n – 1

!
addi $sp, $fp, 4 # restaurar $sp
lw $a0, -8($fp) # restaurar n
lw $ra, -4($fp) # restaurar $ra
lw $fp, 0($fp) # restaurar $fp
!
$sp $a0 dir

$ra
$fp $fp
$sp
$a0
$fp $ra
$fp
li $v0, 1 # retornar 1
{
jr $ra
if (n == 0) !
addi $a0, $a0, -1 # n – 1

!
addi $sp, $fp, 4 # restaurar $sp
!
mul $v0, $v0, $a0 # n * fact(n-1)
jr $ra
$a0 dir
$ra
$fp
$sp
$a0
$fp $ra
$fp
Ejemplo: FACT(3)
FACT: bne $a0, $0, L1 # saltar si n != 0
jr $ra
!
L1: sw $fp, -4($sp) # salvar valor de $fp en stack
addi $fp, $sp, -4 # $fp apunta a base de nuevo frame
sw $ra, -4($fp) # almacenar $ra en el stack
sw $a0, -8($fp) # almacenar n en el stack
addi $a0, $a0, -1 # n – 1

!
L2: addi $sp, $fp, 4 # restaurar $sp
dir
!
mul $v0, $v0, $a0 # n * fact(n-1)
jr $ra
$sp SP_ANT
$fp FP_ANT
$sp SP_ANT $fp FP_ANT $ra RA_ANT $a0 3 $v0 V0_ANT
Ejemplo: FACT(3)
jr $ra
!
addi $a0, $a0, -1 # n – 1

!
$sp 3 SP_1
RA_ANT
! $fp FP_ANT FP_1
mul $v0, $v0, $a0 # n * fact(n-1) SP_ANT
jr $ra
FP_ANT
$sp SP_1 $fp FP_1 $ra RA_ANT $a0 2 $v0 V0_ANT
Ejemplo: FACT(3)
jr $ra
!
addi $a0, $a0, -1 # n – 1

!
$sp 3 SP_1
RA_ANT
! $fp FP_ANT FP_1
jr $ra
FP_ANT
$sp SP_1 $fp FP_1 $ra L2 $a0 2 $v0 V0_ANT
Ejemplo: FACT(3)
jr $ra
!
addi $a0, $a0, -1 # n – 1 $sp 2 SP_2

jal FACT # resultado en $v0 L2
!
L2: addi $sp, $fp, 4 # restaurar $sp $fp FP_1 FP_2
lw $a0, -8($fp) # restaurar n 3 SP_1
RA_ANT
! FP_ANT FP_1
jr $ra
FP_ANT
Ejemplo: FACT(3)
jr $ra
!
addi $a0, $a0, -1 # n – 1 $sp 2 SP_2

!
L2: addi $sp, $fp, 4 # restaurar $sp $fp FP_1 FP_2
RA_ANT
! FP_ANT FP_1
jr $ra
FP_ANT
Ejemplo: FACT(3)
jr $ra
!
$sp 1 SP_3
sw $a0, -8($fp) # almacenar n en el stack L2
$fp FP_2 FP_3
addi $a0, $a0, -1 # n – 1 2 SP_2

!
L2: addi $sp, $fp, 4 # restaurar $sp FP_1 FP_2
RA_ANT
! FP_ANT FP_1
jr $ra
FP_ANT
Ejemplo: FACT(3)
jr $ra
!
$sp 1 SP_3
$fp FP_2 FP_3
addi $a0, $a0, -1 # n – 1 2 SP_2

!
RA_ANT
! FP_ANT FP_1
jr $ra
FP_ANT
$sp SP_3 $fp FP_3 $ra L2 $a0 0 $v0 1
Ejemplo: FACT(3)
jr $ra
!
1 SP_1
addi $sp, $fp, -8 # $sp apunta a nuevo tope de stack FP_2 FP_1
addi $a0, $a0, -1 # n – 1 $sp 2 SP_2

! $fp
RA_ANT
! FP_ANT FP_1
jr $ra
FP_ANT
$sp SP_2 $fp FP_2 $ra L2 $a0 1 $v0 1
Ejemplo: FACT(3)
jr $ra
!
1 SP_1
FP_2 FP_1
addi $a0, $a0, -1 # n – 1 2 SP_2

!
lw $a0, -8($fp) # restaurar n $sp 3 SP_1
RA_ANT
! $fp FP_ANT FP_1
jr $ra
FP_ANT
$sp SP_1 $fp FP_1 $ra L2 $a0 2 $v0 2
Ejemplo: FACT(3)
jr $ra
!
1 SP_1
addi $sp, $fp, -8 # $sp apunta a nuevo tope de stack FP_2 FP_1
addi $a0, $a0, -1 # n – 1 2 SP_2

!
RA_ANT
! FP_ANT FP_1
mul $v0, $v0, $a0 # n * fact(n-1) $sp SP_ANT
jr $ra
$fp FP_ANT
$sp SP_ANT $fp FP_ANT $ra RA_ANT $a0 3 $v0 6
Ejercicio en clases
int fib(int n)
{
if (n == 0)
return 0;
if (n == 1)
return 1;
return fib(n-1) + fib(n-2);
}
Excepciones
❖ Condiciones especiales que cambian el flujo de

ejecución normal del programa!
❖ Tipos de excepciones!
❖ Interrupción!
❖ Generada en forma externa al procesador, típicamente por
dispositivo de E/S como interfaz de red o disco!
❖ Trap o interrupción por software!
❖ Efecto (implícito o explícito) de ejecución de instrucción!
❖ Ej. División por cero, acceso ilegal a memoria, instrucción inválida, syscall,
break.
Atención de excepciones
❖ Típicamente!
❖ Almacenar estado del procesador (PC, registro de condición, máscara de interrupciones, etc.)!
❖ Transferir control al sistema operativo!
❖ Pasar a modo de ejecución supervisor!
❖ Sistema operativo atiende excepción, restaura el estado y retorna al programa de usuario!
❖ ¿Cómo transferir el control al sistema operativo dependiendo del tipo de excepción?!
❖ Registro de estado (MIPS)!
❖ Excepción provoca salto a posición fija de memoria!
❖ Registro de estado (Cause en MIPS) almacena código que indica causa de la excepción!
❖ Sistema operativo examina registro de estado y salta a rutina de excepción correspondiente!
❖ Excepciones vectorizadas (ARM)!
❖ Salto se produce a una dirección distinta para cada tipo de excepción!
❖ Código de sistema operativo en cada dirección atiende excepción!
❖ Típicamente poco espacio entre direcciones de atención, en la mayoría de los casos el código es un salto a
la rutina de atención!
❖ Excepciones autovectorizadas (Intel x86, más o menos)!
❖ Tabla con direcciones de rutinas de atención en memoria de sistema operativo!
❖ Ante una excepción, procesador lee dirección de atención para el tipo de excepción correspondiente y
salta a la rutina de atención
Atención de excepciones en MIPS
Registros de estado en coprocesador 0: !
Cause: almacena la causa de una excepción y las que están pendientes.!
Status: máscara de interrupciones, modo supervisor y habilitar/deshabilitar interrupciones!
BadVAddress: dirección de memoria de datos que provocó excepción!
EPC: instrucción que se interrumpió
31 16 15 8 1
Interrupt Mask k e k e k e
Pending Code
BadVAddress
EPC
Codificación de Instrucciones
❖ Lenguaje assembly!
❖ Representación simbólica de instrucciones del lenguaje de máquina!
❖ Conveniencias para programación (mnemónicos, labels, directivas, etc.)!
❖ Lenguaje de máquina!
❖ Instrucciones en memoria representadas en binario!
❖ Procesador las transforma en señales de control para ejecutar la instrucción!
❖ Campos de una instrucción!
❖ Código de operación (opcode)!
❖ Operandos inmediatos (constantes, desplazamientos)!
❖ Registros operando!
❖ Información adicional (ej. Opcode extendido, continuación de la instrucción, etc.)!
❖ Objetivos de la codificación de instrucciones!
❖ Simplicidad (más fácil de decodificar)!
❖ Regular (campos de la instrucción son fijos)!
❖ Compacto (reduce el tamaño en memoria de los programas)
Codificación de instruciones MIPS
❖ Instrucciones tipo R:!
❖ Instrucciones con 3 registros!
❖ Opcode == 0 para instrucciones tipo R!
❖ Function → operación realizada por la instrucción!
❖ Rs, Rt, Rd → registros operandos (origen 1, origen 2, destino)!
❖ Shamt → (shift amount) desplazamiento en bits!
❖ Ej. add, subu, sla, jr!
❖ Ej: and $10, $14, $3!
❖ !! 000000 01110 00011 01010 00000 100100!

❖ Ej: or $10, $14, $3!
❖ !! 000000 01110 00011 01010 00000 100101!

❖ Ej: sll $6, $20, 5!
❖ !! 000000 XXXXX 10100 00110 00101 000000
6b 5b 5b 5b 5b 6b
Opcode Rs Rt Rd Shamt Function
Codificación de instrucciones MIPS
❖ Instrucciones tipo I:!
❖ Instrucciones con operandos inmediatos!
❖ Ej. addi, subui, beq!
❖ Opcode → operación realizada por la instrucción!
❖ Rs, Rt → registro operando origen y destino!
❖ Ej: andi $10, $14, 23!
❖ ! ! 001100 01110 01010 0000 0000 0001 0111!

❖ Ej: beq $1, $2, CLabel # (CLabel = 5)!
❖ ! ! 000100 00001 00010 0000 0000 0000 0101!
❖ Ojo: desplazamiento de saltos condicionales es en instrucciones, no bytes
6b 5b 5b 16b
Opcode Rs Rt Immediate (CLabel)
Codificación de instrucciones MIPS
❖ Instrucciones tipo J:!
❖ Instrucciones de salto incondicional!
❖ Opcode → operación realizada por la instrucción!

❖ Label → dirección destino!
❖ Ej: j LABEL # (LABEL = 39.062.500 decimal)!
!! 000010 10 0101 0100 0000 1011 1110 0100!
❖ Ej: jal LABEL # (LABEL = 46.875.000 decimal)!
!! 000011 10 1100 1011 0100 0001 0111 1000!
❖ ¡Label de 26 bits no cubre espacio de direcciones completo!!
❖ Direcciona instrucciones, no bytes (2 LSB siempre cero → requiere 30 bits)!
❖ Dirección destino!
❖ 4 MSB son los mismos del PC actual!
❖ 26 bits siguientes vienen del LABEL!
❖ 2 LSB son siempre cero!
❖ Ensamblador encubre esta irregularidad
6b 26b
Opcode Label
Ejemplo: Desensamblar código de máquina
Dirección!! Instrucción!
!
0x00400000! 0x00001025!
0x00400004! 0x0005402A!
…! ! ! ! 0x11000003!
! ! ! ! 0x00441020!
! ! ! ! 0x20A5FFFF!
! ! ! ! 0x08100001!
! ! ! ! 0x03E00008
!
0x00400000! 0x00000000000000000001000000100101!
0x00400004! 0x00000000000001010100000000101010!
…! ! ! ! 0x00010001000000000000000000000011!
! ! ! ! 0x00000000010001000001000000100000!
! ! ! ! 0x00100000101001011111111111111111!
! ! ! ! 0x00001000000100000000000000000001!
! ! ! ! 0x00000011111000000000000000001000
!
0x00400000! R!0x00000000000000000001000000100101!
0x00400004! R!0x00000000000001010100000000101010!
…! ! ! ! I!0x00010001000000000000000000000011!
! ! ! ! R!0x00000000010001000001000000100000!
! ! ! ! I!0x00100000101001011111111111111111!
! ! ! ! J!0x00001000000100000000000000000001!
! ! ! ! R 0x00000011111000000000000000001000
!
0x00400000! R!0x00000000000000000001000000100101!
0x00400004! R!0x00000000000001010100000000101010!
…! ! ! ! I!0x00010001000000000000000000000011!
! ! ! ! R!0x00000000010001000001000000100000!
! ! ! ! I!0x00100000101001011111111111111111!
! ! ! ! J!0x00001000000100000000000000000001!
! ! ! ! R 0x00000011111000000000000000001000
!
0x00400000! R! 0 0 0 2 0 37!
0x00400004! R! 0 0 5 8 0 42!
…! ! ! ! I! 4 8 0 +3!
! ! ! ! R! 0 2 4 2 0 32!
! ! ! ! I! 8 5 5 -1!
! ! ! ! J! 2 0x0100001!
! ! ! !R 0 31 0 0 0 8
!
0x00400000! or! ! $2, $0, $0!
0x00400004! slt!! $8, $0, $5!
…! ! ! ! beq!! $8, $0, 3!
! ! ! ! add!! $2, $2, $4!
! ! ! ! addi! $5, $5, -1!
! ! ! ! j! ! 0x0100001!
! ! ! ! jr! ! $31
!
0x00400000! or! ! $v0, $zero, $zero!
0x00400004! slt!! $t0, $zero, $a1!
…! ! ! ! beq!! $t0, $zero, 3! # salto 4 instrucciones adelante!
! ! ! ! add!! $v0, $v0, $a0!
! ! ! ! addi! $a1, $a1, -1!
! ! ! ! j! ! 0x0100001!! ! # dirección: 0x0400004!
! ! ! ! jr! ! $ra
!
0x00400000! ! ! or! ! $v0, $zero, $zero!
0x00400004! Loop:! slt!! $t0, $zero, $a1!
…! ! ! ! ! ! beq!! $t0, $zero, Exit!
! ! ! ! ! ! add!! $v0, $v0, $a0!
! ! ! ! ! ! addi! $a1, $a1, -1!
! ! ! ! ! ! j! ! Loop!
! ! ! ! Exit:! jr! ! $ra
!
0x00400000! ! ! or! ! $v0, $zero, $zero! # inicializar $v0 en 0!
0x00400004! Loop:! slt!! $t0, $zero, $a1!! # $t0 == 1 si $zero < $a
…! ! ! ! ! ! beq!! $t0, $zero, Exit! # salir si $a1 <= 0!
! ! ! ! ! ! add!! $v0, $v0, $a0! ! # $v0 += $a0!
! ! ! ! ! ! addi! $a1, $a1, -1!! ! # decrementar $a1!
! ! ! ! ! ! j! ! Loop! ! ! ! ! # iterar!
! ! ! ! Exit:! jr! ! $ra!! ! ! ! ! # retornar
/* a ! $v0, b ! $a0, c ! $a1 */!
a = 0;!
while (c > 0) {!
! a += b;!
! c—;!
}!
return a;
/* Multiplicación “carretera”: retorna m*n */!
int mult (int m, int n)!
{!
! int p = 0;!
! while (n > 0) {!
! ! p += m;!
! ! n—;!
! }!
! return p!
}

ISA - Key

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

ISA - Key

Cargado por

Copyright:

Formatos disponibles

543.

Arquitectura de Computadores Miguel Figueroa!

PC: program counter

PC: program counter

PC: program counter

virtual. Coprocesador 1: Unidad de punto HI

Dato de 32 bits en dirección “DIR” 02 DIR + 3

Dato de 32 bits en dirección “DIR” 24 DIR + 3

$31 ra dirección de retorno de función

Sólo $zero y $ra tienen funciones definidas por la ISA!

Resta de variables en assembly: sub!

En aritmética con signo complemento a dos:!

❖ MIPS soporta aritmética con signo y sin signo!

❖ addiu extiende la constante a 32 bits repitiendo ceros hacia la izquierda

Implementar en assembly como múltiples instrucciones!

11010100 $t3 11010100 $t3

00010100 $t1 11110110 $t1

11010100 $t3 00001010

11100010 $t1 00000010 $t1

Constante se extiende en ceros

00010111 $t1 (23) (23)

Equivalente a multiplicación por 23 Equivalente a división por 23?

11110111 $t1 (-9) 00000111 $t1 (7)

Desplazamiento variable:!! sllv $t1, $t2, $t3!

sw $t0, 4($s2) # M[$s2 + 4] <— $t0

$s2 es el registro base, 0 o 4 es el desplazamiento

❖ Salto absoluto a procedimiento (jump-and-link)!

beq $t1,$t2,DESTINO # if ($t1 == $t2) PC = DESTINO

slt $t1,$t2,$t3 # if ($t2 < $t3) $t1= 1 else $t1 = 0

Suponer que compilador asigna:

Vectores a y b y variable sum comienzan a addi $t0, $t0, 1 #i=i+1

Recordar convención estándar de uso de registros MIPS:

Code! Suffix!! Description! ! ! ! ! ! ! ! Flags!

Todos estos valores deben respaldarse en memoria. Pero cómo y dónde?

PROC1: move $t0, $a0 $ra

Pero qué pasaría si PROC1 fuera recursivo?

$sp $a0 dir

addi $a0, $a0, -1 # n – 1

$sp $a0 dir

addi $a0, $a0, -1 # n – 1

$sp $a0 dir

addi $a0, $a0, -1 # n – 1

addi $a0, $a0, -1 # n – 1

$sp SP_ANT $fp FP_ANT $ra RA_ANT $a0 3 $v0 V0_ANT

addi $a0, $a0, -1 # n – 1

$sp SP_1 $fp FP_1 $ra RA_ANT $a0 2 $v0 V0_ANT

addi $a0, $a0, -1 # n – 1

$sp SP_1 $fp FP_1 $ra L2 $a0 2 $v0 V0_ANT

addi $a0, $a0, -1 # n – 1 $sp 2 SP_2

$sp SP_2 $fp FP_2 $ra L2 $a0 1 $v0 V0_ANT

addi $a0, $a0, -1 # n – 1 $sp 2 SP_2

$sp SP_2 $fp FP_2 $ra L2 $a0 1 $v0 V0_ANT

addi $a0, $a0, -1 # n – 1 2 SP_2

$sp SP_3 $fp FP_3 $ra L2 $a0 0 $v0 V0_ANT

addi $a0, $a0, -1 # n – 1 2 SP_2

$sp SP_3 $fp FP_3 $ra L2 $a0 0 $v0 1

addi $a0, $a0, -1 # n – 1 $sp 2 SP_2

$sp SP_2 $fp FP_2 $ra L2 $a0 1 $v0 1

addi $a0, $a0, -1 # n – 1 2 SP_2

$sp SP_1 $fp FP_1 $ra L2 $a0 2 $v0 2

addi $a0, $a0, -1 # n – 1 2 SP_2

$sp SP_ANT $fp FP_ANT $ra RA_ANT $a0 3 $v0 6

❖ Condiciones especiales que cambian el flujo de

Recordar convención estándar de uso de registros MIPS:  