ISA Instruction Set Architecture

Cecilia Hernndez cecihernandez@udec.cl

Estructura de un Sistema Computacional

Aplicaciones Compilador o Intrprete Sistema Operativo

Sw

Interfaz de Sw ISA CPU

Seccin de Control

Mdulos de Entrada Memoria Mdulos de Salida

Fw y Hw

Seccin de Datos

Traduciendo y ejecutando un programa

Programa C Compilador Programa en lenguaje ensamblador Ensamblador

Cd. Objeto: mdulo en lenguaje de mquina

Cod. Objeto: Bibliotecas

Linker Cod. Ejecutable: Prog. Leng. Mquina Loader Memoria

Interfaz HW/SW
swap (int v[], int k) { int tmp; tmp=v[k]; v[k]=v[k+1]; v[k+1]=tmp; Programa Assembler } swap: muli $2,$5,4 add $2,$4,$2 lw $15,0($2) Compilador C lw $16,4($2) sw $16,0($2) sw $15,4($2) Programa Lenguaje Mquina jr $31 000100 00101 00010 0000000000000100
000000 100011 100011 101011 101011 000000 00100 00010 00010 00010 00010 11111 00010 01111 10000 10000 01111 00000

Programa C

Ensamblador

00010 00000 000001 0000000000000000 0000000000000100 0000000000000000 0000000000000100 00000 00000 001000

Instrucciones Directas a la CPU

Convenciones

UNIX

MS-DOS

P.c : archivo fuente en lenguaje C P.s : archivo fuente en lenguaje ensamblador P.o : archivo objeto P.a : biblioteca estticamente linkeada P.so : biblioteca dinmicamente linkeada a.out : archivo ejecutable por defecto

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 dinmicamente linkeada P.EXE: archivo ejecutable

Qu es una instruccin?

Comando que le dice a la CPU que operacin realizar

Mediante cdigo de operacin

Todas las instrucciones estn codificadas

Donde se encuentran los operandos necesarios para ejecutar la operacin Cdigo de operacin Cuntos operandos son necesarios, tipos, tamaos, ubicacin Registros (enteros, punto flotante, PC) Direccin de memoria Constantes

ISA de una instruccin especifica

Operandos

Ejecucin de instruccin de mquina

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 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 ISA

Visin del programador de bajo nivel o del compilador Elementos que definen la ISA

Operaciones (instrucciones)

suma, multiplicacin, saltos, entrada/salida Entero, punto flotante, strings 0,1,2,3 operandos, residentes en memoria o registros internos Complemento a 2, punto flotante IEEE

Tipos de datos

Nmero y forma de acceder a operandos y resultados

Formato (codificacin) de instrucciones y datos

Espacio de memoria y nmero de registros Condiciones excepcionales

Divisin por cero, excepcin 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 investigacin en Stanford y luego form compaa MIPS, que posteriormente compr Silicon Graphics Proviene de mquinas DEC MIPS es RISC Actualmente usados en mercados de sistemas encrustrados o embebidos

