registro

Repaso Arquitectura MIPS
Fundamentos de los Computadores
Grado en Ingeniería Informática
Arquitectura MIPS
Registros
 Instrucciones
I t
i
 Organización de memoria
 Formato de las instrucciones
 Modos de direccionamiento
 Subprogramas

Lenguajes máquina y ensamblador
2
Registros del MIPS

Los registros de los que se dispone son los siguientes:
 Registro contador de programa (PC) de 32 bits
 32 registros de 32 bits: $0, $1… $31.
▫ $0:
▫ $1… $31:
registro cuyo contenido siempre es 0
registros de propósito general
 32 registros de punto flotante
▫ 32 simple precisión (32 bits):
▫ 16 doble precisión (64 bits):
F0, F1, F2… F30, F31
F0, F2… F30 (direcciones pares)
 Registros HI y LO para resultados aritméticos de 64 bits.
▫ Multiplicación: HI,LO almacenan un producto de 64 bits
▫ División: LO almacena el cociente y HI el resto
Lenguajes máquina y ensamblador
3
Arquitectura MIPS
Registros
 Instrucciones
I t
i
 Organización de memoria
 Formato de las instrucciones
 Modos de direccionamiento
 Subprogramas

Lenguajes máquina y ensamblador
4
Instrucciones del MIPS

Tres categorías:
 Instrucciones aritmético/lógicas
 Instrucciones de carga/almacenamiento
 Instrucciones de control de flujo
Lenguajes máquina y ensamblador
5
Instrucciones aritmético/lógicas
Todas las operaciones aritméticas y lógicas
tienen dos operandos y un resultado
 Los dos operandos normalmente están ubicados en
registros
i t y ell resultado
lt d se almacena
l
en un registro
it

 Existe un convenio de uso de registros
 A cada
d registro
i
se le
l asigna
i
un alias
li
▫ Los registros $s0–$s7 ($16–$23) suelen usarse para valores de trabajo
▫ Los registros $t0–$t7
$t0 $t7 ($8–$15)
($8 $15) suelen usarse para valores temporales

