advertisement

I S A

42 %
58 %
advertisement
Information about I S A

Published on August 5, 2007

Author: stefanosalvatori

Source: slideshare.net

advertisement

ISA Instruction Set Architecture Cecilia Hernández [email_address]

Estructura de un Sistema Computacional

Traduciendo y ejecutando un programa Programa C Programa en lenguaje ensamblador Cód. Objeto: módulo en lenguaje de máquina Cod. Objeto: Bibliotecas Cod. Ejecutable: Prog. Leng. Máquina Memoria Compilador Ensamblador Linker Loader

Interfaz HW/SW

Convenciones UNIX P.c : archivo fuente en lenguaje C P.s : archivo fuente en lenguaje ensamblador P.o : archivo objeto P.a : biblioteca estáticamente linkeada P.so : biblioteca dinámicamente linkeada a.out : archivo ejecutable por defecto MS-DOS P.C : archivo fuente en lenguaje C P.ASM : archivo fuente en lenguaje ensamblador P.OBJ : archivo objeto P.LIB : biblioteca estaticamente linkeada P.DLL : biblioteca dinámicamente linkeada P.EXE: archivo ejecutable

UNIX

P.c : archivo fuente en lenguaje C

P.s : archivo fuente en lenguaje ensamblador

P.o : archivo objeto

P.a : biblioteca estáticamente linkeada

P.so : biblioteca dinámicamente linkeada

a.out : archivo ejecutable por defecto

MS-DOS

P.C : archivo fuente en lenguaje C

P.ASM : archivo fuente en lenguaje ensamblador

P.OBJ : archivo objeto

P.LIB : biblioteca estaticamente linkeada

P.DLL : biblioteca dinámicamente linkeada

P.EXE: archivo ejecutable

Qué es una instrucción? Comando que le dice a la CPU que operación realizar Mediante código de operación Todas las instrucciones están codificadas Donde se encuentran los operandos necesarios para ejecutar la operación ISA de una instrucción especifica Código de operación Cuántos operandos son necesarios, tipos, tamaños, ubicación Operandos Registros (enteros, punto flotante, PC) Dirección de memoria Constantes

Comando que le dice a la CPU que operación realizar

Mediante código de operación

Todas las instrucciones están codificadas

Donde se encuentran los operandos necesarios para ejecutar la operación

ISA de una instrucción especifica

Código de operación

Cuántos operandos son necesarios, tipos, tamaños, ubicación

Operandos

Registros (enteros, punto flotante, PC)

Dirección de memoria

Constantes

Ejecución de instrucción de máquina CPU ejecuta instrucciones de un programa ciclo Instrucciones especifican operaciones sobre operandos y generan resultados Datos pueden encontrarse en memoria (RAM, ROM) o en registros internos al procesador Instrucciones pueden también modificar el flujo de control (saltos, llamadas a procedimiento) Instrucciones pueden crear excepciones

CPU ejecuta instrucciones de un programa ciclo

Instrucciones especifican operaciones sobre operandos y generan resultados

Datos pueden encontrarse en memoria (RAM, ROM) o en registros internos al procesador

Instrucciones pueden también modificar el flujo de control (saltos, llamadas a procedimiento)

Instrucciones pueden crear excepciones

Arquitectura de Conjunto de Instrucciones ISA Visión del programador de bajo nivel o del compilador Elementos que definen la ISA Operaciones (instrucciones) suma, multiplicación, saltos, entrada/salida Tipos de datos Entero, punto flotante, strings Número y forma de acceder a operandos y resultados 0,1,2,3 operandos, residentes en memoria o registros internos Formato (codificación) de instrucciones y datos Complemento a 2, punto flotante IEEE Espacio de memoria y número de registros Condiciones excepcionales División por cero, excepción de memoria virtual, llamada a sistema operativo

Visión del programador de bajo nivel o del compilador

Elementos que definen la ISA

Operaciones (instrucciones)

suma, multiplicación, saltos, entrada/salida

Tipos de datos

Entero, punto flotante, strings

Número y forma de acceder a operandos y resultados

0,1,2,3 operandos, residentes en memoria o registros internos

Formato (codificación) de instrucciones y datos

Complemento a 2, punto flotante IEEE

Espacio de memoria y número de registros

Condiciones excepcionales

División por cero, excepción de memoria virtual, llamada a sistema operativo

MIPS Una familia de procesadores 32 bits : R2000/3000 64 bits : R4000/4400, R10000 Partió como proyecto de investigación en Stanford y luego formó compañía MIPS, que posteriormente compró Silicon Graphics Proviene de máquinas DEC MIPS es RISC Actualmente usados en mercados de sistemas encrustrados o embebidos Routers CISCO, modems cable (modula señales de comunicación sobre infraestructura de TV cable), impresoras laser, Sony playstation 2, computadores handheld http://www.mips.com/content/Markets/MIPSBased/content_html

Una familia de procesadores

32 bits : R2000/3000

64 bits : R4000/4400, R10000

Partió como proyecto de investigación en Stanford y luego formó compañía MIPS, que posteriormente compró Silicon Graphics

Proviene de máquinas DEC

MIPS es RISC

Actualmente usados en mercados de sistemas encrustrados o embebidos

Routers CISCO, modems cable (modula señales de comunicación sobre infraestructura de TV cable), impresoras laser, Sony playstation 2, computadores handheld

http://www.mips.com/content/Markets/MIPSBased/content_html

Aplicaciones del procesador MIPS

Almacenamiento en MIPS

Registros MIPS Registros de propósito general Un banco de registro de 32 registros de 32 bits direccionados $0, $1,…, $31 Aritmética entera y lógica cálculo de direcciones, operaciones de propósito específico como Puntero al Stack (pila) Un banco de registros punto flotante. Registros de 32 bits direccionados $f1, $f2,…$f31 usados para aritmética punto flotante Registros de propósito específico 2 registros de 32 bits (HI, LO) usados para multiplicación y división Un registro Contador de Programas (PC) Registro de estado (coprocesador 0) almacena causa de excepción datos relacionados a excepción ISA con registros generales también son llamadas Ortogonales Operaciones son independientes de los registros ISA MIPS define Convención Software para uso de registros No es obligatoria, no es forzada por hardware

Registros de propósito general

Un banco de registro de 32 registros de 32 bits direccionados $0, $1,…, $31

Aritmética entera y lógica cálculo de direcciones, operaciones de propósito específico como Puntero al Stack (pila)

Un banco de registros punto flotante. Registros de 32 bits direccionados $f1, $f2,…$f31 usados para aritmética punto flotante

Registros de propósito específico

2 registros de 32 bits (HI, LO) usados para multiplicación y división

Un registro Contador de Programas (PC)

Registro de estado (coprocesador 0) almacena causa de excepción datos relacionados a excepción

ISA con registros generales también son llamadas Ortogonales

Operaciones son independientes de los registros

ISA MIPS define Convención Software para uso de registros

No es obligatoria, no es forzada por hardware

Convención de uso de registros MIPS $0 zero constante cero $1 at reservado para ensamblador $2 v0 evaluación de expresiones y $3 v1 resultados de funciones $4 a0 argumentos a funciones $5 a1 $6 a2 $7 a3 $8 t0 variables temporales respaldadas por función . que invoca . (función invocada puede . sobreescribir) $15 t7 $16 s0 temporales respaldados por . función invocada . (función que invoca no respalda) . $23 s7 $24 t8 temporales (adicionales) $25 t9 $26 k0 reservados para sistema operativo $27 k1 $28 gp puntero a variables globales $29 sp puntero a tope del stack $30 fp puntero a base del stack $31 ra dirección de retorno de función