Routers CISCO, modems cable (modula seales de comunicacin 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
CPU $0 $1 . . . $31 HI LO PC ALU Coprocesador 1 $f0 $f1 . . . $f31 Mult/Div Enteros Aritmtica FP

Coprocesador 0 Cause Status BadVAddress EPC

Memoria

Registros MIPS

Registros de propsito general

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

Aritmtica 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 2 registros de 32 bits (HI, LO) usados para multiplicacin y divisin Un registro Contador de Programas (PC) Registro de estado (coprocesador 0) almacena causa de excepcin datos relacionados a excepcin

Registros de propsito especfico

ISA con registros generales tambin son llamadas Ortogonales

Operaciones son independientes de los registros No es obligatoria, no es forzada por hardware

ISA MIPS define Convencin Software para uso de registros

Convencin de uso de registros MIPS

$0 zero constante cero $1 at $2 $3 v0 v1 reservado para ensamblador evaluacin de expresiones y resultados de funciones $16 s0 temporales respaldados por . funcin invocada . (funcin que invoca no respalda) . $23 s7 $24 t8 $25 t9 temporales (adicionales)

$4 $5 $6 $7 $8 . . .

a0 a1 a2 a3 t0

argumentos a funciones

$26 k0 $27 k1 variables temporales respaldadas por funcin que invoca (funcin invocada puede sobreescribir) $28 gp $29 sp $30 fp $31 ra

reservados para sistema operativo

puntero a variables globales puntero a tope del stack puntero a base del stack direccin de retorno de funcin

$15 t7

MIPS=RISC = Arquitectura load/store

ALU opera slo en operandos que estn en registros

A 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 instrucciones

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

Se necesitan instrucciones explcitas para realizar operaciones de load y store Resultados obtenidos de otras operaciones deben ser stored en memoria

Ejemplo

Sentencia expresada en un lenguaje de programacin de alto nivel

x=y+z w=x+y

Se traduce en lenguaje assembly (ensamblador) como (asumiendo operandos estn 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 direccin a dato expresado en words es direccin + 4 Direcciones de words son divisibles por 4

Tipos de instrucciones en MIPS

Aritmticas

Operaciones con enteros (con y sin signo) Operaciones con punto flotante Ands, ors, entre otros Desplazamiento de bits (izquierda, derecha) Variables son cargadas en registros (load)

Lgicas y de desplazamiento

Load/store

Desde memoria a registros o constantes a registros

Resultados se graban en memoria (store)

Comparacin de valores en registros Saltos condicionales (branches) y absolutos (jumps)

Manipulan control de flujo Incluyen llamados a procedimientos y retornos

Aritmtica entera

Nmeros pueden ser con o sin signo Instrucciones aritmticas (+,-,/,*) existen para ambos tipos de enteros (diferenciado por cdigo de operacin)

add, addu, sub, subu addi, addiu, subi, subiu mult, multu, div, divu

Nmeros con signo son representados en complemento a 2

En caso de overflow se genera excepcin

Notacin en SPIM

Cdigo operacin

rd, rs, rt
rt, rs, immediato

Instrucciones aritmeticas, lgicas, comparaciones Instrucciones aritmticas, lgicas, load/store, saltos condicionales

Cdigo operacin

Cdigo operacin

immediato

Instrucciones de salto absoluto rd siempre es el registro destino rs siempre es el registro fuente (de slo lectura) rt puede ser fuente o destino depende del cdigo de operacin Immediato es una constante de 16 bits (con o sin signo)

Donde:

Instrucciones aritmticas en SPIM

No confundirlo con la codificacin de instrucciones que se ver pronto

Cdigo Operacin add Operandos rd, rs, rt Comentarios # rd = rs + rt

addi

rt, rs, immediato

# rt = rs + immed

sub

rd, rs, rt

# rd = rs - rt

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

Ejemplos
Add Add Sub
Addi Addi Addi Sub

$8,$9,$10 $t0,$t1,$t2 $s2,$s1,$s0

$a0,$t0,20 $a0,$t0,-20 $t0,$0,0 $t5,$0,$t5

#$8=$9+$10 #$t0=$t1+$t2 #$s2=$s1-$s0

#$a0=$t0+20 #$a0=$t0-20 #clear $t0 #$t5 = -$t5

Instrucciones lgicas
and $1,$2,$3 or $1,$2,$3 xor $1,$2,$3 nor $1,$2,$3 andi $1,$2,10 ori $1,$2,10 xori $1, $2,10 sll $1,$2,10 srl $1,$2,10 sra $1,$2,10 sllv $1,$2,$3 srlv $1,$2, $3 srav $1,$2, $3 #$1 = $2 && $3 #$1 = $2 || $3 #$1 = ~($2 || $3) #$1 = ~($2 || $3) #$1 = $2 && 10 #$1 = $2 || 10 #$1 = ~$2 && ~10 #$1 = $2 << 10. Desplazamiento lgico #$1 = $2 >> 10. Desplazamiento lgico #$1 = $2 >> 10. Desplazamiento aritmtico #$1 = $2 << $3. Desplazamiento lgico #$1 = $2 >> $3. Desplazamiento lgico #$1 = $2 >> $3. Desplazamiento aritmtico

Movimiento entre registros

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

$3 mfc0 $1, $epc

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 lw $1, 100($2) #rt = Memory[rs+offset] # $1 Mem[$2 + 100] #Memory[rs+offset]=rt # $1 -> Mem[$2 + 100]

Store
lw rt,rs,offset sw $1, 100($2)

Instrucciones load/store
sw $3, 500($2) sh $3, 500($2) sb $3, 500($2) lw $3, 500($2) lh $3, 500($2) lhu $3, 500($2) lb $3, 500($2) la $3, Label # Mem(500+$2) $3. Almacena 32b # Mem(500+$2) $3. Almacena 16b # Mem(500+$2) $3. Almacena 8b # $3 Mem(500+$2). Carga 32b # $3 Mem(500+$2). Carga 16b # $3 Mem(500+$2). # Carga 16b sin signo # $3 Mem(500+$2). Carga 8b

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

Algunas pseudoinstrucciones
move $4, $5 # $4 $5 # or $4, $zero, $5 # $4 100 # ori $4, $zero, 100 # $4 LABEL # lui $4, LABEL16bsuperiores # ori $4, $4, LABEL16binferiores # if ($4 > CTE) goto LABEL # slti $at, $4, CTE+1 # beq $at, $zero, LABEL

li $4, 100

la $4, LABEL32

bgt $4, CTE, LABEL

Ejemplo

# 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 la $v1, DIR_B # cargar direccin de a # cargar direccin de b

lw $t0, 0($v0) lw $t1, 0($v1)

# leer a # leer b
# t2 = a * b # cargar direccin de acum # leer acum # $t3 = acum + a * b # guardar acum

int a, b, acum; acum = acum + a * b;

mul $t2, $t0, $t1 la $v2, DIR_ACUM lw $t3, 0($v2) add $t3, $t3, $t2 sw $t3, 0($v2)

a
1000 1004 1008 1012 1016 1020 1024

Memoria 10 DIR_A

b
2
70 50

$v0 $v1 $v2

1000 1012 1024

$t0 $t1 $t2

10 2 20

$t3

70 50

DIR_B
DIR_ACUM

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);
Memoria DIR_C1 DIR_C1 + 4 DIR_C2 c1.x 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 la $v1, DIR_C2 lw $t0, 0($v0) lw $t1, 0($v1) sub $t2, $t1, $t0 abs $t3, $t2 lw $t0, 4($v0) lw $t1, 4($v1) sub $t2, $t1, $t0 abs $t4, $t2 add $t3, $t3, $t4 Direcciones de memoria # cargar direccin de c1 # cargar direccin de c2 # leer c1.x # leer c2.x # t2 = c2.x c1.x # t3 = abs(c2.x c1.x) # leer c1.y # leer c2.y # t2 = c2.y c1.y # t4 = abs(c2.y c1.y) # t3 = abs(c2.x c1.x) + # abs(c2.y c1.y) # cargar direccin de dist # dist = abs(c2.x c1.x) + # abs(c2.y c1.y)

DIR_C2 + 4
DIR_DIST

c2.x c2.y
dist

la $v0, DIR_DIST sw $t3, 0($v0)

Ejecucin condicional de instrucciones

Permiten ejecutar partes de un programa slo si se cumple una determinada condicin

Ej. Estructuras tipo if-else, for, while, switch-case Tpicamente saltos, pero tambin escritura a registro Comparacin en la instruccin bgt r1, r2, ADDR # if r1 > r2 goto ADDR Registro de condicin (MIPS) cmp r1, r2, r3 # r3 = signo (r1-r2) bgtz r1, ADDR # if r1 > 0 goto ADDR

Cmo especificar la condicin?

Instrucciones ISA MIPS

Instrucciones de comparacin

Evala condicin entre dos operandos

Resultado es VERDADERO o FALSO Resultado de comparacin se almacena en registro destino FALSO regDest = 0 VERDADERO regDest = 1

Utilizan registro de condicin

Ejemplo:
add $1, $2, $3 slt $4, $1, $0 # if $1 < $0 then $4 = 1 # else #4 = 0

Algunas instrucciones de comparacin

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

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

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

Instrucciones de salto MIPS

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

Instrucciones de transferencia de control

Registro de contador de programa Program Counter (PC) Almacena direccin de siguiente instruccin a ejecutar Por defecto, instruccin fsicamente siguiente a la actual (PC PC + 4) Modificacin del flujo de control de un programa Tipos de salto (especificacin de direccin destino) Absoluto: instruccin especifica directamente direccin destino Relativo: instruccin especifica desplazamiento respecto de instruccin actual Tipos de salto (ejecucin condicional) Incondicional: salto se realiza de todas formas Condicional: salto se realiza slo si se cumple una condicin La mayora 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 direccin de retorno Retorno de procedimiento: retorna a instruccin siguiente a la que hizo el salto a procedimiento Llamado a sistema: salta a direccin predeterminada y pasa a modo supervisor Retorno de excepcin o llamado a sistema: retorna a instruccin que provoc excepcin 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 ejecucin de una instruccin, PC contiene la direccin de la siguiente instruccin a ejecutar $ra = $31

Saltos indexados
jr $ra jalr $1, $2 # PC $ra # $2 PC + 4; PC $1

Ejemplo
Cdigo 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;
li $t0, 10 li $t1, 5 sle $t3, $t0, $t1 bgtz $t3, ELSE sub $t2, $t0, $t1 j FIN_IF ELSE: sub $t2, $t1, $t0 # a = 10 #b=5 # a <= b ? # if a <= b goto ELSE #c=a-b # goto FIN_IF #c=b-a

Compilador asigna: a $t0 b $t1 c $t2

FIN_IF:

addi $t2, $t2, 10

# c = c + 10

Ejemplo
Posible optimizar cdigo?
Cdigo assembly para el siguiente cdigo C: i = 0; sum = 0; do { sum = sum + a[i] * b[i]; i++; } while (i < 100)
LOOP:

li $t0, 0 li $t1, 0 la $t2, SUM sw $t1, 0($t2) la $t3, A la $t4, B sll $t5, $t0, 2 add $t6, $t3, $t5 lw $t7, 0($t6) add $t6, $t4, $t5 lw $t8, 0($t6) mul, $t8, $t7, $t8 add $t1, $t1, $t8 la $t2, SUM sw, $t1, 0($t2) add $t0, $t0, 1

# i = 0; # $t1 = 0 (sum temporal) # $t2 = direccin de sum # sum = 0 # $t3 = direccin a[0] # $t4 = direccin b[0] # $t5 = i*4 # $t6 = direccin a[i] # $t7 = a[i] # $t6 = direccin b[i] # $t8 = b[i] # $t8 = a[i]*b[i] # $t1 = sum + a[i]*b[i]

# sum = sum + a[i] * b[i] #i=i+1

Vectores a y b y variable sum comienzan a partir de direcciones de memoria indicadas por rtulos A, B y SUM. Variable i asignada a registro $t0.

slti $t7, $t0, 100 # i < 100? bne $t7, $zero, LOOP

Ejemplo (optimizado)
li $t0, 0 li $t1, 0 la $t3, A la $t4, B LOOP: add $t6, $t3, $t0 lw $t7, 0($t6) # i = 0; # $t1 = 0 (sum temporal) # $t3 = direccin a[0] # $t4 = direccin b[0] # $t6 = direccin a[i] # $t7 = a[i]

Cdigo assembly para el siguiente cdigo C: i = 0; sum = 0; do { sum = sum + a[i] * b[i]; i++; } while (i < 100)

add $t6, $t4, $t0 lw $t8, 0($t6)

mul, $t8, $t7, $t8 add $t1, $t1, $t8 add $t0, $t0, 4

# $t6 = direccin b[i] # $t8 = b[i]

# $t8 = a[i]*b[i] # $t1 = sum + a[i]*b[i] #i=i+1

Vectores a y b y variable sum comienzan a partir de direcciones de memoria indicadas por rtulos A, B y SUM. Variable i asignada a registro $t0.

slti $t7, $t0, 400 # i < 100? bne $t7, $zero, LOOP la $t2, SUM sw, $t1, 0($t2)

# sum = sum + a[i] * b[i]

Otras instrucciones

syscall Llamado a sistema: syscall (cdigo en registro $v0) break Excepcin: break #cdigo nop No hace nada: nop eret (MIPS32, anterior rfe) Retorno de excepcin: eret Restaura registro de estado y mscara 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 mquina Ejemplos: li, la Ensamblador las traduce a una o ms instrucciones de mquina (las que s se pueden ejecutar)

Tabla resumen Syscall

Ensamblador MIPS

Ventajas de lenguaje assembly versus lenguaje de mquina

Mnemnicos

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

Definicin de constantes y datos en memoria Directivas al ensamblador

Entregan informacin al ensamblador sobre cmo traducir el cdigo assembly Texto que representa valores constantes o direcciones de memoria Instrucciones assembly que se traducen a unas pocas instrucciones de mquina

Rtulos (labels)

Pseudoinstrucciones

Algunas utilizan registro $at como temporal

Ensamblador realiza traduccin de assembly a lenguaje de mquina

Rtulos

Texto seguido de dos puntos (:)

Entrega nombre a direccin de memoria

Ejemplo
add $4, $4, $2 j LOOP

LOOP:

Tambin utilizado para datos

Ejemplo: nombrar constantes

CONST = 2 li $5, CONST

Ejemplo: nombrar direcciones de datos

.word 5 la $t0, RES lw $t1, 0($t0)

RES:

Pueden ser locales a mdulo (archivo) o globales para todo el programa

.globl MAIN

Ejemplo: para hacer smbolo MAIN global

Mapa de memoria

Texto

0x7FFF FFFF Stack

cdigo del programa

Memoria dinmica variables globales (esttica) Variables locales del procedimiento activo Estructuras del sistema operativo

Heap

Heap 0x1000 0000 Segmento de Texto 0x0040 0000 Reservado 0x0000 0000

Stack

Reservado

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 (cdigo) .kdata Texto que sigue representa datos en rea de datos del kernel (sistema operativo) .ktext

Texto que sigue representa cdigo en rea de kernel .globl LABEL Rtulo 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 la $8, TEXTOSINUL la $9, TEXTOCONUL la $10, DATOS lw $11, 0($10) lw $12, 4($10) lw $13, 8($10)

MAIN:

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 convencin

Protocolo Procedimientos/funciones

Cada mquina y compilador tiene su propio protocolo Protocolo esta determinado por HW y SW Instruccin jal es HW Usar registro $29 como $sp es SW (convencin) 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; } FIN_W: la $a0, str jal STRLEN; # $a0 = str # resultado retorna en $v0