Una versión alternativa de algunas instrucciones
permite que uno de los operandos sea un valor
inmediato proporcionado por la propia instrucción
Lenguajes máquina y ensamblador
6
Instrucciones aritmético/lógicas
a=b+c
add $
$s0,, $s1,
$ , $s2
$
valor
registro
a
$s0
$
b
$s1
c
$s2
NOTA: operación de suma con dos operandos en registros.
Lenguajes máquina y ensamblador
7
Instrucciones aritmético/lógicas
a=b+c+d
add $
$s0,, $s1,
$ , $s2
$
add $s0, $s0, $s3
valor
registro
a
$s0
$
b
$s1
c
$s2
d
$s3
NOTA: operación de suma con tres operandos en registros.
Lenguajes máquina y ensamblador
8
Instrucciones aritmético/lógicas
d=a–e
sub $
$s0,, $s1,
$ , $s2
$
valor
registro
d
$s0
$
a
$s1
e
$s2
NOTA: operación de resta con dos operandos en registros.
Lenguajes máquina y ensamblador
9
Instrucciones aritmético/lógicas
a = b + 75
addi $
$s0,, $s1,
$ , 75
valor
registro
a
$s0
$
b
$s1
NOTA: operación de resta con un operando en registro, siendo el otro un valor inmediato.
Lenguajes máquina y ensamblador
10
Instrucciones aritmético/lógicas
a = ((b + c) – d) AND e
add $
$s0,, $s1,
$ , $s2
$
sub $s0, $s0, $s3
and $s0, $s0, $s4
valor
registro
a
$s0
$
b
$s1
c
$s2
d
$s3
e
$s4
NOTA: operación compleja que se realiza por pasos acumulando el resultado en el registro destino.
Lenguajes máquina y ensamblador
11
Instrucciones aritmético/lógicas
f = (g + h) – (i + j)
add $
$s0,, $s1,
$ , $s2
$
add $t0, $s3, $s4
sub $s0, $s0, $t0
valor
registro
f
$s0
$
g
$s1
h
$s2
i
$s3
j
$s4
NOTA: operación compleja que se realiza por pasos usando un registro como almacenamiento temporal.
Lenguajes máquina y ensamblador
12
Instrucciones aritmético/lógicas
f = (g + h + i) – (i + j)
add $
$s0,, $s1,
$ , $s2
$
add $s0, $s0, $s3
add $t0, $s3, $s4
sub $s0, $s0, $t0
valor
registro
f
$s0
$
g
$s1
h
$s2
i
$s3
j
$s4
NOTA: operación compleja que se realiza por pasos usando un registro como almacenamiento temporal.
Lenguajes máquina y ensamblador
13
Instrucciones aritméticas
Instrucción
sumar
sumar sin signo
sumar inmediato
sumar inmediato sin signo
restar
restar sin signo
dividir
dividir sin signo
multiplicar
multiplicar sin signo
valor absoluto
dividir
dividir sin signo
multiplicar
multiplicar
multiplicar sin signo
Lenguajes máquina y ensamblador
Ejemplo
add $1,$2,$3
addu $1,$2,$3
addi $1,$2,10
addiu $1,$2,10
sub $1,$2,$3
subu $1,$2,$3
Significado
$1= $2+$3
$1=$2+$3
$1=$2+10
$1=$2+10
$1=$2-$3
$1=$2-$3
Lo=$1$2
div $1,$2
Hi=$1mod$2
Lo=$1$2
divu $1,$2
Hi=$1mod$2
mult $1,$2
Hi,Lo=$1*$2
multu $1,$2
Hi,Lo=$1*$2
Pseudoinstrucciones
abs
$1=$2$3
div $1,$2,$3
(cociente)
$1=$2$3
divu $1,$2,$3
(cociente)
mul $1,$2,$3
$1=$2*$3
mulo $1,$2,$3
$1=$2*$3
mulou $1,$2,$3
$1=$2*$3
Comentarios
Posible excepción por desbordamiento
Posible excepción por desbordamiento
Posible excepción por desbordamiento
Posible excepción por desbordamiento
-
Posible excepción por desbordamiento
Posible excepción por desbordamiento
Posible excepción por desbordamiento
14
Instrucciones lógicas
Instrucción
and
or
xor
nor
andi
ori
xori
shift left logical
shift left logical variable
shift right logical
shift right logical variable
shift right arithmetic
shift right arithmetic variable
Ejemplo
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
sllv $1,$2,$3
srl $1,$2, 10
srlv $1
$1,$2,$3
$2 $3
sra $1,$2,10
srav $1,$2,$3
Lenguajes máquina y ensamblador
Significado
$1= $2&$3
$1=$2|$3
$1=$2$3
$1=~($2|$3)
$1=$2&10
$1= $2|10
$1=$210
$1
$210
$1= $2<<10
$1= $2<<$3
$1=$2>>10
$1=$2>>$3
$1=$2>>10
$1=$2>>$3
Comentarios
15
Instrucciones de carga/almacenamiento

Las operaciones de carga y almacenamiento permiten
transferencias de datos entre memoria y registros
 El formato de la instrucción dispone de 16 bits pero no son
suficientes para acceder a toda la memoria del computador
 Se considera que la dirección es un desplazamiento
qque hayy qque sumar al contenido de un registro
g
base