MIPS=RISC = Arquitectura load/store ALU opera sólo en operandos que están en registros A excepción de enteros pequeños que pueden estar en la misma instrucción, como se verá más adelante (caso de instrucciones con componente immediato) Implica que variables deben estar “loaded” en registros (si vienen de la memoria) antes de ejecutar otro tipo de instrucciones Las únicas instrucciones que accesan la memoria son del tipo load/store Se necesitan instrucciones explícitas para realizar operaciones de “load” y “store” Resultados obtenidos de otras operaciones deben ser “stored” en memoria

ALU opera sólo en operandos que están en registros

A excepción de enteros pequeños que pueden estar en la misma instrucción, como se verá más adelante (caso de instrucciones con componente immediato)

Implica que variables deben estar “loaded” en registros (si vienen de la memoria) antes de ejecutar otro tipo de instrucciones

Las únicas instrucciones que accesan la memoria son del tipo load/store

Se necesitan instrucciones explícitas para realizar operaciones de “load” y “store”

Resultados obtenidos de otras operaciones deben ser “stored” en memoria

Ejemplo Sentencia expresada en un lenguaje de programación de alto nivel x = y + z w = x + y Se traduce en lenguaje assembly (ensamblador) como (asumiendo operandos están en memoria) load y en registro ry load z en registro rz rx <- ry + rz store rx en x, no borra el resultado en rx rt <- rx + ry store rt en w

Sentencia expresada en un lenguaje de programación de alto nivel

x = y + z

w = x + y

Se traduce en lenguaje assembly (ensamblador) como (asumiendo operandos están en memoria)

load y en registro ry

load z en registro rz

rx <- ry + rz

store rx en x, no borra el resultado en rx

rt <- rx + ry

store rt en w

Programando en lenguaje ensamblador Usar muchos comentarios para describir lo que se esta haciendo Usar words en lugar de bytes en lo posible La siguiente dirección a dato expresado en words es dirección + 4 Direcciones de words son divisibles por 4

Usar muchos comentarios para describir lo que se esta haciendo

Usar words en lugar de bytes en lo posible

La siguiente dirección a dato expresado en words es dirección + 4

Direcciones de words son divisibles por 4

Tipos de instrucciones en MIPS Aritméticas Operaciones con enteros (con y sin signo) Operaciones con punto flotante Lógicas y de desplazamiento Ands, ors, entre otros Desplazamiento de bits (izquierda, derecha) Load/store Variables son cargadas en registros (load) Desde memoria a registros o constantes a registros Resultados se graban en memoria (store) Comparación de valores en registros Saltos condicionales (branches) y absolutos (jumps) Manipulan control de flujo Incluyen llamados a procedimientos y retornos

Aritméticas

Operaciones con enteros (con y sin signo)

Operaciones con punto flotante

Lógicas y de desplazamiento

Ands, ors, entre otros

Desplazamiento de bits (izquierda, derecha)

Load/store

Variables son cargadas en registros (load)

Desde memoria a registros o constantes a registros

Resultados se graban en memoria (store)

Comparación de valores en registros

Saltos condicionales (branches) y absolutos (jumps)

Manipulan control de flujo

Incluyen llamados a procedimientos y retornos

Aritmética entera Números pueden ser con o sin signo Instrucciones aritméticas (+,-,/,*) existen para ambos tipos de enteros (diferenciado por código de operación) add, addu, sub, subu addi, addiu, subi, subiu mult, multu, div, divu Números con signo son representados en complemento a 2 En caso de overflow se genera excepción

Números pueden ser con o sin signo

Instrucciones aritméticas (+,-,/,*) existen para ambos tipos de enteros (diferenciado por código de operación)

add, addu, sub, subu

addi, addiu, subi, subiu

mult, multu, div, divu

Números con signo son representados en complemento a 2

En caso de overflow se genera excepción

Notación en SPIM Código operación rd, rs, rt Instrucciones aritmeticas, lógicas, comparaciones Código operación rt, rs, immediato Instrucciones aritméticas, lógicas, load/store, saltos condicionales Código operación immediato Instrucciones de salto absoluto Donde: rd siempre es el registro destino rs siempre es el registro fuente (de sólo lectura) rt puede ser fuente o destino depende del código de operación Immediato es una constante de 16 bits (con o sin signo)

Código operación rd, rs, rt

Instrucciones aritmeticas, lógicas, comparaciones

Código operación rt, rs, immediato

Instrucciones aritméticas, lógicas, load/store, saltos condicionales

Código operación immediato

Instrucciones de salto absoluto

Donde:

rd siempre es el registro destino

rs siempre es el registro fuente (de sólo lectura)

rt puede ser fuente o destino depende del código de operación

Immediato es una constante de 16 bits (con o sin signo)

Instrucciones aritméticas en SPIM No confundirlo con la codificación de instrucciones que se verá pronto # rd = rs - rt rd, rs, rt sub # rt = rs + immed rt, rs, immediato addi # rd = rs + rt rd, rs, rt add Comentarios Operandos Código Operación

No confundirlo con la codificación de instrucciones que se verá pronto

Instrucciones aritméticas add $1,$2,$3 #$1 = $2 + $3. Posible overflow sub $1,$2,$3 #$1 = $2 – $3. Posible overflow addi $1,$2,100 #$1 = $2 + 100. Posible overflow addu $1,$2,$3 #$1 = $2 + $3. Suma sin signo sin overflow subu $1,$2,$3 #$1 = $2 – $3. Resta sin signo sin overflow addiu $1,$2,100 #$1 = $2 + 100. Suma sin signo sin overflow mult $2,$3 #HI, LO = $2 x $3 multu$2,$3 #HI, LO = $2 x $3. Producto sin signo div $2,$3 #LO = $2 ÷ $3 (cuociente) #HI = $2 mod $3 (resto) divu $2,$3 #LO = $2 ÷ $3 (cuociente sin signo) #HI = $2 mod $3 (resto) abs $1, $2 #$1 = |$2|. Valor absoluto

add $1,$2,$3 #$1 = $2 + $3. Posible overflow

sub $1,$2,$3 #$1 = $2 – $3. Posible overflow

addi $1,$2,100 #$1 = $2 + 100. Posible overflow

addu $1,$2,$3 #$1 = $2 + $3. Suma sin signo sin overflow

subu $1,$2,$3 #$1 = $2 – $3. Resta sin signo sin overflow

addiu $1,$2,100 #$1 = $2 + 100. Suma sin signo sin overflow

mult $2,$3 #HI, LO = $2 x $3

multu$2,$3 #HI, LO = $2 x $3. Producto sin signo

div $2,$3 #LO = $2 ÷ $3 (cuociente) #HI = $2 mod $3 (resto)

divu $2,$3 #LO = $2 ÷ $3 (cuociente sin signo) #HI = $2 mod $3 (resto)

abs $1, $2 #$1 = |$2|. Valor absoluto

Ejemplos Add $8,$9,$10 #$8=$9+$10 Add $t0,$t1,$t2 #$t0=$t1+$t2 Sub $s2,$s1,$s0 #$s2=$s1-$s0 Addi $a0,$t0,20 #$a0=$t0+20 Addi $a0,$t0,-20 #$a0=$t0-20 Addi $t0,$0,0 #clear $t0 Sub $t5,$0,$t5 #$t5 = -$t5