STRLEN: li $v0, 0 WHILE: lb $t0, 0($a0) beq $t0, $zero, FIN_WHILE addi $a0, $a0, 1 addi $v0, $v0, 1 b WHILE jr $ra

# len = 0 # $t0 = *str # if (*str == 0) goto FIN_W # str = str + 1 # len = len + 1 # goto WHILE # return len

Utilizar convencin estndar 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 ms de 4 argumentos? Qu hacer cuando el valor de retorno utiliza ms de dos palabras (ej. una estructura)?

Retorno de valor: $v0-$v1

Registros preservados por procedimiento invocado: $s0$s7

Dnde debe respaldarlos el procedimiento?

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

Dnde respaldarlos? Qu hacer con su contenido si procedimiento invoca a otro procedimiento?

Direccin de retorno almacenada en: $ra

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

$ra

PROC1_MEM

$t0

Direcciones de memoria

Problema: Qu pasa si PROC1 es recursivo?

Procedimientos y stacks

Alternativa 2: definir un rea de memoria asociada a cada activacin de cada procedimiento Estructura dinmica de llamado a procedimientos asemeja una pila (stack) Retornan en el sentido inverso en el que fueron invocados Memoria para almacenamiento de datos locales tambin se estructura como un stack

A:

call B B: call C C:

