Organizacin del Computador I Verano

MIPS (1 de 2)
Basado en el captulo 3 del libro de Patterson y Hennessy

Verano 2004

Profesora Borensztejn

Lenguajes para la mquina

Las computadoras son circuitos electrnicos, por lo tanto
para hablar con ellas se necesita enviarles seales
elctricas
Las seales viajan por los circuitos electrnicos que estn
formados por (millones de) transistores.
Los transistores son interruptores que, en funcin del
valor de la seal elctrica que los controla, dejan o no
pasar esa seal. Por eso a su salida habr dos posibles
valores: estos valores se pueden representar
simblicamente con los dgitos cero y uno.
Los smbolos cero y uno se llaman bits.

Transistores: que podemos hacer

con algunos pocos de ellos?
Con slo dos: convertir un 1 en un 0 (y viceversa):
hacer una puerta NOT
Con 4 transistores podemos hacer una puerta
lgica NAND o NOR.
Con estas puertas elementales se puede construir
cualquier funcin.
Un computador no es ms que un conjunto
(grande) de funciones de un conjunto (grande) de
entradas (seales)

Lenguajes para la mquina

En realidad, el lenguaje mquina est formado por nmeros en
base 2! Tanto los datos como las instrucciones se codifican
como nmeros en base 2.
Cada mquina (o familia de mquinas) tiene su propio lenguaje
mquina. Los lenguajes mquina,en realidad, no difieren mucho
entre s, debido a que:
la tecnologa de implementacin de los circuitos es la misma para
todos los fabricantes
Todas las mquinas deben proporcionar un repertorio bsico de
instrucciones (sumar, por ejemplo).

Asi que, no se preocupen, lo que aprendan de MIPS

ser...........totalmente diferente en INTEL (orga2)

Lenguajes Mquina
Una computadora, est formada por
Control

Input
Memory

Datapath
Processor

Output
I/O

La Unidad de Proceso y Control (es donde nos vamos a centrar en

este curso) implementa un conjunto de funciones (de propsito
general) a travs de millones de transistores.
Imposible de entender mirando lo que hace cada
transistorNecesitamos una abstraccin

Abstracciones
High-level
language
program
(in C)

swap(int v[], int k)

{int temp;
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
}

C compiler

Assembly
language
program
(for MIPS)

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

Assembler

Binary machine
language
program
(for MIPS)

00000000101000010000000000011000
00000000100011100001100000100001
10001100011000100000000000000000
10001100111100100000000000000100
10101100111100100000000000000000
10101100011000100000000000000100
00000011111000000000000000001000

Lenguaje ensamblador:
Notacin ms humana que
los nmeros binarios
Requiere una instruccin
por lnea

Lenguajes de alto nivel

permiten:
Facilidad al programar
Menor tiempo de desarrollo
(mayor productividad)
Independencia del
computador

MIPS
Machine without Interlocked Pipelined Stages
Arquitectura diseada por Hennessey, en 1980,
guiada por los siguientes principios:
La simplicidad favorece la regularidad
Ms pequeo es ms rpido (menos es mas)
Hacer rpido el caso comn

Objetivos de diseo: maximizar rendimiento y

reducir costos
Usado por: NEC, Nintendo, Silicon Graphics, Sony.

Aritmtica MIPS
Todas las instrucciones tienen 3 operandos
El orden de los operandos es fijo (primero el destino)
Ejemplo:
cdigo C:

A = B + C

cdigo MIPS:

add $s0, $s1, $s2

(el compilador asocia las variables a los registros)

Aritmtica MIPS
Principio de Diseo: la simplicidad favorece la uniformidad.
Operaciones con nmero de operandos variables complica el hardware.
Pero esto complica algunas cosas ...
cdigo C:
A = B + C + D;
E = F - A;
cdigo MIPS: add $t0, $s1, $s2
add $s0, $t0, $s3
sub $s4, $s5, $s0
Los operandos deben ser registros, y solo hay 32 registros.
Los registros son de 32 bits
Principio de Diseo: cuanto ms pequeo, mas rpido.

Registros vs Memoria

Las instrucciones aritmticas deben tener sus operandos en registros, de

los cuales la arquitectura provee 32.
El compilador realiza la asociacin de variables con registros.
Que sucede con los programas que tienen muchas variables?
El compilador intenta mantener las variables usadas ms frecuentemente
en registros. Aquellas menos usadas se guardan en memoria. El proceso de
poner estas variables en memoria se llama spilling.
Los registros tienen menor tiempo de acceso que la memoria, y adems son
mas tiles porque se puede operar con ellos.
El compilador, para obtener un rendimiento alto, debe hacer un uso
eficiente de los registros.