Instrucciones lógicas and $1,$2,$3 #$1 = $2 && $3 or $1,$2,$3 #$1 = $2 || $3 xor $1,$2,$3 #$1 = ~($2 || $3) nor $1,$2,$3 #$1 = ~($2 || $3) andi $1,$2,10 #$1 = $2 && 10 ori $1,$2,10 #$1 = $2 || 10 xori $1, $2,10 #$1 = ~$2 && ~10 sll $1,$2,10 #$1 = $2 << 10. Desplazamiento lógico srl $1,$2,10 #$1 = $2 >> 10. Desplazamiento lógico sra $1,$2,10 #$1 = $2 >> 10. Desplazamiento aritmético sllv $1,$2,$3 #$1 = $2 << $3. Desplazamiento lógico srlv $1,$2, $3 #$1 = $2 >> $3. Desplazamiento lógico srav $1,$2, $3 #$1 = $2 >> $3. Desplazamiento aritmético

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

or $1,$2,$3 #$1 = $2 || $3

xor $1,$2,$3 #$1 = ~($2 || $3)

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

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

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

xori $1, $2,10 #$1 = ~$2 && ~10

sll $1,$2,10 #$1 = $2 << 10. Desplazamiento lógico

srl $1,$2,10 #$1 = $2 >> 10. Desplazamiento lógico

sra $1,$2,10 #$1 = $2 >> 10. Desplazamiento aritmético

sllv $1,$2,$3 #$1 = $2 << $3. Desplazamiento lógico

srlv $1,$2, $3 #$1 = $2 >> $3. Desplazamiento lógico

srav $1,$2, $3 #$1 = $2 >> $3. Desplazamiento aritmético

Movimiento entre registros move $2,$3 # $2  $3 (PseudoInstrucción) mflo $2 # $2  LO. Copia LO en $2 mfhi $2 # $2  HI. Copia HI en $2 mtlo $2 # LO  $2. Copia en LO $2 mthi $2 # $2  HI. Copia en HI $2 lui $3, 500 # $3  500 * 2 16 . Carga el valor # constante de 16b en la parte # más significativa de $3 mfc0 $1, $epc # $1  dirección de instrucción que # causó excepción

move $2,$3 # $2  $3 (PseudoInstrucción)

mflo $2 # $2  LO. Copia LO en $2

mfhi $2 # $2  HI. Copia HI en $2

mtlo $2 # LO  $2. Copia en LO $2

mthi $2 # $2  HI. Copia en HI $2

lui $3, 500 # $3  500 * 2 16 . Carga el valor # constante de 16b en la parte # más significativa de $3

mfc0 $1, $epc # $1  dirección de instrucción que # causó excepción

Acceso a memoria Mueven datos entre registros y memoria Modo de direccionamiento único base + desplazamiento Base: contenido de registro Desplazamiento: constante de 16 bits Load lw rt,rs,offset #rt = Memory[rs+offset] lw $1, 100($2) # $1  Mem[$2 + 100] Store lw rt,rs,offset #Memory[rs+offset]=rt sw $1, 100($2) # $1 -> Mem[$2 + 100]

Mueven datos entre registros y memoria

Modo de direccionamiento único

base + desplazamiento

Base: contenido de registro

Desplazamiento: constante de 16 bits

Load

lw rt,rs,offset #rt = Memory[rs+offset]

lw $1, 100($2) # $1  Mem[$2 + 100]

Store

lw rt,rs,offset #Memory[rs+offset]=rt

sw $1, 100($2) # $1 -> Mem[$2 + 100]

Instrucciones load/store sw $3, 500($2) # Mem(500+$2)  $3. Almacena 32b sh $3, 500($2) # Mem(500+$2)  $3. Almacena 16b sb $3, 500($2) # Mem(500+$2)  $3. Almacena 8b lw $3, 500($2) # $3  Mem(500+$2). Carga 32b lh $3, 500($2) # $3  Mem(500+$2). Carga 16b lhu $3, 500($2) # $3  Mem(500+$2). # Carga 16b sin signo lb $3, 500($2) # $3  Mem(500+$2). Carga 8b la $3, Label # $3  Address. Carga la dirección # efectiva asociada a Label en $3 Dirección efectiva : número que indica dirección del operando en memoria

sw $3, 500($2) # Mem(500+$2)  $3. Almacena 32b

sh $3, 500($2) # Mem(500+$2)  $3. Almacena 16b

sb $3, 500($2) # Mem(500+$2)  $3. Almacena 8b

lw $3, 500($2) # $3  Mem(500+$2). Carga 32b

lh $3, 500($2) # $3  Mem(500+$2). Carga 16b

lhu $3, 500($2) # $3  Mem(500+$2). # Carga 16b sin signo

lb $3, 500($2) # $3  Mem(500+$2). Carga 8b

la $3, Label # $3  Address. Carga la dirección # efectiva asociada a Label en $3

Dirección efectiva : número que indica dirección del operando en memoria

Algunas pseudoinstrucciones move $4, $5 # $4  $5 # or $4, $zero, $5 li $4, 100 # $4  100 # ori $4, $zero, 100 la $4, LABEL32 # $4  LABEL # lui $4, LABEL 16bsuperiores # ori $4, $4, LABEL 16binferiores bgt $4, CTE, LABEL # if ($4 > CTE) goto LABEL # slti $at, $4, CTE+1 # beq $at, $zero, LABEL

Ejemplo int a, b, acum; … acum = acum + a * b; # 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 $v0, DIR_A # cargar dirección de a la $v1, DIR_B # cargar dirección de b lw $t0, 0($v0) # leer a lw $t1, 0($v1) # leer b mul $t2, $t0, $t1 # t2 = a * b la $v2, DIR_ACUM # cargar dirección de acum lw $t3, 0($v2) # leer acum add $t3, $t3, $t2 # $t3 = acum + a * b sw $t3, 0($v2) # guardar acum 10 2 DIR_A DIR_B DIR_ACUM 50 Memoria $v0 $v1 $v2 $t0 $t1 $t2 $t3 1000 1012 10 2 20 1024 50 70 70 1000 1004 1008 1012 1016 1020 1024 a b acum

Ejemplo typedef struct { int x; int y; } coord; coord c1, c2; … int dist; dist = abs(c2.x – c1.x) + abs(c2.y – c1.y); # Dirección de memoria de ‘c1’ en rótulo DIR_C1 # Dirección de memoria de ‘c2’ en rótulo DIR_C2 # Dirección de memoria de ‘dist’ en rótulo DIR_DIST la $v0, DIR_C1 # cargar dirección de c1 la $v1, DIR_C2 # cargar dirección de c2 lw $t0, 0($v0) # leer c1.x lw $t1, 0($v1) # leer c2.x sub $t2, $t1, $t0 # t2 = c2.x – c1.x abs $t3, $t2 # t3 = abs(c2.x – c1.x) lw $t0, 4($v0) # leer c1.y lw $t1, 4($v1) # leer c2.y sub $t2, $t1, $t0 # t2 = c2.y – c1.y abs $t4, $t2 # t4 = abs(c2.y – c1.y) add $t3, $t3, $t4 # t3 = abs(c2.x – c1.x) + # abs(c2.y – c1.y) la $v0, DIR_DIST # cargar dirección de dist sw $t3, 0($v0) # dist = abs(c2.x – c1.x) + # abs(c2.y – c1.y) c1.x c1.y c2.x c2.y Direcciones de memoria DIR_C1 DIR_C1 + 4 DIR_C2 DIR_C2 + 4 DIR_DIST dist Memoria

Ejecución condicional de instrucciones Permiten ejecutar partes de un programa sólo si se cumple una determinada condición Ej. Estructuras tipo if-else, for, while, switch-case Típicamente saltos, pero también escritura a registro ¿Cómo especificar la condición? Comparación en la instrucción bgt r1, r2, ADDR # if r1 > r2 goto ADDR Registro de condición (MIPS) cmp r1, r2, r3 # r3 = signo (r1-r2) bgtz r1, ADDR # if r1 > 0 goto ADDR

Permiten ejecutar partes de un programa sólo si se cumple una determinada condición