A A B A B C A B A

ret

ret

Stacks de memoria

Almacenan ambientes asociados a procedimientos anidados (marco de activacin)

Direccin de retorno Argumentos Variables locales Valor de retorno Registros salvados por el procedimiento

Soporte para stacks

Stack pointer (SP)

FP Apunta al tope del stack Usado para agregar y sacar datos a stack
Argumentos

Frame pointer (FP)

Apunta a base del bloque de activacin (stack frame) Usado para accesar variables locales y argumentos sin removerlos del stack PUSH POP CALL RETURN En el lenguaje de mquina: VAX, Intel, registros e instrucciones especficas Por convencin de software: MIPS

Operaciones

Registros salvados por el llamado

Variables locales

Soporte ISA para stacks

SP

Evaluacin de expresiones (dinmico)

Soporte mnimo: jal, jr

Ejemplo: Cadena de llamados

Estructura de cdigo
p1() { p2(); }

Cadena de llamados
p1

p2() { p3(); p3(); }

p2 p3 p3() { p3(); } p3 p3 p3

Procedimiento p3 es recursivo

Operacin del stack

p1() { p2(); }

Cadena de
p1

Frame Pointer llamados $fp Stack Pointer $sp

p1

Operacin del stack

p2() { p3(); p3(); }

p1

