ISAInstruction Set ArchitectureCecilia Hernndezcecihernandez@udec.cl

Estructura de un Sistema Computacional

Compilador o Intrprete

SeccindeControl

SeccindeDatos

CPU

Memoria

Mdulos deEntrada

Mdulos deSalida

FwyHw

Interfaz de SwISA

Sistema Operativo

Aplicaciones

Sw

Traduciendo y ejecutando un programaPrograma CPrograma en lenguaje ensambladorCd. Objeto: mdulo en lenguaje de mquinaCod. Objeto: BibliotecasCod. Ejecutable: Prog. Leng. MquinaMemoriaCompiladorEnsambladorLinkerLoader

Interfaz HW/SW

swap (int v[], int k){ int tmp;tmp=v[k];v[k]=v[k+1];v[k+1]=tmp;}

swap: muli $2,$5,4 add $2,$4,$2 lw $15,0($2) lw $16,4($2) sw $16,0($2) sw $15,4($2) jr $31

Programa C

Programa Assembler

Programa Lenguaje Mquina

Instrucciones Directas a la CPU

Compilador C

Ensamblador

000100 00101 00010 0000000000000100000000 00100 00010 00010 00000 000001100011 00010 01111 0000000000000000100011 00010 10000 0000000000000100101011 00010 10000 0000000000000000101011 00010 01111 0000000000000100000000 11111 00000 00000 00000 001000

ConvencionesUNIXP.c : archivo fuente en lenguaje CP.s : archivo fuente en lenguaje ensambladorP.o : archivo objeto P.a : biblioteca estticamente linkeadaP.so : biblioteca dinmicamente linkeadaa.out : archivo ejecutable por defectoMS-DOSP.C : archivo fuente en lenguaje CP.ASM : archivo fuente en lenguaje ensambladorP.OBJ : archivo objeto P.LIB : biblioteca estaticamente linkeadaP.DLL : biblioteca dinmicamente linkeadaP.EXE: archivo ejecutable

Qu es una instruccin?Comando que le dice a la CPU que operacin realizarMediante cdigo de operacinTodas las instrucciones estn codificadasDonde se encuentran los operandos necesarios para ejecutar la operacinISA de una instruccin especificaCdigo de operacinCuntos operandos son necesarios, tipos, tamaos, ubicacinOperandosRegistros (enteros, punto flotante, PC)Direccin de memoriaConstantes

Ejecucin de instruccin de mquinaCPU ejecuta instrucciones de un programa cicloInstrucciones especifican operaciones sobre operandos y generan resultadosDatos pueden encontrarse en memoria (RAM, ROM) o en registros internos al procesadorInstrucciones pueden tambin modificar el flujo de control (saltos, llamadas a procedimiento)Instrucciones pueden crear excepciones

Leer Instruccin

Decodificar

Leer Operandos

Ejecutar Instruccin

Almacenar Resultados

Clculo Sgte Instruccin

Arquitectura de Conjunto de Instrucciones ISAVisin del programador de bajo nivel o del compiladorElementos que definen la ISAOperaciones (instrucciones) suma, multiplicacin, saltos, entrada/salidaTipos de datosEntero, punto flotante, stringsNmero y forma de acceder a operandos y resultados0,1,2,3 operandos, residentes en memoria o registros internosFormato (codificacin) de instrucciones y datosComplemento a 2, punto flotante IEEEEspacio de memoria y nmero de registrosCondiciones excepcionalesDivisin por cero, excepcin de memoria virtual, llamada a sistema operativo

MIPSUna familia de procesadores32 bits : R2000/300064 bits : R4000/4400, R10000Parti como proyecto de investigacin en Stanford y luego form compaa MIPS, que posteriormente compr Silicon GraphicsProviene de mquinas DECMIPS es RISCActualmente usados en mercados de sistemas encrustrados o embebidosRouters CISCO, modems cable (modula seales de comunicacin sobre infraestructura de TV cable), impresoras laser, Sony playstation 2, computadores handheldhttp://www.mips.com/content/Markets/MIPSBased/content_html

Aplicaciones del procesador MIPS

Almacenamiento en MIPS

$0

$1

...

$31

CPU

ALU