Ej. Estructuras tipo if-else, for, while, switch-case

Típicamente saltos, pero también escritura a registro

¿Cómo especificar la condición?

Comparación en la instrucción

bgt r1, r2, ADDR # if r1 > r2 goto ADDR

Registro de condición (MIPS)

cmp r1, r2, r3 # r3 = signo (r1-r2) bgtz r1, ADDR # if r1 > 0 goto ADDR

Instrucciones ISA MIPS Instrucciones de comparación Evalúa condición entre dos operandos Resultado es VERDADERO o FALSO Utilizan registro de condición Resultado de comparación se almacena en registro destino FALSO  regDest = 0 VERDADERO  regDest = 1 Ejemplo: add $1, $2, $3 slt $4, $1, $0 # if $1 < $0 then $4 = 1 # else #4 = 0

Instrucciones de comparación

Evalúa condición entre dos operandos

Resultado es VERDADERO o FALSO

Utilizan registro de condición

Resultado de comparación se almacena en registro destino

FALSO  regDest = 0

VERDADERO  regDest = 1

Algunas instrucciones de comparación slt $1,$2,$3 # if ($2 < $3) $1= 1 else $1 = 0 sltu $1,$2,$3 # if ($2 < $3) $1 = 1 else $1 = 0 (sin signo) slti $1, $2, 100 # if ($2 < 100) $1 = 1 else $1 = 0 sltiu $1, $2, 100 # if ($2 < 100) $1 = 1 else $1 = 0 (sin signo) Pseudoinstrucciones (se traducen en más de una instrucción de máquina): seq $1, $2, $3 $if ($2 == $3) $1 = 1 else $1 = 0 sne $1, $2, $3 $if ($2 != $3) $1 = 1 else $1 = 0 sgt $1, $2, $3 $if ($2 > $3) $1 = 1 else $1 = 0 sge $1, $2, $3 $if ($2 >= $3) $1 = 1 else $1 = 0 sle $1, $2, $3 $if ($2 <= $3) $1 = 1 else $1 = 0 Y otras…

slt $1,$2,$3 # if ($2 < $3) $1= 1 else $1 = 0

sltu $1,$2,$3 # if ($2 < $3) $1 = 1 else $1 = 0 (sin signo)

slti $1, $2, 100 # if ($2 < 100) $1 = 1 else $1 = 0

sltiu $1, $2, 100 # if ($2 < 100) $1 = 1 else $1 = 0 (sin signo)

Pseudoinstrucciones (se traducen en más de una instrucción de máquina):

seq $1, $2, $3 $if ($2 == $3) $1 = 1 else $1 = 0

sne $1, $2, $3 $if ($2 != $3) $1 = 1 else $1 = 0

sgt $1, $2, $3 $if ($2 > $3) $1 = 1 else $1 = 0

sge $1, $2, $3 $if ($2 >= $3) $1 = 1 else $1 = 0

sle $1, $2, $3 $if ($2 <= $3) $1 = 1 else $1 = 0

Y otras…

Instrucciones de salto MIPS Saltos condicionales beq $1,$2,CLabel # if ($1==$2) goto CLabel ; bne $1,$2,CLabel # if ($1!=$2) goto CLabel ; bgez $1, Clabel # if ($1 >=0) goto Clabel bgtz, $1, Clabel # if ($1 >0) goto Clabel blez, $1, Clabel # if ($1<=0) goto Clabel bltz $1, Clabel # if ($1<0) goto CLabel bge $1,$2,CLabel # if ($1>=$2) goto CLabel ; bgt $1,$2,CLabel # if ($1>$2) goto CLabel ; bgtu $1,$2,CLabel # if ($1>$2) goto CLabel ; # Comparación sin signo ble $1,$2,CLabel # if ($1<=$2) goto CLabel ; blt $1,$2,CLabel # if ($1<$2) goto CLabel ; bltu $1,$2,CLabel # if ($1<$2) goto CLabel ; # Comparación sin signo

Saltos condicionales

beq $1,$2,CLabel # if ($1==$2) goto CLabel ;

bne $1,$2,CLabel # if ($1!=$2) goto CLabel ;

bgez $1, Clabel # if ($1 >=0) goto Clabel

bgtz, $1, Clabel # if ($1 >0) goto Clabel

blez, $1, Clabel # if ($1<=0) goto Clabel

bltz $1, Clabel # if ($1<0) goto CLabel

bge $1,$2,CLabel # if ($1>=$2) goto CLabel ;

bgt $1,$2,CLabel # if ($1>$2) goto CLabel ;

bgtu $1,$2,CLabel # if ($1>$2) goto CLabel ;

# Comparación sin signo

ble $1,$2,CLabel # if ($1<=$2) goto CLabel ;

blt $1,$2,CLabel # if ($1<$2) goto CLabel ;

bltu $1,$2,CLabel # if ($1<$2) goto CLabel ;

# Comparación sin signo

Instrucciones de transferencia de control Registro de contador de programa Program Counter (PC) Almacena dirección de siguiente instrucción a ejecutar Por defecto, instrucción físicamente siguiente a la actual (PC  PC + 4) Modificación del flujo de control de un programa Tipos de salto (especificación de dirección destino) Absoluto: instrucción especifica directamente dirección destino Relativo: instrucción especifica desplazamiento respecto de instrucción actual Tipos de salto (ejecución condicional) Incondicional: salto se realiza de todas formas Condicional: salto se realiza sólo si se cumple una condición La mayoría de las ISA usan dos tipos de salto jump: absoluto e incondicional branch: relativo y condicional

Registro de contador de programa

Program Counter (PC)

Almacena dirección de siguiente instrucción a ejecutar

Por defecto, instrucción físicamente siguiente a la actual (PC  PC + 4)

Modificación del flujo de control de un programa

Tipos de salto (especificación de dirección destino)

Absoluto: instrucción especifica directamente dirección destino

Relativo: instrucción especifica desplazamiento respecto de instrucción actual

Tipos de salto (ejecución condicional)

Incondicional: salto se realiza de todas formas

Condicional: salto se realiza sólo si se cumple una condición

La mayoría de las ISA usan dos tipos de salto

jump: absoluto e incondicional

branch: relativo y condicional

Saltos Otros tipos de salto Salto a procedimiento : almacena dirección de retorno Retorno de procedimiento : retorna a instrucción siguiente a la que hizo el salto a procedimiento Llamado a sistema : salta a dirección predeterminada y pasa a modo supervisor Retorno de excepción o llamado a sistema : retorna a instrucción que provocó excepción o llamado a sistema, y restaura modo usuario

Otros tipos de salto

Salto a procedimiento : almacena dirección de retorno

Retorno de procedimiento : retorna a instrucción siguiente a la que hizo el salto a procedimiento

Llamado a sistema : salta a dirección predeterminada y pasa a modo supervisor

Retorno de excepción o llamado a sistema : retorna a instrucción que provocó excepción o llamado a sistema, y restaura modo usuario

Instrucciones de salto MIPS Saltos absolutos j CLabel # PC  CLabel Saltos a procedimiento jal CLabel # $ra  PC; PC  CLabel; bgezal $1, CLabel # if ($1>=0) $ra = PC; PC = Clabel Recordar que, durante la ejecución de una instrucción, PC contiene la dirección de la siguiente instrucción a ejecutar $ra = $31 Saltos indexados jr $ra # PC  $ra jalr $1, $2 # $2  PC + 4; PC  $1

Saltos absolutos

j CLabel # PC  CLabel

Saltos a procedimiento

jal CLabel # $ra  PC; PC  CLabel;

bgezal $1, CLabel # if ($1>=0) $ra = PC; PC = Clabel