Cadena de llamados
p1 p2 Frame Pointer $fp Stack Pointer $sp

p2

Operacin del stack

p3() { p3(); }

p1

Cadena de llamados
p1 p2 p3 Stack Pointer $sp Frame Pointer $fp

p2

p3

Operacin del stack

p3() { p3(); }

p1

Cadena de llamados
p1

p2 p2 p3 p3 p3

Frame Pointer $fp Stack Pointer $sp

p3

Operacin del stack

p3() { p3(); }

p1

Cadena de llamados
p1

p2 p2 p3 p3 p3 Frame Pointer $fp Stack Pointer $sp p3

p3

p3

Operacin del stack

p3() { p3(); }

p1

Cadena de llamados
p1

p2 p2 p3 p3 amI p3

Frame Pointer $fp Stack Pointer $sp

p3

Operacin del stack

p3() { p3(); }

p1

Cadena de llamados
p1 p2 p3 p3 p3 Stack Pointer $sp Frame Pointer $fp

p2

p3

Operacin del stack

p2() { p3(); p3(); }

p1

Call Chain
p1 p2 p3 p3 p3 Frame Pointer $fp Stack Pointer $sp

p2

Operacin del stack

p3() { }

p1

Cadena de llamados
p1 p2 p3 p3 p3 p3 Stack Pointer $sp Frame Pointer $fp