Las operaciones de carga (load) mueven un dato
desde memoria hasta un registro y las operaciones
de almacenamiento (store) al contrario
Lenguajes máquina y ensamblador
16
Instrucciones de carga/almacenamiento
a = memoria[2]
lw $
$s0,, 8($s1)
($ )
valor
registro
a
$s0
$
memoria
$s1
memoria
0x00
0
0x04
1
0x08
2
0x0c
3
0x10
4
0x14
…
NOTA: cargar un valor de memoria en un registro.
Lenguajes máquina y ensamblador
17
Instrucciones de carga/almacenamiento
memoria[2] = a
sw $
$s0,, 8($s1)
($ )
valor
registro
a
$s0
$
memoria
$s1
memoria
0x00
0
0x04
1
0x08
2
0x0c
3
0x10
4
0x14
…
NOTA: almacenar el valor de un registro en memoria.
Lenguajes máquina y ensamblador
18
Instrucciones de carga/almacenamiento
g = h + memoria[3]
lw $
$t0,, 12($s2)
($ )
add $s0, $s1, $t0
valor
registro
g
$s0
$
h
$s1
memoria
$s2
memoria
0x00
0
0x04
1
0x08
2
0x0c
3
0x10
4
0x14
…
NOTA: realizar una operación con uno de los operandos en memoria.
Lenguajes máquina y ensamblador
19
Instrucciones de carga/almacenamiento
memoria[4] = a + memoria[4]
lw $
$t0,, 4($s1)
($ )
add $t0, $t0, $s0
sw $t0,16($s1)
valor
registro
a
$s0
$
memoria
$s1
memoria
0x00
0
0x04
1
0x08
2
0x0c
3
0x10
4
0x14
…
NOTA: realizar una operación con uno de los operandos en memoria y almacenar el resultado en memoria.
Lenguajes máquina y ensamblador
20
Instrucciones de transferencia de datos
Instrucción
carga byte
carga byte sin ext.
ext signo
carga media palabra
carga media palabra sin
extensión de signo
carga palabra
carga inmediata de la
parte más significativa
“load upper inmediate”
carga
registro
del
coprocesador z
almacena byte
almacena media palabra
almacena palabra
almacena registro
g
en
memoria registro del
coprocesador z
Ejemplo
lb $1,10($2)
lbu $1
$1,10($2)
10($2)
lh $1,10($2)
Significado
$1=M[10+$2]
$1=M[10+$2]
$1=M[10+$2]
Extiende el bit de signo
No extiende el bit de signo
Extiende el bit de signo
lhu $1,10($2)
$1=M[10+$2]
No extiende el bit de signo
lw $1,10($2)
$1=M[10+$2]
lui $1,50
$1=50*216
lwc1 $f0,10($2)
( )
$f0= M[10+$2]
sb $1,10($2)
sh $1,10($2)
sw $1,10($2)
M[10+$2]=$1
M[10+$2]=$1
M[10+$2]=$1
swc1 $f0,10($2)
M[10+$2]=$f0
carga inmediata
li $1,1000
carga dirección
la $3,label
Lenguajes máquina y ensamblador
Comentarios
Carga un dato de 16 bits en la parte más
significativa del registro.
Pseudoinstrucciones
Carga de un dato de 32 bits
$1=1000
$3 di
$3=dirección
ió d
de Transfiere
f
la dirección de memoria no el
contenido.
label
21
Instrucciones de movimiento de datos
Instrucción
mover desde Hi
mover desde Lo
mover a Hi
mover a Lo
mover desde coprocesador z
mover al coprocesador z
transfiere o mueve
transfiere doble desde coproc. 1
Lenguajes máquina y ensamblador
Ejemplo
Significado
Comentarios
mfhi $1
$1= Hi
mflo $1
$1= Lo
mthi $1
Hi=$1
mtlo $1
Lo=$1
$f0-$f30: Registros del coprocesador 1
mfcz $1,$f0
$1=$f0
mtcz $1,$f0
$f0=$1
Pseudoinstrucciones
move $1,$2
$1=$2
$4=$F0
mfc1.d $4,$f0
$5=$F1
22
Instrucciones de control de flujo

Las instrucciones de control de flujo generan un
salto en la secuencia de ejecución del programa

En general, existen dos tipos de instrucciones de salto
 Saltos condicionales: según una determinada condición se
d id sii continuar
decide
i
con la
l secuencia
i del
d l programa o saltar
l a
otra posición
 Saltos
S lt incondicionales:
i
di i l siempre
i
se produce
d
ell salto,
lt
no hay condiciones a tener en cuenta
Lenguajes máquina y ensamblador
23
Saltos condicionales

Normalmente son saltos relativos al PC
 La dirección de destino se da como un
desplazamiento que se suma o resta al PC
 El código puede ejecutarse independientemente
de su posición en memoria

Los saltos suelen ser cortos, por lo que se
utilizan pocos bits para especificar la dirección
Lenguajes máquina y ensamblador
24
Saltos incondicionales

La dirección de la siguiente instrucción
es especificada por la instrucción de salto,
salto
pudiendo hacerlo de dos formas distintas
 Directa:
el propio código de la instrucción contiene la dirección
 Indirecta:
la instrucción indica un registro que contiene la dirección
Lenguajes máquina y ensamblador
25
Instrucciones de control de flujo
si (a = b) saltar a DESTINO
beq
q$
$s0,$s1,
,$ , DESTINO
valor
registro
a
$s0
$
b
$s1
NOTA: saltar a una posición si dos valores son iguales.
Lenguajes máquina y ensamblador
26
Instrucciones de control de flujo
si (a ≠ b) saltar a DESTINO
bne $
$s0,$s1,
,$ , DESTINO
valor
registro
a
$s0
$
b
$s1
NOTA: saltar a una posición si dos valores son diferentes.
Lenguajes máquina y ensamblador
27
Instrucciones de control de flujo
saltar a DESTINO
j DESTINO
NOTA: saltar incondicionalmente a una posición.
Lenguajes máquina y ensamblador
28
Instrucciones de control de flujo
saltar a la posición indicada por el registro $s0
jjr $
$s0
NOTA: saltar incondicionalmente a la posición dada por un registro.
Lenguajes máquina y ensamblador
29
Instrucciones de control de flujo
si (a = b)
si no
sino:
fin:
fi
f=f+2
f=f+4
bne $s0,$s1, sino
addi $s2, $s2, 2
j fin
addi $s2, $s2, 4
…
valor
registro
a
$s0
$
b
$s1
f
$s2
NOTA: elegir entre dos acciones distintas.
Lenguajes máquina y ensamblador
30
Instrucciones de control de flujo
contar hasta 5 en el registro $s0
bucle:
fin:
add $
$s0,, $0,
$ , $0
$
addi $s1, $0, 5
beq $s0, $s1, fin
addi $s0, $s0, 1
j bucle
…
NOTA: realizar una misma acción varias veces.
Lenguajes máquina y ensamblador
31
Instrucciones de control de flujo
sumar 1 a las 5 primeras posiciones de memoria
bucle:
fin:
add $
$s0,, $0,
$ , $0
$
addi $s1, $0, 20
beq $s0, $s1, fin
lw $t0, memoria($s0)
addi $t0, $t0, 1
sw $t0,
$t0 memoria($s0)
addi $s0, $s0, 4
j bucle
…
memoria
0x00
0
0x04
1
0x08
2
0x0c
3
0x10
4
0x14
…
NOTA: realizar una misma acción varias veces pero en posiciones de memoria distintas.
Lenguajes máquina y ensamblador
32
Instrucciones de salto
Instrucción
salta sobre igual
salta sobre no igual
salta sobre mayor o igual que cero
salta sobre mayor o igual que cero y
enlazar
.....
salto incondicional
salto incondicional (registro)
salto incondicional y enlazar
salto incondicional y enlazar (registro)
salta sobre mayor o igual
salta sobre mayor que
salta sobre menor o igual
salta sobre menor que
.....
Lenguajes máquina y ensamblador
Ejemplo
beq $1,$2,100
bne $1,$2,100
bgez $1,100
Significado
si($1==$2) ir a PC+4 +100
si($1!=$2) ir a PC+4 +100
si($1>=0) ir a PC+4 +100
bgezal $1,1000
si($1>=0) $31=PC+4; ir a 1000
Comentarios
ir a 2000
j 2000
ir a $1
jr $1
$31=PC+4; ir a 10000
jal 10000
$31=PC+4; ir a $1
jalr $1
Pseudoinstrucciones
si($1>=$2)
si($1
$2) ir a PC
PC+4
4 +100
100
bge $1
$1,$2,100
$2 100
si($1>$2) ir a PC+4 +100
bgt $1,$2,100
si($1<=$2) ir a PC+4 +100
ble $1,$2,100
si($1<$2) ir a PC+4 +100
blt $1,$2,100
33
Instrucciones de comparación
Instrucción
Inicializar menor que
Ejemplo
slt $1,$2,$3
Significado
if ($2<$3) then
$1=1
else
$1=0
endif
Comentarios
inicializar menor que sin signo
sltu $1,$2,$3
Inicializar menor que inmediato
slti $1,$2,5
Inicializar menor que inmediato sin signo sltiu $1,$3,$5
Inicializa igual
inicializa mayor
y o igual
g
inicializa mayor que
inicializa menor o igual
inicializa no igual
Lenguajes máquina y ensamblador
Pseudoinstrucciones
si ($2==$3) then
$1=1
$1
1
seq $1,$2,$3
else
$1=0
endif
sge
g $
$1,$2,$3
,$ ,$
sgt $1,$2,$3
sle $1,$2,$3
sne $1,$2,$3
34
Arquitectura MIPS
Registros
 Instrucciones