Recordar que, durante la ejecución de una instrucción, PC contiene la dirección de la siguiente instrucción a ejecutar

$ra = $31

Saltos indexados

jr $ra # PC  $ra

jalr $1, $2 # $2  PC + 4; PC  $1

Ejemplo Código assembly para el siguiente código C: int a = 10, b = 5; int c; … if (a > b) c = a – b; else c = b – a; c = c + 10; Compilador asigna: a  $t0 b  $t1 c  $t2 li $t0, 10 # a = 10 li $t1, 5 # b = 5 sle $t3, $t0, $t1 # a <= b ? bgtz $t3, ELSE # if a <= b goto ELSE sub $t2, $t0, $t1 # c = a - b j FIN_IF # goto FIN_IF ELSE: sub $t2, $t1, $t0 # c = b - a FIN_IF: addi $t2, $t2, 10 # c = c + 10

Ejemplo Código assembly para el siguiente código C: i = 0; sum = 0; do { sum = sum + a[i] * b[i]; i++; } while (i < 100) li $t0, 0 # i = 0; li $t1, 0 # $t1 = 0 (sum temporal) la $t2, SUM # $t2 = dirección de sum sw $t1, 0($t2) # sum = 0 LOOP: la $t3, A # $t3 = dirección a[0] la $t4, B # $t4 = dirección b[0] sll $t5, $t0, 2 # $t5 = i*4 add $t6, $t3, $t5 # $t6 = dirección a[i] lw $t7, 0($t6) # $t7 = a[i] add $t6, $t4, $t5 # $t6 = dirección b[i] lw $t8, 0($t6) # $t8 = b[i] mul, $t8, $t7, $t8 # $t8 = a[i]*b[i] add $t1, $t1, $t8 # $t1 = sum + a[i]*b[i] la $t2, SUM sw, $t1, 0($t2) # sum = sum + a[i] * b[i] add $t0, $t0, 1 # i = i + 1 slti $t7, $t0, 100 # i < 100? bne $t7, $zero, LOOP Vectores a y b y variable sum comienzan a partir de direcciones de memoria indicadas por rótulos A, B y SUM. Variable i asignada a registro $t0. ¿Posible optimizar código?

Ejemplo (optimizado) Código assembly para el siguiente código C: i = 0; sum = 0; do { sum = sum + a[i] * b[i]; i++; } while (i < 100) li $t0, 0 # i = 0; li $t1, 0 # $t1 = 0 (sum temporal) la $t3, A # $t3 = dirección a[0] la $t4, B # $t4 = dirección b[0] LOOP: add $t6, $t3, $t0 # $t6 = dirección a[i] lw $t7, 0($t6) # $t7 = a[i] add $t6, $t4, $t0 # $t6 = dirección b[i] lw $t8, 0($t6) # $t8 = b[i] mul, $t8, $t7, $t8 # $t8 = a[i]*b[i] add $t1, $t1, $t8 # $t1 = sum + a[i]*b[i] add $t0, $t0, 4 # i = i + 1 slti $t7, $t0, 400 # i < 100? bne $t7, $zero, LOOP la $t2, SUM sw, $t1, 0($t2) # sum = sum + a[i] * b[i] Vectores a y b y variable sum comienzan a partir de direcciones de memoria indicadas por rótulos A, B y SUM. Variable i asignada a registro $t0.

Otras instrucciones syscall Llamado a sistema: syscall (código en registro $v0) break Excepción: break #código nop No hace nada: nop eret (MIPS32, anterior rfe) Retorno de excepción: eret Restaura registro de estado y máscara de interrupciones Instrucciones de coprocesadores y punto flotante Instrucciones al TLB Instrucciones para acceso no alineado a memoria Pseudoinstrucciones Instrucciones assembly que no existen en el lenguaje de máquina Ejemplos: li, la Ensamblador las traduce a una o más instrucciones de máquina (las que sí se pueden ejecutar)

syscall

Llamado a sistema: syscall (código en registro $v0)

break

Excepción: break #código

nop

No hace nada: nop

eret (MIPS32, anterior rfe)

Retorno de excepción: eret

Restaura registro de estado y máscara de interrupciones

Instrucciones de coprocesadores y punto flotante

Instrucciones al TLB

Instrucciones para acceso no alineado a memoria

Pseudoinstrucciones

Instrucciones assembly que no existen en el lenguaje de máquina

Ejemplos: li, la

Ensamblador las traduce a una o más instrucciones de máquina (las que sí se pueden ejecutar)

Tabla resumen Syscall

Ensamblador MIPS Ventajas de lenguaje assembly versus lenguaje de máquina Mnemónicos Texto que representa operandos e instrucciones en vez de ceros y unos Definición de constantes y datos en memoria Directivas al ensamblador Entregan información al ensamblador sobre cómo traducir el código assembly Rótulos (labels) Texto que representa valores constantes o direcciones de memoria Pseudoinstrucciones Instrucciones assembly que se traducen a unas pocas instrucciones de máquina Algunas utilizan registro $at como temporal Ensamblador realiza traducción de assembly a lenguaje de máquina

Ventajas de lenguaje assembly versus lenguaje de máquina

Mnemónicos

Texto que representa operandos e instrucciones en vez de ceros y unos

Definición de constantes y datos en memoria

Directivas al ensamblador

Entregan información al ensamblador sobre cómo traducir el código assembly

Rótulos (labels)

Texto que representa valores constantes o direcciones de memoria

Pseudoinstrucciones

Instrucciones assembly que se traducen a unas pocas instrucciones de máquina

Algunas utilizan registro $at como temporal

Ensamblador realiza traducción de assembly a lenguaje de máquina

Rótulos Texto seguido de dos puntos (:) Entrega nombre a dirección de memoria Ejemplo También utilizado para datos Ejemplo: nombrar constantes Ejemplo: nombrar direcciones de datos Pueden ser locales a módulo (archivo) o globales para todo el programa Ejemplo: para hacer símbolo MAIN global LOOP: add $4, $4, $2 j LOOP CONST = 2 … li $5, CONST .globl MAIN RES: .word 5 … la $t0, RES lw $t1, 0($t0)

Texto seguido de dos puntos (:)

Entrega nombre a dirección de memoria

Ejemplo

También utilizado para datos

Ejemplo: nombrar constantes

Ejemplo: nombrar direcciones de datos

Pueden ser locales a módulo (archivo) o globales para todo el programa

Ejemplo: para hacer símbolo MAIN global

Mapa de memoria Texto código del programa Heap Memoria dinámica variables globales (estática) Stack Variables locales del procedimiento activo Reservado Estructuras del sistema operativo

Texto

código del programa

Heap

Memoria dinámica

variables globales (estática)

Stack

Variables locales del procedimiento activo

Reservado

Estructuras del sistema operativo

Algunas directivas al ensamblador .data Texto que sigue representa datos almacenados en el heap .text Texto que sigue representa instrucciones almacenadas en área de texto (código) .kdata Texto que sigue representa datos en área de datos del kernel (sistema operativo) .ktext Texto que sigue representa código en área de kernel .globl LABEL Rótulo LABEL es global (visible a todo el programa) .ascii str Almacenar string de texto str en ASCII sin un NULL al final .asciiz str Almacenar string de texto str en ASCII con un NULL (0) al final .word w1 … wn Almacenar n palabras (32b) en posiciones consecutivas de memoria .half h1 … hn Almacenar n medias palabras (16b) en posiciones consecutivas de memoria .byte b1 … bn Almacenar n bytes (8b) en posiciones consecutivas de memoria

Ejemplo .data TEXTOSINULL: .ascii “texto 1” TEXTOCONUL: .asciiz “texto 2” DATOS: .word 16 124 1000 .text .globl MAIN MAIN: la $8, TEXTOSINUL la $9, TEXTOCONUL la $10, DATOS lw $11, 0($10) lw $12, 4($10) lw $13, 8($10)