p2

p3

Operacin del stack

p2() { p2(); p2(); }

p1

Cadena de llamados
p1 p2 p3 p3 p3 p3 Frame Pointer $fp Stack Pointer $sp

p2

Operacin del stack

p1() { p2(); }

Cadena de
p1 p2 p3 p3

Frame Pointer llamados $fp Stack Pointer $sp

p1

p3

p3

Stack (Pila) de Programa

Cada programa en ejecucin (proceso) tiene un stack Stack: estructura de datos dinmica accesada en LIFO Stack de programa automticamente asignada por el SO Al comienzo del proceso el registro $sp ($29 en MIPS) es automticamente cargado a un punto de la primera entrada vaca al tope del stack

Despus de eso queda a manos del programador el uso del stack Para asignar una nueva entrada (al hacer push), decrementar $sp Para liberar espacio en el tope del stack (al hacer pop), incrementar $sp

Por convencin, el stack crece hacia direcciones ms bajas

Operacin push

Push agrega un item en el tope del stack

Una instruccin para manipular dato : sw $6, 0($sp) Una instruccin para ajustar el puntero al stack : subu $sp, $sp, 4

46
-72 ???

8($sp)
4($sp) $sp

46
-72 127 ???

12($sp)
8($sp) 4($sp) $sp 127 $6

127

$6

antes

despus

Operacin pop

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

Una instruccin para ajustar el puntero a stack : addu $sp, $sp, 4 Una instruccin para manipular el dato : lw $6, 0($sp)
46 -72 127 8($sp) 4($sp) $sp 46 -72 127 ??? 127 $6 12($sp) 8($sp) 4($sp) $sp 453 $6