Organizacin de la Memoria
0
1
2
3
4
5
6
...

8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data

Se ve como un vector muy largo de

una dimensin. Cada posicin tiene
asociada una direccin.
Una direccin de memoria es un
ndice al vector.
"Byte addressing" significa que el
ndice apunta a un byte de memoria.

Organizacin de la Memoria
0
4
8
12

32 bits of data
32 bits of data
32 bits of data
32 bits of data

0
4
8
12

00000000000000000000000000000000
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011

En general, los datos son de una longitud mayor que un byte4

bytes: se llaman words en MIPS.
...
La memoria
se puede ver como un vector de:
232 bytes con direcciones (de byte) que van desde 0 a 232-1
230 words con direcciones (de byte) 0, 4, 8, ... 232-4

Los words estn alineados en memoria:

Es decir, los dos bits menos significativos de una direccin de memoria
que identifica a un word son cero.

La organizacin de un word en memoria se llama big endian

(en contraposicin con little endian): consiste en almacenar el
byte de mas peso del word en la direccin ms baja de memoria.

Instrucciones para leer/escribir

datos en memoria
Load: carga de un operando de memoria a registro
Store: almacenamiento de un operando de registro a memoria
Ejemplo:
C cdigo:

A[8] = h + A[8];

MIPS cdigo: lw $t0, 32($s3)

add $t0, $s2, $t0
sw $t0, 32($s3)
El destino en la instruccin de Store est al final.
Recordar: operandos aritmticos no pueden estar en memoria.

Hasta ahora:
MIPS
carga de words pero direccionamiento a
nivel de byte
aritmtica solo en registros
Instruccin
Significado
add $s1, $s2, $s3
sub $s1, $s2, $s3
lw $s1, 100($s2)
sw $s1, 100($s2)

$s1 = $s2 + $s3

$s1 = $s2 $s3
$s1 = Memory[$s2+100]
Memory[$s2+100] = $s1

Control
Instrucciones para la toma de decisiones
Alteran el flujo secuencial del programa
Controlan el orden de ejecucin de las
instrucciones del programa

Instrucciones MIPS de salto condicional:

bne $t0, $t1, L1
beq $t0, $t1, Ll

Ejemplo:

if (i= = j) h = i + j;

bne $s0, $s1, Ll

add $s3, $s0, $s1
Ll: ....

Control
Intruccin MIPS de salto incondicional
j Ll
Ejemplo:
if (i!=j)
h=i+j;
else j L2
h=i-j;
L2:
...

beq $s4, $s5, L1

add $s3, $s4, $s5
L1:

sub $s3, $s4, $s5

Como sera un bucle for?

for (i=0;i<10;i++)
h=h+i;

Hasta Ahora:
Instruccin

Significado

add $s1,$s2,$s3 $s1 = $s2 + $s3

sub $s1,$s2,$s3 $s1 = $s2 $s3
lw $s1,100($s2) $s1 = Memory[$s2+100]
sw $s1,100($s2) Memory[$s2+100] = $s1
bne $s4,$s5,L
Siguiente instr.en L si $s4!=$s5
beq $s4,$s5,L
Siguiente instr.en L si $s4 =$s5
j L Siguiente instr.en L

Control: Saltar si Menor?

Instruccin SetLessThan:
if $s1 < $s2 then
$t0 = 1
slt $t0, $s1, $s2
else
$t0 = 0
Usamos la instruccin SLT para construir el salto si menor que: "blt $s1, $s2, L
slt $t0, $s1, $s2
bne $t0, $zero, L
El registro $zero se corresponde con el registro 0 que est cableado a cero.
El compilador MIPS construye todas las variantes de saltos condicionales utilizando las
instrucciones bne, beq y slt. De esta manera, se aplica el criterio de simplicidad: la
incorporacin de estas instrucciones alargara el tiempo para ejecutar una instruccin: se
prefieren dos instrucciones rpidas frente a todas mas lentas.

Instruccin Jump Register

Instruccin MIPS jr: sirve para saltar a la direccin
contenida en el registro especificado.
jr $t0

Permite implementar la sentencia switch

switch(k)
{case
case
case
case
}

0:
1:
2:
3:

f=i+j;
f=g+h;
f=g-h;
f=i-j;

break;
break;
break;
break;

Se implementar con una Tabla que contiene las direcciones

(etiquetas) de los distintos trozos de cdigo
correspondientes a cada caso. (Tabla de direcciones de
salto).