Procedimientos Son un componente importante en la estructura y modularidad de programas Llamado y retorno requiere un protocolo del que llama y el que es llamado Protocolo está basado en convención

Son un componente importante en la estructura y modularidad de programas

Llamado y retorno requiere un protocolo del que llama y el que es llamado

Protocolo está basado en convención

Protocolo Procedimientos/funciones Cada máquina y compilador tiene su propio protocolo Protocolo esta determinado por HW y SW Instrucción “jal” es HW Usar registro $29 como $sp es SW (convención) Protocolo está determinado por una secuencia de pasos que se siguen por cada llamado y retorno En RISC HW realiza instrucciones sencillas SW controla (compilador/ensamblador) controla secuencia de instrucciones Registros utilizados $ra $a0-$a3 $v0-$v2 $29 para puntero a stack Instrucciones jal, jr

Cada máquina y compilador tiene su propio protocolo

Protocolo esta determinado por HW y SW

Instrucción “jal” es HW

Usar registro $29 como $sp es SW (convención)

Protocolo está determinado por una secuencia de pasos que se siguen por cada llamado y retorno

En RISC

HW realiza instrucciones sencillas

SW controla (compilador/ensamblador) controla secuencia de instrucciones

Registros utilizados

$ra

$a0-$a3

$v0-$v2

$29 para puntero a stack

Instrucciones

jal, jr

Ejemplo procedimiento simple int len; char[20] str; … len = strlen(str); … int strlen(char *str) { int len = 0; while (*str != 0) { str = str + 1; len = len + 1; } return len; } la $a0, str # $a0 = str jal STRLEN; # resultado retorna en $v0 STRLEN: li $v0, 0 # len = 0 WHILE: lb $t0, 0($a0) # $t0 = *str beq $t0, $zero, FIN_WHILE # if (*str == 0) goto FIN_W addi $a0, $a0, 1 # str = str + 1 addi $v0, $v0, 1 # len = len + 1 b WHILE # goto WHILE FIN_W: jr $ra # return len Utilizar convención estándar de uso de registros MIPS

Otro ejemplo procedimiento int i; int a[100], b[100] … res = punto(a, b, 100); … int prod_punto(int v1[], int v2[], int n) { int i = 0; suma = 0; do { suma = suma + v1[i] * v2[i]; i++; } while (i < n) return suma; } la $a0, A # $a0 = &(a[0]) la $a1, B # $a1 = &(b[0]) li $a2, 100 # $a2 = 100 jal PUNTO # resultado en $v0 la $t0, RES sw $v0, 0($t0) … PUNTO: li $t0, 0 # i = 0 li $v0, 0 # suma = 0 WHILE: sll $t1, $t0, 2 # $t1 = i*4 add $t2, $a0, $t1 # $t2 = &(v1[i]) lw $t3, 0($t2) # $t3 = v1[i] add $t2, $a1, $t1 # $t2 = &(v2[i]) lw $t4, 0($t2) # $t4 = v2[i] mult $t3, $t3, $t4 # $t3 = v1[i] * v2[i] add $v0, $v0, $t3 # suma = suma +… addi $t0, $t0, 1 # i = i + 1 slt $t3, $t0, $a2 # i < n? bne $t3, $zero, WHILE jr $ra

Qué hacer cuando los registros no son suficientes? Algunas preguntas Registros para paso de argumentos: $a0-$a3 ¿Qué hacer cuando hay más de 4 argumentos? Retorno de valor: $v0-$v1 ¿Qué hacer cuando el valor de retorno utiliza más de dos palabras (ej. una estructura)? Registros preservados por procedimiento invocado: $s0-$s7 ¿Dónde debe respaldarlos el procedimiento? Registros preservados por procedimiento que invoca: $t0-$t9 ¿Dónde respaldarlos? Dirección de retorno almacenada en: $ra ¿Qué hacer con su contenido si procedimiento invoca a otro procedimiento? En general, ¿qué hacer cuando se nos acaban los registros que estamos utilizando?

Algunas preguntas

Registros para paso de argumentos: $a0-$a3

¿Qué hacer cuando hay más de 4 argumentos?

Retorno de valor: $v0-$v1

¿Qué hacer cuando el valor de retorno utiliza más de dos palabras (ej. una estructura)?

Registros preservados por procedimiento invocado: $s0-$s7

¿Dónde debe respaldarlos el procedimiento?

Registros preservados por procedimiento que invoca: $t0-$t9

¿Dónde respaldarlos?

Dirección de retorno almacenada en: $ra

¿Qué hacer con su contenido si procedimiento invoca a otro procedimiento?

En general, ¿qué hacer cuando se nos acaban los registros que estamos utilizando?

Datos locales y procedimientos recursivos Respuesta: el único lugar donde pueden almacenarse estos datos es la memoria Alternativa 1: almacenarlos en área de memoria global asociada al procedimiento PROC1: move $t0, $a0 … la $s0, PROC1_MEM sw $t0, 0($s0) sw $ra, 4($s0) jal PROC2 lw $t0, 0($s0) lw $ra, 4($s0) … jr $ra Ahora PROC2 puede sobreescribir $t0 y $ra sin problemas PROC1_MEM $t0 $ra Problema: ¿Qué pasa si PROC1 es recursivo? Direcciones de memoria

Respuesta: el único lugar donde pueden almacenarse estos datos es la memoria

Alternativa 1: almacenarlos en área de memoria global asociada al procedimiento

Procedimientos y stacks Alternativa 2 : definir un área de memoria asociada a cada activación de cada procedimiento Estructura dinámica de llamado a procedimientos asemeja una pila (stack) Retornan en el sentido inverso en el que fueron invocados Memoria para almacenamiento de datos locales también se estructura como un stack A A A A A B B B C A: call B B: call C C: ret ret … …

Alternativa 2 : definir un área de memoria asociada a cada activación de cada procedimiento

Estructura dinámica de llamado a procedimientos asemeja una pila (stack)

Retornan en el sentido inverso en el que fueron invocados

Memoria para almacenamiento de datos locales también se estructura como un stack

Stacks de memoria Almacenan ambientes asociados a procedimientos anidados (marco de activación) Dirección de retorno Argumentos Variables locales Valor de retorno Registros salvados por el procedimiento

Almacenan ambientes asociados a procedimientos anidados (marco de activación)

Dirección de retorno

Argumentos

Variables locales

Valor de retorno

Registros salvados por el procedimiento

Soporte para stacks Stack pointer (SP) Apunta al tope del stack Usado para agregar y sacar datos a stack Frame pointer (FP) Apunta a base del bloque de activación (stack frame) Usado para accesar variables locales y argumentos sin removerlos del stack Operaciones PUSH POP CALL RETURN Soporte ISA para stacks En el lenguaje de máquina: VAX, Intel, registros e instrucciones específicas Por convención de software: MIPS Soporte mínimo: jal, jr Argumentos Registros salvados por el llamado Variables locales Evaluación de expresiones (dinámico) FP SP

Stack pointer (SP)

Apunta al tope del stack

Usado para agregar y sacar datos a stack

Frame pointer (FP)

Apunta a base del bloque de activación (stack frame)

Usado para accesar variables locales y argumentos sin removerlos del stack

Operaciones

PUSH

POP

CALL

RETURN

Soporte ISA para stacks

En el lenguaje de máquina: VAX, Intel, registros e instrucciones específicas

Por convención de software: MIPS

Soporte mínimo: jal, jr