Pasa a ser
basura

despes

antes

Requerimientos llamados a procedimiento

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

Mecanismo

Registros son usados

Para pasar direccin de retorno en $ra

Stacks son usados para

Jal target

Para pasar parmetros ($a0 $a3, a lo ms 4) Mantener el valor de $sp Retornando valores de funcin en $v0, $v1

Salvar registros para ser usados por procedimientos Salvar informacin acerca del que llama (direccin de retorno) Pasar parmetros si se necesita Asignando datos locales para el procedimiento llamado

Convencin uso de registros

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

Tareas del que llama y procedimiento llamado en CALL

El que llama

Procedimiento

Salva contenido de registros volatiles ($t0$t9) teniendo contenidos que deben ser guardados Poner a lo ms 4 argumentos en $a0$a3 Si hay ms de 4 argumentos, poner el resto en el stack Llamar a jal instruccin

Salva $ra en stack Salva cualquier registro no voltil ($s0$s7) que se usar

Tareas del que llama y procedimiento llamado en RETURN

Procedimiento

El que llama

Restaura cualquier registro no voltil ($s0$s7) que ha usado Restaura $ra Pone resultados de funcin en $v0, $v1 Retorna al que llama con instruccin jr $ra

Restaura cualquier registro voltil 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 move subu sw sw jal $a0,$t0 $a1,$t3 $sp,$sp,8 $t6,8($sp) $t7,4($sp) target # argumento 1 en $a0 # argumento 2 en $a1 #espacio para 2 temps en stack #salvar $t6 en stack #salvar $t7 en stack

Asumir que procedimiento no necesita salvar registros

target: sw $ra,0($sp) subu $sp,$sp,4 #salva direccin de retorno # en stack

Ejemplo RETURN

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

addu lw jr $sp,$sp,4 $ra,0($sp) $ra #pop #dir de retorno en $ra #para el que llama

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

lw lw addu $t6,8($sp) $t7,4($sp) $sp,$sp,8

Ejemplo: Factorial recursivo

FACT: bne li jr $a0, $0, L1 $v0, 1 $ra $sp, $fp, $ra, $fp, $a0, $sp, -12 0($sp) 4($sp) $sp, 8 0($fp) # saltar si n != 0 # retornar 1

int factorial(int n) L1: { if (n == 0) return 1; else return n * factorial(n-1); }

addiu sw sw addiu sw addiu jal lw lw lw addiu mul jr

# # # # #

tamao del nuevo stack es 12 bytes almacenar $fp en el stack almacenar $ra en el stack $fp apunta al principio del stack almacenar n en el stack

$a0, $a0, -1 FACT $a0, $ra, $fp, $sp, 0($fp) 4($sp) 0($sp) $sp, 12

# n - 1 # resultado en $v0 # # # # recuperar recuperar recuperar restaurar n direccion de retorno $fp stack original $sp

$v0, $v0, $a0 $ra

# n * fact(n-1)

Mostrar ejemplos usando fp y no usando fp, usando ConTEXT Ejercicio: hacer dibujo con marcos de activacin y cadena de llamados

Excepciones

Condiciones especiales que cambian el flujo de ejecucin normal del programa Tipos de excepciones

Interrupcin

Generada en forma externa al procesador, tpicamente por dispositivo de E/S como interfaz de red o disco
Efecto colateral (implcito o explcito) de ejecucin de instruccin

Trap

Ej. Divisin por cero, acceso ilegal a memoria, instruccin invlida, syscall, break.

Atencin de excepciones

Tpicamente

Almacenar estado del procesador (PC, registro de condicin, mscara de interrupciones, etc.) Transferir control al sistema operativo Pasar a modo de ejecucin supervisor Sistema operativo atiende excepcin, restaura el estado y retorna al programa de usuario

Atencin de excepciones en MIPS

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 porcin de cdigo a la direccin 0x80000180 (en modo kernel) llamado exception handler o manejador de interrupciones Este cdigo examina causa de excepcin y salta al punto apropiado de la rutina de atencin de la excepcin que ocurri ( en el SO).