I t
i
 Organización de la memoria
 Formato de las instrucciones
 Modos de direccionamiento
 Subprogramas

Lenguajes máquina y ensamblador
35
Organización de la memoria en el MIPS
Los datos se almacenan en memoria
siguiendo el convenio Big Endian
Endian*
 El tamaño de palabra es de 32 bits
0x10203040
 Los accesos deben estar alineados






La memoria dispone de 232 bytes
Hay 231 medias palabras
Hay 230 palabras
Hay 228 dobles palabras
Memoria
…
0
0x10
0x20
0x30
0x40
…
2n – 1
MIPS dispone
p
de cinco modos de direccionamiento
 Tres para acceso a operandos
 Dos para
p ruptura
p
de secuencia ((condicional e incondicional))
(*) ¡ojo! El PCspim actúa como si fuera little endian porque se ejecuta en un Pentium.
Lenguajes máquina y ensamblador
36
Arquitectura MIPS
Registros
 Instrucciones
I t
i
 Organización de memoria
 Formato de las instrucciones
 Modos de direccionamiento
 Subprogramas

Lenguajes máquina y ensamblador
37
Formato de las instrucciones

Hay tres formatos posibles para las instrucciones,
teniendo todos ellos 32 bits de longitud
 Formato R:
OP destino (rd), fuente (rs), fuente (rt)
op
6 bits
 Formato I:
rt
5 bits
rd
5 bits
shamt
5 bits
funct
6 bits
OP ddestino
ti (rt),
( t) fuente
f t (rs),
( ) inmediato
i
di t
op
6 bits
 Formato J:
rs
5 bits
rs
5 bits
rt
5 bits
inmediato/dirección
16 bits
OP dirección
op
6 bits
Lenguajes máquina y ensamblador
dirección objetivo
26 bits
38
Arquitectura MIPS
Registros
 Instrucciones
I t
i
 Organización de memoria
 Formato de las instrucciones
 Modos de direccionamiento
 Subprogramas

Lenguajes máquina y ensamblador
39
Modos de direccionamiento

Los modos de direccionamiento de los que dispone la
arquitectura MIPS son los siguientes:
 Registro: utilizado por las instrucciones aritmético/lógicas
cuyos operandos están almacenados en registros
add

$1,$2,$3
$1= $2 + $3
formato R
OP
rs
rt
rd
registro
Lenguajes máquina y ensamblador
40
Modos de direccionamiento

Los modos de direccionamiento de los que dispone la
arquitectura MIPS son los siguientes:
 Inmediato: utilizado por las instrucciones aritmético/lógicas
que operan el contenido de un registro con un valor inmediato
y por las instrucciones que cargan valores inmediatos en
registros o almacenan valores inmediatos en memoria
addi

$1,$2,25
$1= $2 + 25
formato I
OP
rs
Lenguajes máquina y ensamblador
rt
inmediato
41
Modos de direccionamiento

Los modos de direccionamiento de los que dispone la
arquitectura MIPS son los siguientes:
 Base + desplazamiento: utilizado por las
instrucciones de carga/almacenamiento
lw
sw
$1, 100($2)
$1, 100($2)


$1 = mem[100+$2]
mem[100+$2] = $1
formato I
OP
rs
rt
dirección
+
memoria
registro
Lenguajes máquina y ensamblador
42
Modos de direccionamiento

Los modos de direccionamiento de los que dispone la
arquitectura MIPS son los siguientes:
 Relativo al contador de programa: utilizado por las
instrucciones de salto condicional
beq
$1,$2,destino 
si ($1 = $2) ir a destino
formato I
OP
rs
rt
dirección
+
PC
Lenguajes máquina y ensamblador
43
Modos de direccionamiento

Los modos de direccionamiento de los que dispone la
arquitectura MIPS son los siguientes:
 Pseudodirecto: utilizado por las
instrucciones de salto incondicional
j destino