Ejemplo: Cadena de llamados Estructura de código p1(…) { • • p2(); • • } p2(…) { • • • p3(); • • • p3(); • • • } p3(…) { • • p3(); • • } p1 p2 p3 p3 p3 Cadena de llamados Procedimiento p3 es recursivo p3

p1(…)

{





p2();





}

p2(…)

{

• • •

p3();

• • •

p3();

• • •

}

p3(…)

{





p3();





}

Procedimiento p3 es recursivo

p1 • • • p1 Cadena de llamados p1(…) { • • p2(); • • } Operación del stack Stack Pointer $sp Frame Pointer $fp

p1(…)

{





p2();





}

Operación del stack p1 p2 • • • p1 p2 Cadena de llamados p2(…) { • • • p3(); • • • p3(); • • • } Stack Pointer $sp Frame Pointer $fp

p2(…)

{

• • •

p3();

• • •

p3();

• • •

}

Operación del stack p1 p2 p3 • • • p1 p2 p3 Cadena de llamados p3(…) { • • p3(); • • } Stack Pointer $sp Frame Pointer $fp

p3(…)

{





p3();





}

Operación del stack p1 p2 p3 • • • p1 p2 p3 Cadena de llamados p3(…) { • • p3(); • • } p3 p3 Stack Pointer $sp Frame Pointer $fp

p3(…)

{





p3();





}

Operación del stack p1 p2 p3 • • • p1 p2 p3 Cadena de llamados p3(…) { • • p3(); • • } p3 p3 p3 p3 Stack Pointer $sp Frame Pointer $fp

p3(…)

{





p3();





}

Operación del stack p1 p2 p3 • • • p1 p2 p3 Cadena de llamados p3(…) { • • p3(); • • } p3 p3 amI Stack Pointer $sp Frame Pointer $fp

p3(…)

{





p3();





}

Operación del stack p1 p2 p3 • • • p1 p2 p3 Cadena de llamados p3(…) { • • p3(); • • } p3 p3 Stack Pointer $sp Frame Pointer $fp

p3(…)

{





p3();





}

Operación del stack p1 p2 • • • p1 p2 Call Chain p2(…) { • • • p3(); • • • p3(); • • • } p3 p3 p3 Stack Pointer $sp Frame Pointer $fp

p2(…)

{

• • •

p3();

• • •

p3();

• • •

}

Operación del stack p1 p2 p3 • • • p1 p2 Cadena de llamados p3(…) { • • • • } p3 p3 p3 p3 Stack Pointer $sp Frame Pointer $fp

p3(…)

{









}

Operación del stack p1 p2 • • • p1 p2 Cadena de llamados p2(…) { • • • p2(); • • • p2(); • • • } p3 p3 p3 p3 Stack Pointer $sp Frame Pointer $fp

p2(…)

{

• • •

p2();

• • •

p2();

• • •

}

Operación del stack p1(…) { • • p2(); • • } p1 • • • p1 p2 Cadena de llamados p3 p3 p3 p3 Stack Pointer $sp Frame Pointer $fp

p1(…)

{





p2();





}

Stack (Pila) de Programa Cada programa en ejecución (proceso) tiene un stack Stack: estructura de datos dinámica accesada en LIFO Stack de programa automáticamente asignada por el SO Al comienzo del proceso el registro $sp ($29 en MIPS) es automáticamente cargado a un punto de la primera entrada vacía al tope del stack Después de eso queda a manos del programador el uso del stack Por convención, el stack crece hacia direcciones más bajas Para asignar una nueva entrada (al hacer push), decrementar $sp Para liberar espacio en el tope del stack (al hacer pop), incrementar $sp

Cada programa en ejecución (proceso) tiene un stack

Stack: estructura de datos dinámica accesada en LIFO

Stack de programa automáticamente asignada por el SO

Al comienzo del proceso el registro $sp ($29 en MIPS) es automáticamente cargado a un punto de la primera entrada vacía al tope del stack

Después de eso queda a manos del programador el uso del stack

Por convención, el stack crece hacia direcciones más bajas

Para asignar una nueva entrada (al hacer push), decrementar $sp

Para liberar espacio en el tope del stack (al hacer pop), incrementar $sp

Operación push Push agrega un item en el tope del stack Una instrucción para manipular dato : “sw $6, 0($sp)” Una instrucción para ajustar el puntero al stack : “subu $sp, $sp, 4” antes después 46 -72 ??? 46 -72 127 ??? 8($sp) 4($sp) $sp 12($sp) 8($sp) 4($sp) $ sp 127 $6 127 $6

Push agrega un item en el tope del stack

Una instrucción para manipular dato : “sw $6, 0($sp)”

Una instrucción para ajustar el puntero al stack : “subu $sp, $sp, 4”

Operación pop Pop remueve un item del tope del stack y lo almacena en un registro Una instrucción para ajustar el puntero a stack : “addu $sp, $sp, 4” Una instrucción para manipular el dato : “lw $6, 0($sp)” antes 46 -72 127 46 -72 127 ??? 8($sp) 4($sp) $ sp 12($sp) 8($sp) 4($sp) $sp 127 $6 453 $6 Pasa a ser basura despúes

Pop remueve un item del tope del stack y lo almacena en un registro

Una instrucción para ajustar el puntero a stack : “addu $sp, $sp, 4”

Una instrucción para manipular el dato : “lw $6, 0($sp)”

Requerimientos llamados a procedimiento El que llama debe pasar la dirección de retorno al que es llamado (procedimiento) El que llama debe pasar los parámetros al procedimiento El que llama debe guardar el contenido de los registros que podrían ser usados por el procedimiento El procedimiento debe guardar la dirección de retorno (si es que llama a otro procedimiento o el mismo si es recursivo) El procedimiento debe proporcionar almacenamiento de stack para su propio uso

El que llama debe pasar la dirección de retorno al que es llamado (procedimiento)

El que llama debe pasar los parámetros al procedimiento

El que llama debe guardar el contenido de los registros que podrían ser usados por el procedimiento

El procedimiento debe guardar la dirección de retorno (si es que llama a otro procedimiento o el mismo si es recursivo)

El procedimiento debe proporcionar almacenamiento de stack para su propio uso

Mecanismo Registros son usados Para pasar dirección de retorno en $ra Jal target Para pasar parámetros ($a0 … $a3, a lo más 4) Mantener el valor de $sp Retornando valores de función en $v0, $v1 Stacks son usados para Salvar registros para ser usados por procedimientos Salvar información acerca del que llama (dirección de retorno) Pasar parámetros si se necesita Asignando datos locales para el procedimiento llamado

Registros son usados

Para pasar dirección de retorno en $ra

Jal target

Para pasar parámetros ($a0 … $a3, a lo más 4)

Mantener el valor de $sp

Retornando valores de función en $v0, $v1

Stacks son usados para

Salvar registros para ser usados por procedimientos

Salvar información acerca del que llama (dirección de retorno)

Pasar parámetros si se necesita

Asignando datos locales para el procedimiento llamado

Convención uso de registros Dirección de retorno de función $ra $31 Puntero a la base del stack (Frame Pointer) $fp $30 Puntero al tope del stack (Stack Pointer) $sp $29 Puntero al heap (segmento datos global) $gp $28 Reservados al O.S. $k0-$k1 $26-$27 Temporales no salvados al llamar función $t8-$t9 $24-$25 Temporales salvados al llamar función $s0-$s7 $16-$23 Temporales no salvados al llamar función $t0-$t7 $8-$15 Argumentos en llamada función $a0-$a3 $4-$7 Evaluación expresiones y resultado funciones $v0-$v1 $2-$3 Reservado para temporal del ensamblador $at $1 Cero $zero $0 Uso Nombre Registro