Implementacin de la sentencia
switch
; comprueba si k>0 y k<4
slt $t3, $s5, $zero
Bne $t3, $zero, fin
slt $t3, $s5, $t2
Bne $t3, $zero, fin
;multiplica $s5 (k) por 4
;para acceder a la Tabla
add $t1,$s5,$s5
add $t1,$t1,$t1
;cargar la direccin de Tabla[k]
add $t1,$t1,$t4
lw $t0,0($t1)
;saltar a la instruccin
jr $t0
L0: add $s0,$s3,$s4
J
fin
L1: add $s0,$s1,$s2
J
fin
L3: sub $s0,$s1,$s2
J
fin
L3: sub $s0,$s3,$s4
Fin:

switch(k)
{case
case
case
case
}

0:
1:
2:
3:

f=i+j;
f=g+h;
f=g-h;
f=i-j;

break;
break;
break;
break;

Las variables f a k se corresponden

con $s0..$s5, $t2 contiene 4. La
variable k se usar como ndice a la
tabla de etiquetas.La tabla se
almacena a partir de la direccin
guardada en $t4

Constantes
Constantes pequeas son usadas muy frecuentemente (52% de los operandos son
contantes pequeas en gcc)
por ej: A = A + 5;
B = B + 1;
C = C - 18;
Soluciones:
Almacenar algunas constantes tpicas en memoria, y luego cargarlas.
lw
add

$t0,dir_constante($zero)
$s1,$t0,$t0

Crear constantes cableadas en registros (como $zero).

Incorporar a MIPS versiones de instrucciones en los cuales un operando es
una constante y dicha constante, de 16 bits, est almacenada en la instruccin.
addi $s1, $s1, 4
slti $s2, $s3, 10
andi $t0, $t2, 6

Constantes mas grandes?

LUI (load upper immediate) almacena los 16 bits mas altos
de una constante en un registro.
lui $t0, 1010101010101010 Se llena con ceros
1010101010101010

0000000000000000

Luego se suma al registro la parte baja de la constante

utilizando una instruccin aritmtica con operando inmediato
ori $t0, $t0, 1010101010101010

ori

1010101010101010

0000000000000000

0000000000000000

1010101010101010

1010101010101010

1010101010101010

Caracteres y Bytes
Un carcter se representa mediante el cdigo standard ASCII
(American Stantard Code for Information Interchange)
ASCII

Carcter

ASCII Carcter

ASCII Carcter ASCII Carcter ASCII Carcter ASCII Carcter

32 espacio

48

64

80

96

112

33

49

65

81

97

113

34

"

50

66

82

98

114

35

51

67

83

99

115

36

52

68

84

100

116

37

53

69

85

101

117

38

&

54

70

86

102

118

39

55

71

87

103

119

40

56

72

88

104

120

41

57

73

89

105

121

42

58

74

90

106

122

43

59

75

91

107

123

44

60

<

76

92

108

124

45

61

77

93

109

125

46

62

>

78

94

110

126

47

63

79

95

111

127

DEL

Caracteres
Instrucciones para leer y escribir bytes:
Lb: carga un byte de memoria y lo sita en los 8 bits
ms bajos del registro (derecha)
Sb: lee el byte que est a la derecha en el registro
especificado y lo escribe en memoria.
lb
sb

$t0, 0($sp)
$t0, 0($gp)

Los caracteres se combinan en cadenas: en C, el

fin de una cadena se marca con un byte cuyo valor
es cero (carcter Null)

Strcpy
strcpy:
; direcciones de x e y en $a0 y $a1
; se usa $s0 para i
sub $sp, $sp, 4
sw $s0, 4($sp)
;inicializa i en cero
add $s0,$zero,$zero
L1:
;guarda la direccion de y[i] en $t1
add $t1,$a1,$s0
;carga y[i] en $t2
lb $t2,0($t1)
;guarda la direccion de x[i] en $t3
add $t3,$a0,$s0
;guarda $t2 en x[i]
sb $t2,0($t3)
;aritmtica de punteros
addi $s0,$s0,1
bne $t2, $zero, L1
;restaura los valores antiguos
; y retorna
lw $s0, 4($sp)
add $sp, $sp, 4
jr $ra

void strcpy(char x[],char y[])

{
int i;
i=0;
while ((x[i]= y[i])!=0)
i=i+1;
}

Soporte para procedimientos

Mecanismo de llamada y
retorno de un procedimiento:
1.Paso de parmetros a travs
de un lugar conocido
2.Transferencia de control a la
subrutina
3.Ejecucin del cdigo de la
subrutina
4.Situar el resultado en un lugar
conocido
5.Retornar el control al punto
de origen

1.
2.
3.
4.
5.