ir a destino
formato J
OP
dirección
PC
Lenguajes máquina y ensamblador
44
Ejemplos de instrucciones
add $s0, $s1, $s2
0x02328020
formato R
op
rs
rt
rd
shamt
funct
000000
10001
10010
10000
00000
100000
código de código
de
operación
registro fuente registro
fuente
R17
registro fuente registro
fuente
R18
registro destino registro
destino
R16
desplazamiento
distinción dentro dentro
de la operación
Lenguajes máquina y ensamblador
45
Ejemplos de instrucciones
sub $s2, $t0, $t1
0x01099022
formato R
op
rs
rt
rd
shamt
funct
000000
01000
01001
10010
00000
010010
código de código
de
operación
registro fuente registro
fuente
R8
registro fuente registro
fuente
R9
registro destino registro
destino
R18
desplazamiento
distinción dentro dentro
de la operación
Lenguajes máquina y ensamblador
46
Ejemplos de instrucciones
addi $s2, $s4, 23
0x22920017
formato I
op
rs
rt
inmediato
001000
10100
10010
0000000000010111
código de código
de
operación
registro fuente registro
fuente
R20
registro destino registro
destino
R18
operando inmediato
operando
inmediato
23(10)
23
1
Lenguajes máquina y ensamblador
2
11
1
2
5
1
2
2
0
2
1
47
Ejemplos de instrucciones
lui $s1, 0x1234
0x3C111234
formato I
op
rs
rt
inmediato
001111
00000
10001
0001001000110100
código de código
de
operación
no se usa
no
se usa
registro fuente
registro destino registro
destino
R17
operando inmediato
operando
inmediato
1234(16)
Lenguajes máquina y ensamblador
48
Ejemplos de instrucciones
lw $s0, 32($s2)
0x8E500020
formato I
op
rs
rt
dirección
100011
10010
10000
0000000000100000
código de código
de
operación
registro base
registro
base
R18
registro destino registro
destino
R16
desplazamiento sobre el registro
desplazamiento
sobre el registro base
32(10)
Lenguajes máquina y ensamblador
49
Ejemplos de instrucciones
sw $s0, 4($s2)
0xAE500004
formato I
op
rs
rt
dirección
101011
10010
10000
0000000000000100
código de código
de
operación
registro base
registro
base
R18
registro fuente registro
fuente
R16
desplazamiento sobre el registro
desplazamiento
sobre el registro base
4(10)
Lenguajes máquina y ensamblador
50
Ejemplos de instrucciones
[0x00400024]
[0x00400028]
[0x0040002c]
[0x00400030] destino:
beq $t1, $t2, destino
…
…
…
0x112A0002
f
formato I
t I
op
rs
rt
dirección
000100
01001
01010
0000000000000010
código de operación
registro fuente
R9
registro fuente R10
desplazamiento sobre el PC+4
2(10)
X
0x24 + 4(10) = 0x28
0x30 – 0x28 = 8(10) = 1000(2)  10(2)
Lenguajes máquina y ensamblador
51
Ejemplos de instrucciones
[0x00400024]
[0x00400028]
[0x0040002c]
[0x00400030] destino:
j destino
…
…
…
0x0810000c
f
formato J
t J
op
dirección objetivo
000010
00000100000000000000001100
código de operación
26 bits de la dirección de destino del salto
0000 00000100000000000000001100 00 = 0x00400030
PC
x4
Lenguajes máquina y ensamblador
52
Ejemplos de instrucciones
[0x00400024]
[0x00400028]
[0x0040002c]
[0x00400030] destino:
jal destino
…
…
…
0x0c10000c
f
formato J
t J
op
dirección objetivo
000011
00000100000000000000001100
código de operación
26 bits de la dirección de destino del salto
0000 00000100000000000000001100 00 = 0x00400030
PC
x4
Lenguajes máquina y ensamblador
53
Ejemplos de instrucciones
jr $ra
0x03e00008
formato R
op
rs
rt
rd
shamt
funct
000000
11111
00000
00000
00000
001000
código de código
de
operación
registro fuente registro
fuente
R31
no se usa no
se usa
registro fuente
no se usa no
se usa
registro destino
desplazamiento
distinción dentro dentro
de la operación
Lenguajes máquina y ensamblador
54
Ejemplos de instrucciones

Codifica en lenguaje máquina las siguientes instrucciones:
bne $t1, $t0, alli
slt $s0, $t0, $t1
lb $t1, 0($t0)
l $t1,
lw
$t1 4($t0)
alli:
sb $t3, 5($t0)