Tareas del que llama y procedimiento llamado en CALL El que llama Salva contenido de registros volatiles ($t0…$t9) teniendo contenidos que deben ser guardados Poner a lo más 4 argumentos en $a0…$a3 Si hay más de 4 argumentos, poner el resto en el stack Llamar a jal instrucción Procedimiento Salva $ra en stack Salva cualquier registro no volátil ($s0…$s7) que se usará

El que llama

Salva contenido de registros volatiles ($t0…$t9) teniendo contenidos que deben ser guardados

Poner a lo más 4 argumentos en $a0…$a3

Si hay más de 4 argumentos, poner el resto en el stack

Llamar a jal instrucción

Procedimiento

Salva $ra en stack

Salva cualquier registro no volátil ($s0…$s7) que se usará

Tareas del que llama y procedimiento llamado en RETURN Procedimiento Restaura cualquier registro no volátil ($s0…$s7) que ha usado Restaura $ra Pone resultados de función en $v0, $v1 Retorna al que llama con instrucción “jr $ra” El que llama Restaura cualquier registro volátil que ha salvado Examina $v0 y $v1 si lo necesita

Procedimiento

Restaura cualquier registro no volátil ($s0…$s7) que ha usado

Restaura $ra

Pone resultados de función en $v0, $v1

Retorna al que llama con instrucción “jr $ra”

El que llama

Restaura cualquier registro volátil que ha salvado

Examina $v0 y $v1 si lo necesita

Ejemplo de un CALL Asumir que los argumentos en $t0 y $t3 y que se desea salvar los contenidos en $t6 y $t7 move $a0,$t0 # argumento 1 en $a0 move $a1,$t3 # argumento 2 en $a1 subu $sp,$sp,8 #espacio para 2 temps en stack sw $t6,8($sp) #salvar $t6 en stack sw $t7,4($sp) #salvar $t7 en stack jal target Asumir que procedimiento no necesita salvar registros target: sw $ra,0($sp) #salva dirección de retorno subu $sp,$sp,4 # en stack

Asumir que los argumentos en $t0 y $t3 y que se desea salvar los contenidos en $t6 y $t7

move $a0,$t0 # argumento 1 en $a0

move $a1,$t3 # argumento 2 en $a1

subu $sp,$sp,8 #espacio para 2 temps en stack

sw $t6,8($sp) #salvar $t6 en stack

sw $t7,4($sp) #salvar $t7 en stack

jal target

Asumir que procedimiento no necesita salvar registros

target: sw $ra,0($sp) #salva dirección de retorno

subu $sp,$sp,4 # en stack

Ejemplo RETURN El procedimiento pondrá valores de retorno en $v0, $v1 addu $sp,$sp,4 #pop lw $ra,0($sp) #dir de retorno en $ra jr $ra #para el que llama El que llama restaura $t6 y $t7 y ajusta stack lw $t6,8($sp) lw $t7,4($sp) addu $sp,$sp,8

El procedimiento pondrá valores de retorno en $v0, $v1

addu $sp,$sp,4 #pop

lw $ra,0($sp) #dir de retorno en $ra

jr $ra #para el que llama

El que llama restaura $t6 y $t7 y ajusta stack

lw $t6,8($sp)

lw $t7,4($sp)

addu $sp,$sp,8

Ejemplo: Factorial recursivo int factorial(int n) { if (n == 0) return 1; else return n * factorial(n-1); } FACT: bne $a0, $0, L1 # saltar si n != 0 li $v0, 1 # retornar 1 jr $ra L1: addiu $sp, $sp, -12 # tamaño del nuevo stack es 12 bytes sw $fp, 0($sp) # almacenar $fp en el stack sw $ra, 4($sp) # almacenar $ra en el stack addiu $fp, $sp, 8 # $fp apunta al principio del stack sw $a0, 0($fp) # almacenar n en el stack addiu $a0, $a0, -1 # n - 1 jal FACT # resultado en $v0 lw $a0, 0($fp) # recuperar n lw $ra, 4($sp) # recuperar direccion de retorno lw $fp, 0($sp) # recuperar $fp addiu $sp, $sp, 12 # restaurar stack original $sp mul $v0, $v0, $a0 # n * fact(n-1) jr $ra Mostrar ejemplos usando fp y no usando fp, usando ConTEXT Ejercicio: hacer dibujo con marcos de activación y cadena de llamados

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 Efecto colateral (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.

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

Efecto colateral (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

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

Atención de excepciones en MIPS Registros que controlan estado de procesador Parte del coprocesador 0 Accesados mediante instrucciones mfc0 y mtc0

Registros que controlan estado de procesador

Parte del coprocesador 0

Accesados mediante instrucciones mfc0 y mtc0

Registro Causa

Registro de estado Excepciones e interrupciones causan al procesador MIPS saltar a una porción de código a la dirección 0x80000180 (en modo kernel) llamado exception handler o manejador de interrupciones Este código examina causa de excepción y salta al punto apropiado de la rutina de atención de la excepción que ocurrió ( en el SO).

Excepciones e interrupciones causan al procesador MIPS saltar a una porción de código a la dirección 0x80000180 (en modo kernel) llamado exception handler o manejador de interrupciones

Este código examina causa de excepción y salta al punto apropiado de la rutina de atención de la excepción que ocurrió ( en el SO).

#clear presentations

Add a comment

Related pages

S – Wikipedia

S beziehungsweise s (gesprochen: [ʔɛs]) ist der 18. Buchstabe des klassischen und der 19. Buchstabe des modernen lateinischen Alphabets. Er ist ein Konsonant
Read more

Mode, Kleidung und Accessoires im s.Oliver Online Shop kaufen

Mode und Accessories für Damen, Herren und Kinder im s.Oliver Online Shop bestellen. Täglich neue Styles!
Read more

s – Wiktionary

Alle weiteren Informationen zu diesem Wort befinden sich im Eintrag „S“. Ergänzungen sollten daher auch nur dort vorgenommen werden.
Read more

Unsere Bestseller für Damen bequem im s.Oliver Online Shop ...

Mit den Bestsellern von s.Oliver liegen Frauen voll im Trend. Unsere Bestseller in Top-Qualität gibt es im Online Shop von s.Oliver zu kaufen.
Read more

Themen alphabetisch: S - Schlagwörter - FOCUS Online

Wichtige Themen: auf einen Blick Nachrichten, Archiv-Material, Fotos und Videos von FOCUS Online. Alphabetisch sortiert, Anfangsbuchstabe S
Read more

AT&S - hochwertige Leiterplatten Technologie und Erzeugung

AT&S ist Technologieführer bei Leiterplatten: Mobile Devices, Automotive & Aviation, Industrial, Medical & Healthcare und Advanced Packaging tätig.
Read more

S-Broker - Aktien günstig online handeln

S Broker - Top Online Broker der Sparkassen-Finanzgruppe - günstige Konditionen und professioneller online Wertpapierhandel - börslich und außerbörslich.
Read more

Levi's Jeans, Jacken & Kleidung | im offiziellen Levi's ...

Lerne die aktuelle Levi's Kollektion für Damen & Herren kennen und entdecke tolle Jeans, Jacken & mehr im offiziellen Levi's Deutschland Online Store.
Read more

S & S Elektro-Fachgroßhandlung GmbH

Innovationsschau 2016. save the day! Die KfW fördert moderne Türkommunikation und Alarmanlagen. Jetzt bis zu 5.000,00 Euro Zuschuss sichern ...
Read more

Willkommen in Berlin - S-Bahn Berlin GmbH

Offizielle Homepage der S-Bahn Berlin GmbH. Fahrplan, Routenplaner, Erlebnis-Stadtplan, Tickets, Veranstaltungen, Ausflugstipps und vieles mehr.
Read more