$a0..$a3
Instruccin MIPS:
jal direccin_subrutina
Ejecucin del cdigo de la
subrutina
$v0-$v1
$ra: contiene la direccin
de retorno. La instruccin
jr $r0 devuelve el control
al programa llamador.

Instrucciones JAL y JR
(call y return)
Jump and Link: salta y enlaza
Cambia el valor del PC por la direccin
especificada en la instruccin y almacena en
el registro $r0 la direccin de retorno
(PC+4).
La instruccin JR $r0 se utiliza para el
retorno del procedimiento

La Pila
Que sucede si el programa necesita utilizar ms registros

(temporales) para hacer clculos? El compilador puede usarlos,

siempre y cuando preserve los valores que tenan antes de
invocarse el procedimiento.
Para preservar los valores, se vuelcan los registros en memoria
(spilling).
El lugar idneo para realizar el spilling (vuelco) es una
estructura de datos en memoria llamada pila: una cola donde el
ltimo que entra es el primero que sale.
Los programas MIPS reservan un registro, $sp (stack pointer),
que es el puntero al tope de la pila: es decir, apunta a la
posicin de memoria donde se ha almacenado el ltimo dato.

Ejemplo de una funcin

ejemplo:
; salvar los registros $s0,$t0 y $t1
sub $sp, $sp, 12; *
sw $t1, 8($sp)
sw $t0, 4($sp)
sw $s0, 0($sp)
;realiza el clculo de f
;y lo deja en $s0
add $t0,$a0,$a1
add $t1,$a2,$a3
sub $s0,$t0,$t1
;copia $s0 en $v0 (reg. de retorno)
add $v0,$s0,$zero
;restaura los valores antiguos
; y retorna
lw $s0, 0($sp)
sw $t0, 4($sp)
sw $t1, 8($sp)
add $sp, $sp, 12
jr $ra

int ejemplo(int g,int h,int i,int j)

{
int f;
f=(g+h)-(i+j);
return f;
}

Las variables g a j se
corresponden con $a0..$a3,
y f se corresponde con $s0.
$sp

$sp
Antes de instruccin *

$s0

0($sp)

$t0

4($sp)

$t1

8($sp)

Convenciones
Los compiladores establecen una convencin en el uso de
los registros para evitar salvar y restaurar registros cuyo
valor nunca se usa.
$t0..$t9: 10 registros temporales cuyo valor no es preservado por el
procedimiento invocado
$s0..$s7: 8 registros que si deben ser salvados si son utilizados por
el procedimiento invocado

Adems, recordamos que:

$a0..$a3: 4 registros para paso de parmetros

$v0..$v1: 2 registros para devolver resultados
$sp: registro puntero a pila
$ra: registro que guarda la direccin de retorno

Procedimientos anidados
A

Si B recibe de A en
$a0..$a4 sus
parmetros, deber
salvarlos en la pila
antes de llamar a C

Lo mismo sucede con la direccin de retorno, y con todos los registros

temporales que cada procedimiento deba seguir usando despues de la
llamada.
El invocador apila sus registros de argumentos ($a0..$a4) y temporales
($t0..$t9). El invocado apila el registro $ra y cualquier registro salvado
$s0..$s7 usado por el invocado.
El puntero a la pila ($sp) se ajusta a la cantidad de registros salvados.
Antes del retorno, se restauran los registros y $sp se ajusta al valor inicial
(el que recibi).

Bloque de Activacin

Las variables locales a los procedimientos que no caben en

los registros, tales como tablas o estructuras, tambin se
almacenan en la pila.
El conjunto de informacin almacenada en la pila es:

Argumentos (si hay mas de 4)

Direccin de Retorno
Registros Salvados
Variables Locales

El bloque de pila que contiene esa informacin se

denomina Bloque de Activacin y los programas pueden
utilizar un registro, el $fp, como puntero al Bloque.

Bloque de Activacin
$FP

Argumentos
Direccin de
Retorno
Registros Salvados

$SP

Variables Locales

El puntero $fp, a
diferencia de $sp, se
mantiene fijo durante
toda la ejecucin del
procedimiento,
brindando un registro
base estable para
acceder a parmetros y
variables.

Convenciones
Nombre
$zero
$at
$v0-$v1
$a0-$a3
$t0-$t7
$s0-$s7
$t8-$t9
$k0-$k1
$gp
$sp

Nmero
0
1
2-3
4-7
8-15
16-23
24-25
26-27
28
29

Uso
valor constante cero
reservado para el ensamblador
resultados y evaluacin expresiones
argumentos
temporales
salvados
temporales
reservado para el sistema operativo
puntero glogal
puntero pila