HI

LO

Mult/DivEnteros

PC

$f0

$f1

...

$f31

Aritmtica FP

Coprocesador 1

Cause

Status

BadVAddress

EPC

Coprocesador 0

Memoria

Registros MIPSRegistros de propsito generalUn banco de registro de 32 registros de 32 bits direccionados $0, $1,, $31Aritmtica entera y lgica clculo de direcciones, operaciones de propsito especfico como Puntero al Stack (pila)Un banco de registros punto flotante. Registros de 32 bits direccionados $f1, $f2,$f31 usados para aritmtica punto flotante Registros de propsito especfico2 registros de 32 bits (HI, LO) usados para multiplicacin y divisinUn registro Contador de Programas (PC)Registro de estado (coprocesador 0) almacena causa de excepcin datos relacionados a excepcinISA con registros generales tambin son llamadas Ortogonales Operaciones son independientes de los registrosISA MIPS define Convencin Software para uso de registrosNo es obligatoria, no es forzada por hardware

Convencin de uso de registros MIPS$0 zero constante cero$1 at reservado para ensamblador$2 v0 evaluacin 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 funcin. que invoca. (funcin invocada puede . sobreescribir)

$15 t7$16 s0 temporales respaldados por. funcin invocada. (funcin 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 direccin de retorno de funcin

MIPS=RISC = Arquitectura load/storeALU opera slo en operandos que estn en registrosA excepcin de enteros pequeos que pueden estar en la misma instruccin, como se ver ms 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 instruccionesLas nicas instrucciones que accesan la memoria son del tipo load/storeSe necesitan instrucciones explcitas para realizar operaciones de load y storeResultados obtenidos de otras operaciones deben ser stored en memoria

EjemploSentencia expresada en un lenguaje de programacin de alto nivelx = y + zw = x + ySe traduce en lenguaje assembly (ensamblador) como (asumiendo operandos estn en memoria)load y en registro ryload z en registro rzrx

Programando en lenguaje ensambladorUsar muchos comentarios para describir lo que se esta haciendoUsar words en lugar de bytes en lo posibleLa siguiente direccin a dato expresado en words es direccin + 4Direcciones de words son divisibles por 4

Tipos de instrucciones en MIPSAritmticasOperaciones con enteros (con y sin signo)Operaciones con punto flotanteLgicas y de desplazamientoAnds, ors, entre otrosDesplazamiento de bits (izquierda, derecha)Load/storeVariables son cargadas en registros (load)Desde memoria a registros o constantes a registrosResultados se graban en memoria (store)Comparacin de valores en registrosSaltos condicionales (branches) y absolutos (jumps)Manipulan control de flujoIncluyen llamados a procedimientos y retornos

Aritmtica enteraNmeros pueden ser con o sin signoInstrucciones aritmticas (+,-,/,*) existen para ambos tipos de enteros (diferenciado por cdigo de operacin)add, addu, sub, subuaddi, addiu, subi, subiumult, multu, div, divuNmeros con signo son representados en complemento a 2En caso de overflow se genera excepcin

Notacin en SPIMCdigo operacin rd, rs, rtInstrucciones aritmeticas, lgicas, comparacionesCdigo operacin rt, rs, immediatoInstrucciones aritmticas, lgicas, load/store, saltos condicionalesCdigo operacin immediatoInstrucciones de salto absolutoDonde:rd siempre es el registro destinors siempre es el registro fuente (de slo lectura)rt puede ser fuente o destino depende del cdigo de operacinImmediato es una constante de 16 bits (con o sin signo)

Instrucciones aritmticas en SPIMNo confundirlo con la codificacin de instrucciones que se ver pronto

Instrucciones aritmticasadd $1,$2,$3#$1 = $2 + $3. Posible overflowsub $1,$2,$3#$1 = $2 $3. Posible overflowaddi $1,$2,100#$1 = $2 + 100. Posible overflowaddu $1,$2,$3#$1 = $2 + $3. Suma sin signo sin overflowsubu $1,$2,$3#$1 = $2 $3. Resta sin signo sin overflowaddiu $1,$2,100#$1 = $2 + 100. Suma sin signo sin overflowmult $2,$3#HI, LO = $2 x $3multu$2,$3#HI, LO = $2 x $3. Producto sin signodiv $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

EjemplosAdd$8,$9,$10#$8=$9+$10Add$t0,$t1,$t2#$t0=$t1+$t2Sub$s2,$s1,$s0#$s2=$s1-$s0

Addi$a0,$t0,20#$a0=$t0+20Addi$a0,$t0,-20#$a0=$t0-20

Addi$t0,$0,0#clear $t0Sub$t5,$0,$t5#$t5 = -$t5

Instrucciones lgicasand $1,$2,$3#$1 = $2 && $3or $1,$2,$3#$1 = $2 || $3xor $1,$2,$3#$1 = ~($2 || $3)nor $1,$2,$3#$1 = ~($2 || $3)andi $1,$2,10#$1 = $2 && 10ori $1,$2,10#$1 = $2 || 10xori $1, $2,10 #$1 = ~$2 && ~10sll $1,$2,10#$1 = $2 > 10. Desplazamiento lgicosra $1,$2,10#$1 = $2 >> 10. Desplazamiento aritmticosllv $1,$2,$3#$1 = $2 > $3. Desplazamiento lgicosrav $1,$2, $3 #$1 = $2 >> $3. Desplazamiento aritmtico

Movimiento entre registrosmove $2,$3# $2 $3 (PseudoInstruccin)mflo $2# $2 LO. Copia LO en $2mfhi $2# $2 HI. Copia HI en $2mtlo $2# LO $2. Copia en LO $2mthi $2# $2 HI. Copia en HI $2lui $3, 500# $3 500 * 216. Carga el valor # constante de 16b en la parte# ms significativa de $3mfc0 $1, $epc# $1 direccin de instruccin que # caus excepcin

Acceso a memoriaMueven datos entre registros y memoriaModo de direccionamiento nicobase + desplazamientoBase: contenido de registroDesplazamiento: constante de 16 bitsLoadlwrt,rs,offset#rt = Memory[rs+offset]lw $1, 100($2)# $1 Mem[$2 + 100]Storelwrt,rs,offset#Memory[rs+offset]=rtsw $1, 100($2)# $1 -> Mem[$2 + 100]

Instrucciones load/storesw $3, 500($2)# Mem(500+$2) $3. Almacena 32bsh $3, 500($2) # Mem(500+$2) $3. Almacena 16bsb $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 signolb $3, 500($2)# $3 Mem(500+$2). Carga 8b

la $3, Label# $3 Address. Carga la direccin # efectiva asociada a Label en $3Direccin efectiva: nmero que indica direccin del operando en memoria

Algunas pseudoinstruccionesmove $4, $5# $4 $5# or $4, $zero, $5

li $4, 100# $4 100# ori $4, $zero, 100

la $4, LABEL32# $4 LABEL# lui $4, LABEL16bsuperiores# ori $4, $4, LABEL16binferiores

bgt $4, CTE, LABEL# if ($4 > CTE) goto LABEL# slti $at, $4, CTE+1# beq $at, $zero, LABEL

Ejemploint a, b, acum;acum = acum + a * b;# Direccin de memoria de a en rtulo DIR_A# Direccin de memoria de b en rtulo DIR_B# Direccin de memoria acum en rtulo DIR_ACUM

la $v0, DIR_A # cargar direccin de ala $v1, DIR_B # cargar direccin de b

lw $t0, 0($v0) # leer alw $t1, 0($v1) # leer b

mul $t2, $t0, $t1 # t2 = a * b

la $v2, DIR_ACUM# cargar direccin de acumlw $t3, 0($v2)# leer acum

add $t3, $t3, $t2# $t3 = acum + a * bsw $t3, 0($v2)# guardar acum102DIR_ADIR_BDIR_ACUM50Memoria$v0$v1$v2$t0$t1$t2$t3100010121022010245070701000100410081012101610201024abacum

Ejemplotypedef struct { int x; int y;} coord;

coord c1, c2;int dist;dist = abs(c2.x c1.x) + abs(c2.y c1.y);# Direccin de memoria de c1 en rtulo DIR_C1# Direccin de memoria de c2 en rtulo DIR_C2# Direccin de memoria de dist en rtulo DIR_DIST

la $v0, DIR_C1# cargar direccin de c1la $v1, DIR_C2 # cargar direccin de c2

lw $t0, 0($v0) # leer c1.xlw $t1, 0($v1) # leer c2.xsub $t2, $t1, $t0 # t2 = c2.x c1.xabs $t3, $t2# t3 = abs(c2.x c1.x)

lw $t0, 4($v0) # leer c1.ylw $t1, 4($v1) # leer c2.ysub $t2, $t1, $t0 # t2 = c2.y c1.yabs $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 direccin de distsw $t3, 0($v0)# dist = abs(c2.x c1.x) +# abs(c2.y c1.y)c1.xc1.yc2.xc2.yDirecciones de memoriaDIR_C1DIR_C1 + 4DIR_C2DIR_C2 + 4DIR_DISTdistMemoria

Ejecucin condicional de instruccionesPermiten ejecutar partes de un programa slo si se cumple una determinada condicinEj. Estructuras tipo if-else, for, while, switch-caseTpicamente saltos, pero tambin escritura a registroCmo especificar la condicin?Comparacin en la instruccinbgt r1, r2, ADDR # if r1 > r2 goto ADDRRegistro de condicin (MIPS)cmp r1, r2, r3# r3 = signo (r1-r2) bgtz r1, ADDR# if r1 > 0 goto ADDR

Instrucciones ISA MIPS Instrucciones de comparacinEvala condicin entre dos operandosResultado es VERDADERO o FALSOUtilizan registro de condicinResultado de comparacin se almacena en registro destinoFALSO regDest = 0VERDADERO regDest = 1Ejemplo:add $1, $2, $3slt $4, $1, $0# if $1 < $0 then $4 = 1# else #4 = 0

Algunas instrucciones de comparacinslt $1,$2,$3# if ($2 < $3) $1= 1 else $1 = 0sltu $1,$2,$3# if ($2 < $3) $1 = 1 else $1 = 0(sin signo)slti $1, $2, 100# if ($2 < 100) $1 = 1 else $1 = 0sltiu $1, $2, 100# if ($2 < 100) $1 = 1 else $1 = 0(sin signo)

Pseudoinstrucciones (se traducen en ms de una instruccin de mquina):

seq $1, $2, $3$if ($2 == $3) $1 = 1 else $1 = 0sne $1, $2, $3$if ($2 != $3) $1 = 1 else $1 = 0sgt $1, $2, $3$if ($2 > $3) $1 = 1 else $1 = 0sge $1, $2, $3$if ($2 >= $3) $1 = 1 else $1 = 0sle $1, $2, $3$if ($2

Instrucciones de salto MIPSSaltos condicionalesbeq $1,$2,CLabel# if ($1==$2) goto CLabel ;bne $1,$2,CLabel# if ($1!=$2) goto CLabel ;bgez $1, Clabel# if ($1 >=0) goto Clabelbgtz, $1, Clabel# if ($1 >0) goto Clabelblez, $1, Clabel# if ($1$2) goto CLabel ;bgtu $1,$2,CLabel # if ($1>$2) goto CLabel ;# Comparacin sin signoble $1,$2,CLabel # if ($1

Instrucciones de transferencia de controlRegistro de contador de programaProgram Counter (PC)Almacena direccin de siguiente instruccin a ejecutarPor defecto, instruccin fsicamente siguiente a la actual (PC PC + 4)Modificacin del flujo de control de un programaTipos de salto (especificacin de direccin destino)Absoluto: instruccin especifica directamente direccin destinoRelativo: instruccin especifica desplazamiento respecto de instruccin actualTipos de salto (ejecucin condicional)Incondicional: salto se realiza de todas formasCondicional: salto se realiza slo si se cumple una condicinLa mayora de las ISA usan dos tipos de saltojump: absoluto e incondicionalbranch: relativo y condicional

SaltosOtros tipos de saltoSalto a procedimiento: almacena direccin de retornoRetorno de procedimiento: retorna a instruccin siguiente a la que hizo el salto a procedimientoLlamado a sistema: salta a direccin predeterminada y pasa a modo supervisorRetorno de excepcin o llamado a sistema: retorna a instruccin que provoc excepcin o llamado a sistema, y restaura modo usuario

Instrucciones de salto MIPSSaltos absolutosj CLabel # PC CLabelSaltos a procedimientojal CLabel # $ra PC; PC CLabel;bgezal $1, CLabel # if ($1>=0) $ra = PC; PC = ClabelRecordar que, durante la ejecucin de una instruccin, PC contiene la direccin de la siguiente instruccin a ejecutar$ra = $31Saltos indexadosjr $ra# PC $ra jalr $1, $2# $2 PC + 4; PC $1

EjemploCdigo assembly para el siguiente cdigo 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 $t2li $t0, 10# a = 10li $t1, 5# b = 5

sle $t3, $t0, $t1# a

EjemploCdigo assembly para el siguiente cdigo 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 = direccin de sumsw $t1, 0($t2)# sum = 0

LOOP:la $t3, A# $t3 = direccin a[0]la $t4, B# $t4 = direccin b[0]

sll $t5, $t0, 2 # $t5 = i*4add $t6, $t3, $t5 # $t6 = direccin a[i]lw $t7, 0($t6) # $t7 = a[i]

add $t6, $t4, $t5 # $t6 = direccin 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, SUMsw, $t1, 0($t2) # sum = sum + a[i] * b[i]

add $t0, $t0, 1 # i = i + 1slti $t7, $t0, 100 # i < 100?bne $t7, $zero, LOOPVectores a y b y variable sum comienzan apartir de direcciones de memoria indicadaspor rtulos A, B y SUM. Variable i asignada a registro $t0.Posible optimizar cdigo?

Ejemplo (optimizado)Cdigo assembly para el siguiente cdigo 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 = direccin a[0]la $t4, B# $t4 = direccin b[0]LOOP:add $t6, $t3, $t0 # $t6 = direccin a[i]lw $t7, 0($t6) # $t7 = a[i]

add $t6, $t4, $t0 # $t6 = direccin 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 + 1slti $t7, $t0, 400 # i < 100?bne $t7, $zero, LOOP

la $t2, SUMsw, $t1, 0($t2) # sum = sum + a[i] * b[i]Vectores a y b y variable sum comienzan apartir de direcciones de memoria indicadaspor rtulos A, B y SUM. Variable i asignada a registro $t0.

Otras instruccionessyscallLlamado a sistema:syscall (cdigo en registro $v0)breakExcepcin:break #cdigonopNo hace nada:noperet (MIPS32, anterior rfe) Retorno de excepcin:eretRestaura registro de estado y mscara de interrupcionesInstrucciones de coprocesadores y punto flotanteInstrucciones al TLBInstrucciones para acceso no alineado a memoriaPseudoinstruccionesInstrucciones assembly que no existen en el lenguaje de mquinaEjemplos: li, laEnsamblador las traduce a una o ms instrucciones de mquina (las que s se pueden ejecutar)

Tabla resumen Syscall

Ensamblador MIPSVentajas de lenguaje assembly versus lenguaje de mquinaMnemnicosTexto que representa operandos e instrucciones en vez de ceros y unosDefinicin de constantes y datos en memoriaDirectivas al ensambladorEntregan informacin al ensamblador sobre cmo traducir el cdigo assemblyRtulos (labels)Texto que representa valores constantes o direcciones de memoriaPseudoinstruccionesInstrucciones assembly que se traducen a unas pocas instrucciones de mquinaAlgunas utilizan registro $at como temporalEnsamblador realiza traduccin de assembly a lenguaje de mquina

RtulosTexto seguido de dos puntos (:)Entrega nombre a direccin de memoriaEjemplo

Tambin utilizado para datosEjemplo: nombrar constantes

Ejemplo: nombrar direcciones de datos

Pueden ser locales a mdulo (archivo) o globales para todo el programaEjemplo: para hacer smbolo MAIN global

LOOP:add $4, $4, $2j LOOP CONST = 2li $5, CONST.globl MAINRES:.word 5la $t0, RESlw $t1, 0($t0)

Mapa de memoriaTextocdigo del programaHeapMemoria dinmicavariables globales (esttica)StackVariables locales del procedimiento activoReservadoEstructuras del sistema operativo

Reservado

0x0040 0000

0x0000 0000

Segmentode Texto

0x1000 0000

Heap

0x7FFF FFFF

Stack

Algunas directivas al ensamblador.dataTexto que sigue representa datos almacenados en el heap.textTexto que sigue representa instrucciones almacenadas en reade texto (cdigo).kdataTexto que sigue representa datos en rea de datos del kernel(sistema operativo).ktextTexto que sigue representa cdigo en rea de kernel.globl LABELRtulo LABEL es global (visible a todo el programa).ascii strAlmacenar string de texto str en ASCII sin un NULL al final.asciiz strAlmacenar string de texto str en ASCII con un NULL (0) al final.word w1 wnAlmacenar n palabras (32b) en posiciones consecutivas de memoria.half h1 hnAlmacenar n medias palabras (16b) en posiciones consecutivas de memoria.byte b1 bnAlmacenar n bytes (8b) en posiciones consecutivas de memoria

Ejemplo.dataTEXTOSINULL:.ascii texto 1TEXTOCONUL:.asciiz texto 2DATOS:.word 16 124 1000

.text.globl MAINMAIN:la $8, TEXTOSINULla $9, TEXTOCONULla $10, DATOSlw $11, 0($10)lw $12, 4($10)lw $13, 8($10)

ProcedimientosSon un componente importante en la estructura y modularidad de programasLlamado y retorno requiere un protocolo del que llama y el que es llamadoProtocolo est basado en convencin

Protocolo Procedimientos/funcionesCada mquina y compilador tiene su propio protocoloProtocolo esta determinado por HW y SWInstruccin jal es HWUsar registro $29 como $sp es SW (convencin)Protocolo est determinado por una secuencia de pasos que se siguen por cada llamado y retornoEn RISCHW realiza instrucciones sencillasSW controla (compilador/ensamblador) controla secuencia de instruccionesRegistros utilizados$ra$a0-$a3$v0-$v2$29 para puntero a stackInstruccionesjal, jr

Ejemplo procedimiento simpleint 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 = strjal STRLEN;# resultado retorna en $v0

STRLEN:li $v0, 0# len = 0

WHILE:lb $t0, 0($a0)# $t0 = *strbeq $t0, $zero, FIN_WHILE# if (*str == 0) goto FIN_W

addi $a0, $a0, 1# str = str + 1addi $v0, $v0, 1# len = len + 1

b WHILE# goto WHILE

FIN_W:jr $ra# return lenUtilizar convencin estndar de uso de registros MIPS

Otro ejemplo procedimientoint 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 = 100jal PUNTO# resultado en $v0la $t0, RESsw $v0, 0($t0)PUNTO:li $t0, 0# i = 0li $v0, 0# suma = 0WHILE:sll $t1, $t0, 2# $t1 = i*4add $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 + 1slt $t3, $t0, $a2# i < n?bne $t3, $zero, WHILEjr $ra

Qu hacer cuando los registros no son suficientes?Algunas preguntasRegistros para paso de argumentos: $a0-$a3Qu hacer cuando hay ms de 4 argumentos?Retorno de valor: $v0-$v1Qu hacer cuando el valor de retorno utiliza ms de dos palabras (ej. una estructura)?Registros preservados por procedimiento invocado: $s0-$s7Dnde debe respaldarlos el procedimiento?Registros preservados por procedimiento que invoca: $t0-$t9Dnde respaldarlos?Direccin de retorno almacenada en: $raQu 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 recursivosRespuesta: el nico lugar donde pueden almacenarse estos datos es la memoriaAlternativa 1: almacenarlos en rea de memoria global asociada al procedimientoPROC1:move $t0, $a0la $s0, PROC1_MEMsw $t0, 0($s0)sw $ra, 4($s0)jal PROC2lw $t0, 0($s0)lw $ra, 4($s0)jr $ra

Ahora PROC2 puede sobreescribir $t0 y $ra sin problemasPROC1_MEM$t0$raProblema: Qu pasa si PROC1 es recursivo?Direccionesde memoria

Procedimientos y stacksAlternativa 2: definir un rea de memoria asociada a cada activacin de cada procedimientoEstructura dinmica de llamado a procedimientos asemeja una pila (stack)Retornan en el sentido inverso en el que fueron invocadosMemoria para almacenamiento de datos locales tambin se estructura como un stack

AAAAABBBCA:call BB:call CC:retret

Stacks de memoriaAlmacenan ambientes asociados a procedimientos anidados (marco de activacin)Direccin de retornoArgumentosVariables localesValor de retornoRegistros salvados por el procedimiento

Soporte para stacksStack pointer (SP)Apunta al tope del stackUsado para agregar y sacar datos a stackFrame pointer (FP)Apunta a base del bloque de activacin (stack frame)Usado para accesar variables locales y argumentos sin removerlos del stackOperacionesPUSHPOPCALLRETURNSoporte ISA para stacksEn el lenguaje de mquina: VAX, Intel, registros e instrucciones especficasPor convencin de software: MIPSSoporte mnimo: jal, jrArgumentosRegistros salvados por el llamadoVariableslocalesEvaluacin deexpresiones(dinmico)FPSP

Ejemplo: Cadena de llamadosEstructura de cdigop1(){p2();}p2(){ p3(); p3(); }p3(){p3();}p1p2p3p3p3Cadena de llamadosProcedimiento p3 es recursivop3

p1

p1Cadena de llamadosp1(){p2();}Operacin del stack

Operacin del stack

p1

p2

p1p2Cadena de llamadosp2(){ p3(); p3(); }

Operacin del stack

p1

p2

p3

p1p2p3Cadena de llamadosp3(){p3();}

Operacin del stack

p1

p2

p3

p1p2p3Cadena de llamadosp3(){p3();}

p3

p3

Operacin del stack

p1

p2

p3

p1p2p3Cadena de llamadosp3(){p3();}

p3

p3p3

p3

Operacin del stack

p1

p2

p3

p1p2p3Cadena de llamadosp3(){p3();}

p3

p3amI

Operacin del stack

p1

p2

p3

p1p2p3Cadena de llamadosp3(){p3();}p3p3

Operacin del stack

p1

p2

p1p2Call Chainp2(){ p3(); p3(); }p3p3p3

Operacin del stack

p1

p2

p3

p1p2Cadena de llamadosp3(){}p3p3p3p3

Operacin del stack

p1

p2

p1p2Cadena de llamadosp2(){ p2(); p2(); }p3p3p3p3

Operacin del stackp1(){p2();}

p1

p1p2Cadena de llamadosp3p3p3p3

Stack (Pila) de ProgramaCada programa en ejecucin (proceso) tiene un stackStack: estructura de datos dinmica accesada en LIFOStack de programa automticamente asignada por el SOAl comienzo del proceso el registro $sp ($29 en MIPS) es automticamente cargado a un punto de la primera entrada vaca al tope del stackDespus de eso queda a manos del programador el uso del stackPor convencin, el stack crece hacia direcciones ms bajasPara asignar una nueva entrada (al hacer push), decrementar $spPara liberar espacio en el tope del stack (al hacer pop), incrementar $sp

Operacin pushPush agrega un item en el tope del stackUna instruccin para manipular dato : sw $6, 0($sp)Una instruccin para ajustar el puntero al stack : subu $sp, $sp, 4antesdespus46-72 ???46-72127 ???8($sp)4($sp)$sp12($sp)8($sp)4($sp)$sp127 $6127 $6

Operacin popPop remueve un item del tope del stack y lo almacena en un registroUna instruccin para ajustar el puntero a stack : addu $sp, $sp, 4Una instruccin para manipular el dato : lw $6, 0($sp)antes46-72 12746-72127 ???8($sp)4($sp)$sp12($sp)8($sp)4($sp)$sp127 $6453 $6Pasa a serbasuradespes

Requerimientos llamados a procedimientoEl que llama debe pasar la direccin de retorno al que es llamado (procedimiento)El que llama debe pasar los parmetros al procedimientoEl que llama debe guardar el contenido de los registros que podran ser usados por el procedimientoEl procedimiento debe guardar la direccin 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

MecanismoRegistros son usadosPara pasar direccin de retorno en $raJal targetPara pasar parmetros ($a0 $a3, a lo ms 4)Mantener el valor de $sp Retornando valores de funcin en $v0, $v1Stacks son usados paraSalvar registros para ser usados por procedimientosSalvar informacin acerca del que llama (direccin de retorno)Pasar parmetros si se necesitaAsignando datos locales para el procedimiento llamado

Convencin uso de registros

RegistroNombre Uso$0$zeroCero$1$atReservado para temporal del ensamblador$2-$3$v0-$v1Evaluacin expresiones y resultado funciones$4-$7$a0-$a3Argumentos en llamada funcin$8-$15$t0-$t7Temporales no salvados al llamar funcin$16-$23$s0-$s7Temporales salvados al llamar funcin$24-$25$t8-$t9Temporales no salvados al llamar funcin$26-$27$k0-$k1Reservados al O.S.$28$gpPuntero al heap (segmento datos global)$29$spPuntero al tope del stack (Stack Pointer)$30$fpPuntero a la base del stack (Frame Pointer)$31$raDireccin de retorno de funcin

Tareas del que llama y procedimiento llamado en CALLEl que llamaSalva contenido de registros volatiles ($t0$t9) teniendo contenidos que deben ser guardadosPoner a lo ms 4 argumentos en $a0$a3Si hay ms de 4 argumentos, poner el resto en el stackLlamar a jal instruccin ProcedimientoSalva $ra en stackSalva cualquier registro no voltil ($s0$s7) que se usar

Tareas del que llama y procedimiento llamado en RETURNProcedimientoRestaura cualquier registro no voltil ($s0$s7) que ha usadoRestaura $raPone resultados de funcin en $v0, $v1Retorna al que llama con instruccin jr $raEl que llamaRestaura cualquier registro voltil que ha salvadoExamina $v0 y $v1 si lo necesita

Ejemplo de un CALLAsumir que los argumentos en $t0 y $t3 y que se desea salvar los contenidos en $t6 y $t7move$a0,$t0# argumento 1 en $a0move$a1,$t3# argumento 2 en $a1subu$sp,$sp,8#espacio para 2 temps en stacksw$t6,8($sp)#salvar $t6 en stack sw$t7,4($sp)#salvar $t7 en stack jaltargetAsumir que procedimiento no necesita salvar registrostarget: sw $ra,0($sp)#salva direccin de retorno subu $sp,$sp,4 # en stack

Ejemplo RETURNEl procedimiento pondr valores de retorno en $v0, $v1addu$sp,$sp,4#poplw$ra,0($sp)#dir de retorno en $rajr$ra#para el que llamaEl que llama restaura $t6 y $t7 y ajusta stacklw$t6,8($sp)lw$t7,4($sp)addu$sp,$sp,8

Ejemplo: Factorial recursivoint 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 # tamao 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 $raMostrar ejemplos usando fp y no usando fp, usando ConTEXTEjercicio: hacer dibujo con marcos de activacin y cadena de llamados

ExcepcionesCondiciones especiales que cambian el flujo de ejecucin normal del programaTipos de excepcionesInterrupcinGenerada en forma externa al procesador, tpicamente por dispositivo de E/S como interfaz de red o discoTrapEfecto colateral (implcito o explcito) de ejecucin de instruccinEj. Divisin por cero, acceso ilegal a memoria, instruccin invlida, syscall, break.

Atencin de excepcionesTpicamenteAlmacenar estado del procesador (PC, registro de condicin, mscara de interrupciones, etc.)Transferir control al sistema operativoPasar a modo de ejecucin supervisorSistema operativo atiende excepcin, restaura el estado y retorna al programa de usuario

Atencin de excepciones en MIPSRegistros que controlan estado de procesadorParte del coprocesador 0 Accesados mediante instrucciones mfc0 y mtc0

Registro Causa

Registro de estadoExcepciones e interrupciones causan al procesador MIPS saltar a una porcin de cdigo a la direccin 0x80000180 (en modo kernel) llamado exception handler o manejador de interrupcionesEste cdigo examina causa de excepcin y salta al punto apropiado de la rutina de atencin de la excepcin que ocurri ( en el SO).