Decodifica las siguientes instrucciones asumiendo que el valor
del PC es 0x00400000:
0 02 10018
0x02510018
0X01698822
0X0C100012
0X20090002
0X00129043
Lenguajes máquina y ensamblador
55
Ejemplos de instrucciones

Codifica en lenguaje máquina las siguientes instrucciones:
bne $t1, $t0, alli
(0x15280004)
slt $s0, $t0, $t1
(0x0109802a)
lb $t1, 0($t0)
(0x81090000)
l $t1,
lw
$t1 4($t0)
(0 8d090004)
(0x8d090004)
alli:
sb $t3, 5($t0)
(0xa10b0005)

Decodifica las siguientes instrucciones asumiendo que el valor
del PC es 0x00400000:
0 02 10018 (mult
0x02510018
(
$18 $19)
$18,
0X01698822 (sub $17, $11,$9)
0X0C100012 (jal 0X00400048)
0X20090002 (addi $9, $0, 2)
0X00129043 (sra $18, $18, 1)
Lenguajes máquina y ensamblador
56
Arquitectura MIPS
Registros
 Instrucciones
I t
i
 Organización de memoria
 Formato de las instrucciones
 Modos de direccionamiento
 Subprogramas

Lenguajes máquina y ensamblador
57
Subprogramas

Un subprograma es una porción de código dentro de un
programa más grande que realiza una tarea concreta de
forma relativamente independiente al resto del código

El uso de subprogramas proporciona
d grandes
dos
d ventajas
j
 Permite estructurar mejor los programas, descomponiendo
problemas
bl
complejos
l j en otros más
á simples
i l que se pueden
d
tratar por separado
 Permite
P
it reutilizar
tili código,
ódi dando
d d lugar
l
a bibliotecas de subprogramas
Lenguajes máquina y ensamblador
58
Instrucciones de llamada y retorno

Los subprogramas pueden ser activados
desde otras partes del programa principal
 La transferencia de control se realiza por medio de
instrucciones de llamada y retorno
 El proceso de llamada debe almacenar parte del estado del
computador,
p
, lo que
q incluye
y al menos la dirección de retorno
Programa principal
D1: instrucción 1
D2: instrucción 2
D3: Llamada a “X”
D4: instrucción 4
.
.
Dn: instrucción n
Guarda dirección
D4
Subprograma X
instrucción 1
instrucción 2
instrucción 3
retorno
Almacenamiento
temporal
(registro o pila)
Recupera
D4
Lenguajes máquina y ensamblador
59
Instrucciones de llamada y retorno

Las instrucciones de llamada son saltos incondicionales
que almacenan la dirección de la siguiente instrucción
de la secuencia en el registro $31
guardar la dirección de la siguiente instrucción
de la secuencia (PC+4) y saltar a la posición M
jal M

Las instrucciones de retorno son saltos incondicionales
a la dirección indicada ppor el registro
g
$$31
regresar a la posición
indicada por el registro $31
jr $31
Lenguajes máquina y ensamblador
60
Uso de registros en subprogramas

Los subprogramas utilizarán los mismos registros que
el programa principal
principal, por lo que hay que determinar
qué ocurre con sus contenidos
 Hay dos convenios básicos para guardar los registros:
▫ Guarda el llamador (caller-saving): antes de llamar al subprograma
se guardan los registros cuyo contenido se quiere preservar
▫ Guarda el llamado (called-saving): el subprograma llamado es
quien se encarga de guardar los registros que quiera reutilizar
Lenguajes máquina y ensamblador
61
Paso de parámetros
Al llamar a un subprograma puede ser necesario
pasarle parámetros
parámetros, es decir,
decir datos que necesitará para
trabajar
 Los
L subprogramas
b
también
t bié pueden
d generar resultados
lt d
que deberán ser proporcionados al programa principal
 La transferencia
f
i de
d parámetros de
d entrada
d y resultados
l d
entre subprogramas se realizar por medio de estructuras
d almacenamiento
de
l
i
temporall

 Registros
 Pila
Lenguajes máquina y ensamblador
62
Etapas en la llamada a un subprograma
P
Programa
principal
i i l

Paso 1: Paso de parámetros.
parámetros
- Colocar los parámetros en el lugar
adecuado para pasarlos al subprograma
(en registros o en la pila).
Paso 2: Llamada al subprograma.


S b
Subprograma
Paso 3: Salvar registros.
- Crear el bloque de activación, que
consiste en el conjunto de recursos de
almacenamiento que necesitará el
subprograma durante su ejecución.
- Guardar en los registros que se deseen
preservar para después de la ejecución
del subprograma.
Paso 4: Cuerpo del subprograma.
- Ejecutar la tarea a realizar.
Paso 5: Resultados.
- Colocar los resultados en el lugar
g
adecuado para pasarlos al programa
principal.
- Restaurar registros.
- Destruir
D t i bloque
bl
d
de activación.
ti
ió
Paso 6: Retorno al programa principal.
- Regresar a la dirección de memoria
inmediatamente posterior a la llamada
al subprograma.
Lenguajes máquina y ensamblador
63
La pila

Estructura de datos tipo LIFO (Last Input First Output)
que se utiliza para
 Preservar datos durante la ejecución de subprogramas
 Pasar parámetros a subprogramas y devolver resultados

Hay dos operaciones básicas que se realizan sobre pilas
 Guardar
d (push)
( h)
 Recuperar (pop).

Normalmente existe un registro llamado puntero de
pila cuyo contenido apunta a la cima de la pila que, en
general, crece hacia posiciones más bajas de memoria
Lenguajes máquina y ensamblador
64
Operaciones sobre la pila
Guardar (push)
Recuperar (pop)
1. Decrementar puntero
2. Escribir en memoria
MIPS:
addi
$sp $sp -4
$sp,$sp,-4
sw
$reg, 0($sp)
Memoria
1. Leer de memoria
2. Incrementar puntero
MIPS:
lw
$reg 0($sp)
$reg,
addi
$sp,$sp,4
Dirección
Memoria
Baja
sp-4
Dirección
Baja
Valor guardado
sp
sp
Valor leído
sp+4
Alta
Lenguajes máquina y ensamblador
Alta
65
Bloque de activación en la pila
# Programa principal
…
Llamar X(p1,p2,..)
(p ,p , )
…
Antes
# Subprograma X(...)
<guardar registros>
<cuerpo>
<restaurar registros>
<retorno>
Dirección baja
de memoria
sp ->
sp ->
Durante
Después
Recursos locales
Registros
guardados
Dirección de retorno
fpOLD
<- fpNEW
sp ->
<- fpOLD
<- fp
Dirección alta
de memoria
Estado de la p
pila antes,, durante y después
p
de la llamada a un procedimiento.
p
Bloque de activación sombreado
Lenguajes máquina y ensamblador
66
Uso de la memoria
0x7FFFFFFF
Pila
Segmento de pila
Datos dinámicos
0x10000000
Datos estáticos
Código
Segmento de datos
Segmento de texto
0x00400000
0x00000000
Lenguajes máquina y ensamblador
Reservada
67
Convenio de uso de registros
Nombre Nº reg.
g
Uso
Preservado
en llamadas?
$zero
0
Constante 0
-
$at
1
Reservado para el ensamblador
-
$v0-$v1
2-3
Valores de resultados y evaluación de expresiones
no
$a0-$a3
4-7
Paso de parámetros (hasta cuatro; más a través de la pila)
no
$t0-$t7
8-15
Registros temporales
no
$s0 $s7
$s0-$s7
16 23
16-23
Registros que deben preservarse
si
$t8-$t9
24-25
Registros temporales
no
$k0-$k1
26-27
Reservado para el Sistema Operativo
-
$
$gp
28
P t
Puntero
global
l b l (global
( l b l pointer)
i t )
sii
$sp
29
Puntero de pila (stack pointer)
si
$fp
30
Puntero de bloque de activación (frame pointer)
si
$
$ra
31
Di
Dirección
ió d
de vuelta
lt ((return
t
address)
dd
)
sii
Las abreviaciones de dos letras y nombre de los registros reflejan los usos pensados para ellos en el convenio.
Lenguajes máquina y ensamblador
68
Bibliografía
Estructura y diseño de computadores
Interficie circuitería/programación
David A. Patterson y John L. Hennessy
Editorial Reverté, 2000
Lenguajes máquina y ensamblador
69