Preservado
n.a.
no
no
si
no
si
no
no
si
si

Resumen
MIPS operands
Name

Example
$s0-$s7, $t0-$t9, $zero,
32 registers $a0-$a3, $v0-$v1, $gp,
$fp, $sp, $ra, $at
Memory[0],
30

memory Memory[4], ...,

words

Comments
Fast locations for data. In MIPS, data must be in registers to perform
arithmetic. MIPS register $zero alw ays equals 0. Register $at is
reserved for the assembler to handle large constants.
Accessed only by data transfer instructions. MIPS uses byte addresses, so
sequential w ords differ by 4. Memory holds data structures, such as arrays,
and spilled registers, such as those saved on procedure calls.

Memory[4294967292]

MIPS assembly language

Category

Arithmetic

Instruction
add

Example
add $s1, $s2, $s3

Meaning
$s1 = $s2 + $s3

Three operands; data in registers

subtract

sub $s1, $s2, $s3

$s1 = $s2 - $s3

Three operands; data in registers

$s1 = $s2 + 100

$s1 = Memory[$s2 + 100]
Memory[$s2 + 100] = $s1
$s1 = Memory[$s2 + 100]
Memory[$s2 + 100] = $s1

Used to add constants

addi $s1, $s2, 100

lw $s1, 100($s2)
sw $s1, 100($s2)
store word
lb $s1, 100($s2)
load byte
sb $s1, 100($s2)
store byte
load upper immediate lui $s1, 100
add immediate
load word

Data transfer

Conditional
branch

Unconditional jump

$s1 = 100 * 2

16

Comments

Word from memory to register

Word from register to memory
Byte from memory to register
Byte from register to memory
Loads constant in upper 16 bits

branch on equal

beq

$s1, $s2, 25

if ($s1 == $s2) go to
PC + 4 + 100

Equal test; PC-relative branch

branch on not equal

bne

$s1, $s2, 25

if ($s1 != $s2) go to
PC + 4 + 100

Not equal test; PC-relative

set on less than

slt

$s1, $s2, $s3

if ($s2 < $s3) $s1 = 1;

else $s1 = 0

Compare less than; for beq, bne

set less than

immediate

slti

jump

j
jr
jal

jump register
jump and link

$s1, $s2, 100 if ($s2 < 100) $s1 = 1;

Compare less than constant

else $s1 = 0

2500
$ra
2500

Jump to target address

go to 10000
For switch, procedure return
go to $ra
$ra = PC + 4; go to 10000 For procedure call

Compilacin, Ensamblage,
Linkedicin y Carga
Programa .c

Programa .s

Compilador

Ensamblador

Objeto .o

Libreras de rutinas
Montador

Ejecutable (LM)

Cargador
Memoria

Ensamblador
Traduce pseudoinstrucciones, por ejemplo
move
$t0, $t1
Es traducida a:
add
$t0,$zero, $t1

Convierte el programa en lenguaje ensamblador en un programa objeto:

instrucciones en lenguaje mquina
datos
Informacin para situar las instrucciones en memoria

El programa objeto est compuesto por 6 secciones:

Cabecera
Segmento de Texto
Segmento de Datos
Informacin de reubicacin
Tabla de Smbolos
Informacin para depuracin

Montador, Linker
Une distintos programas objeto en un nico ejecutable
til para reutilizar cdigo ya ensamblado (por ejemplo, libreras de rutinas
standard)
Funciones:
Sita simblicamente en memoria los datos y el cdigo
Determina las direcciones de los datos y de las etiquetas de instrucciones
Resuelve las referencias externas

El archivo ejecutable consta de:

Cabecera: indica el tamao de los sementos de cdigo y datos
Segmento de cdigo
Segmento de datos
Datos estticos
Datos dinmicos
Pila

Convencin MIPS de
distribucin de memoria
$sp

7fff ffff

Pila

Datos Dinmicos
$gp

pc

1000 8000
1000 0000
0040 0000
0000 0000

Datos Estticos
Cdigo
Reservado

Cargador
Para ejecutar el programa, el sistema operativo realiza
las siguientes acciones:
Lee la cabecera del archivo ejecutable para determinar el
tamao de los segmentos de cdigo y de datos
Crea un espacio de direcciones para albergar el programa,
y copia las instrucciones y los datos a este espacio
Copia en el segmento de pila, los argumentos del programa
Inicializa los registros: el $sp, $gp
Salta a una rutina de inicio (start-up routine) que a su vez
llama al programa main y cuando este finaliza, llama a una
rutina de salida (exit system call)

FIN
MIPS