Instrucciones: Lenguaje del computador

(I I Pa rt e )
I nst ruc c ione s: Le ngua je
de l c om put a dor
§2.1 Introducción
Es el repertorio de instrucciones de un
computador
Procesadores diferentes tienen conjunto de
instrucciones diferentes.
Pero con muchos aspectos en común
Los primeros computadores tenían un conjunto
de instrucciones muy sencillo.
Construcción muy simple.
Muchos computadores modernos también tienen
un conjunto de instrucciones simples.
Ing. JoséAlberto Díaz García
2
Utilizado como ejemplo en el libro de texto
Stanford MIPS, comercializado por MIPS
Technologies (www.mips.com)
Son utilizadas por gran parte del mercado
Aplicaciones en electrónica de consumo, equipo de
redes/almacenamiento, cámaras, impresoras,
.
Típicas en muchas ISAs modernas.
Ing. JoséAlberto Díaz García
3
Se refiere a la forma en que se escriben
las instrucciones y los operandos que se
involucran en cada uno de los campos.
En las instrucciones MIPS hay dos
formatos para escribir las instrucciones
Formato básico
Formato para instrucciones en punto flotante
Ing. JoséAlberto Díaz García
4
Básicas
Se refiere a instrucciones aritméticas, de manejo de
datos y control de programa necesarias para escribir
algoritmos en código ensamblador, para que sean
interpretadas por un procesador con instrucciones
MIPS.
Punto flotante
Los MIPS tienen un coprocesador que opera en punto
flotante con precisión sencilla (32 bits), o con doble
precisión (64 bits)
El coprocesador cuenta con su grupo de registros de
32 bits de ancho enumerados con $f0 hasta $f31.
Ing. JoséAlberto Díaz García
5
Ing. JoséAlberto Díaz García
6
Ing. JoséAlberto Díaz García
7
$a0 $a3: argumentos (reg s 4 7)
$v0, $v1: valores de resultados (reg s 2 y 3)
$t0 $t9: temporales
Pueden sobreescribirse por un call
$s0
$s7: almacenar
Deben ser almacenados/salvados por un call
$gp: puntero global para datos estáticos (reg 28)
$sp: puntero de pila (reg 29)
$fp: puntero de marco o frame (reg 30)
$ra: dirección de retorno (reg 31)
Ing. JoséAlberto Díaz García
8
Resumen de los modos de direccionamiento
Ing. JoséAlberto Díaz García
9
Todas las instrucciones son de 32 bits de
ancho
Cuenta con formatos diferentes para
diferentes propósitos
La similitud en formatos permite una fácil
implementación
31
31
31
6 bits
5 bits
5 bits
5 bits
5 bits
op
rs
rt
rd
6 bits
5 bits
5 bits
16 bits
op
rs
rt
offset
shamt funct
6 bits
26 bits
op
address
Ing. JoséAlberto Díaz García
6 bits
0
0
Formato R
Formato I
Formato J
0
10
Formato básicas
Formato en punto flotante
Ing. JoséAlberto Díaz García
11
Aritméticas & Lógicas
en registros
add $s1, $s2, $s3
or $s3, $s4, $s5
manipulan datos
$s1 = $s2 + $s3
$s3 = $s4 OR $s5
Transferencia de datos mueve datos que
se encuentran en registros a o de memoria
lw $s1, 100($s2)
sw $s1, 100($s2)
$s1 = Memory[$s2 + 100]
Memory[$s2 + 100] = $s1
Salto - altera el flujo del programa
beq $s1, $s2, 25
Ing. JoséAlberto Díaz García
if ($s1==$s1) PC = PC + 4 + 4*25
12
Uso de instrucciones (assembly)
add dest, src1, src2
sub dest, src1, src2
and dest, src1, src2
dest=src1 + src2
dest=src1 - src2
dest=src1 AND src2
Características de las instrucciones
Siempre tres operandos: destino y dos fuentes
El orden de los operandos está definido
Los operandos siempre se encuentran en los
registros de propósito general
Ing. JoséAlberto Díaz García
13
Representación binaria de las
instrucciones aritméticas & lógicas
6 bits
5 bits
5 bits
5 bits
op
rs
rt
rd
31
5 bits
6 bits
shamt funct
0
Utilizado en instrucciones aritméticas, lógicas y
de desplazamiento.
También se les llama instrucciones con formato
tipo R.
Ing. JoséAlberto Díaz García
14
opcode
Presenta el código binario que representa la operación básica que realizará la
instrucción, por lo general se le llama código de operación
rs
Se presenta el código correspondiente al registro donde se encuentra el primer
operando
rt
Se presenta el código correspondiente al registro donde se encuentra el segundo
operando
rd
Se presenta el código correspondiente al registro destino donde se almacenará
el resultado de la operación
shamt
Shift amount, se utiliza en algunas instrucciones relacionadas con
desplazamientos de bits
funct
Función, algunas veces llamado como código de función, selecciona las
variantes específicas del código de operación.
Ing. JoséAlberto Díaz García
15
Representación binaria de las
instrucciones aritméticas y lógicas
Lenguaje máquina para
add $8, $17, $18
En la tarjeta de referencia buscar los
valores para op, funct
6 bits
5 bits
5 bits
5 bits
op
rs
rt
rd
5 bits
6 bits
shamt funct
31
0
0
17
18
8
0
32
000000 10001 10010 01000 00000 100000
Ing. JoséAlberto Díaz García
Decimal
Binaria
16
Dos fuentes y un destino
add a, b, c
# a toma el valor de
b + c
Todas las operaciones aritméticas tienen la
misma forma
Principio de Diseño #1: La simplicidad favorece
la regularidad
La regularidad hace simple la implementación.
Simplicidad permite un mayor rendimiento a menor
costo
Ing. JoséAlberto Díaz García
§2.2 Operaciones y el hardware del computador
Sume y substraer, tres operandos
17
Código en lenguaje C:
f = (g + h) - (i + j);
Compilado en código MIPS:
add t0, g, h
add t1, i, j
sub f, t0, t1
Ing. JoséAlberto Díaz García
# temp t0 = g + h
# temp t1 = i + j
# f = t0 - t1
18
Datos constantes especificados en una
instrucción
addi $s3, $s3, 4
No hay una instrucción para substraer en forma
inmediata.
Basta con utilizar una constante negativa
addi $s2, $s1, -1
Principio de Diseño 3: Haga el caso común lo
más rápido posible.
Las constantes pequeñas son comunes
Los operandos inmediatos eliminan las instrucciones
de cargue.
Ing. JoséAlberto Díaz García
19
El registro MIPS 0 ($zero) es la constante 0
No se puede sobre escribir
Útil para las operaciones comunes
Por ejemplo, movimientos entre registros
add $t2, $s1, $zero
Ing. JoséAlberto Díaz García
20
x
x n 12
n 1
xn 22
Rango: 0 a +2n
Ejemplo
n 2
1
x12
x0 2
0
1
§2.4 Números con signo y sin signo
Dado un número de n-bit
0000 0000 0000 0000 0000 0000 0000 10112
=0+
+ 1×23 + 0×22 +1×21 +1×20
=0+
+ 8 + 0 + 2 + 1 = 1110
Utilizando 32 bits
0 a +4,294,967,295
Ing. JoséAlberto Díaz García
21
Enteros con signo en complemento a 2
Dado un número de n-bit
x
x n 12
n 1
Rango: 2n
Ejemplo
xn 22
1
n 2
a +2n
1
x12
1
x0 2
0
1
1111 1111 1111 1111 1111 1111 1111 11002
= 1×231 + 1×230 +
+ 1×22 +0×21 +0×20
= 2,147,483,648 + 2,147,483,644 = 410
Utilizando 32 bits
2,147,483,648 a +2,147,483,647
Ing. JoséAlberto Díaz García
22
Enteros con signo en complemento a 2
El bit 31 es el bit de signo
1 para los números negativos
0 para los números positivos
( 2n 1) no puede representarse
Los números positivos tienen el mismo signo y la
misma representación en complemento a 2.
Algunos números específicos
0: 0000 0000
0000
1: 1111 1111
1111
Más negativo: 1000 0000
Más positivo: 0111 1111
Ing. JoséAlberto Díaz García
0000
1111
23
Complemento y sume 1
Complemento significa 1
x x 1111...1112
x 1
0, 0
1
1
x
Ejemplo: negar +2
+2 = 0000 0000
2 = 1111 1111
= 1111 1111
Ing. JoséAlberto Díaz García
00102
11012 + 1
11102
24
Representa números utilizando más bits
Conserva el valor numérico
En el conjunto de instrucciones MIPS
addi: para valores inmediatos extendidos
lb, lh: carga extendida byte/mediapalabra
beq, bne: extendida con desplazamiento
Reproduce el bit de signo a la izquierda
p.e. números sin signo: extendidos con 0s
Ejemplo: 8-bit a 16-bit
+2: 0000 0010 => 0000 0000 0000 0010
2: 1111 1110 => 1111 1111 1111 1110
Ing. JoséAlberto Díaz García
25
Se llaman código máquina
Instrucciones MIPS
Se codifican en palabras de instrucción de 32-bits.
Los formatos de números pequeños, codificación del
código de operación (opcode), números de registros,
Reproducciones
Numero de los registros
$t0 $t7 son los registros del 8 15
$t8 $t9 son los registros del 24 25
$s0 $s7 son los registros del 16 23
Ing. JoséAlberto Díaz García
§2.5 Representación de instrucciones en el computador
Las instrucciones se codifican en binario
26
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
Campos de la instrucción
op: código de operación (opcode)
rs: número del primer registro fuente
rt: número del segundo registro fuente
rd: número del registro destino
shamt: cantidad de desplazamientos (00000
por fila)
funct: código de la función (opcode extendido)
Ing. JoséAlberto Díaz García
27
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
add $t0, $s1, $s2
special
$s1
$s2
$t0
0
add
0
17
18
8
0
32
000000
10001
10010
01000
00000
100000
000000100011001001000000001000002 = 0232402016
Ing. JoséAlberto Díaz García
28
Base 16
Representación compacta de una cadena de bits
4 bits por cada dígito hexadecimal
0
1
2
3
0000
0001
0010
0011
4
5
6
7
0100
0101
0110
0111
8
9
a
b
1000
1001
1010
1011
c
d
e
f
1100
1101
1110
1111
Ejemplo: ECA8 6420
1110 1100 1010 1000 0110 0100 0010 0000
Ing. JoséAlberto Díaz García
29
op
rs
rt
Constante o dirección
6 bits
5 bits
5 bits
16 bits
Instrucción aritmética inmediata e instrucción load/store
rt: número de registro fuente o destino
Constante: 215 a+215 1
Dirección: se agrega un offset a la dirección base en rs
Principio de Diseño 4: Un buen diseño demanda un buen
compromiso
Los diferentes formatos complican la decodificación, pero
permiten uniformidad en instrucciones de 32 bits.
Mantenga los formatos lo más similar posible.
Ing. JoséAlberto Díaz García
30
Computadores con programa almacenado
La gra n figura
Las instrucciones se
representan en binario como
los datos.
Las instrucciones y los datos
se almacenan en memoria.
Los programas pueden
operar en programas
p.e., compiladores, linkers,
La compatibilidad binaria
permite a los programas
compilados operar en
diferentes computadores
ISAs estandarizadas
Ing. JoséAlberto Díaz García
31
Operación
C
Java
MIPS
Desplazamiento
izquierda
<<
<<
sll
Desplazamiento
derecha
>>
>>>
srl
Modo de bit AND
&
&
and, andi
Modo de bit OR
|
|
or, ori
Modo de bit NOT
~
~
nor
§2.6 Operaciones lógicas
Instrucciones par la manipulación de bits
Útil para insertar y extraer grupos de
bits en una palabra
Ing. JoséAlberto Díaz García
32
Útil para enmascarar bits en una palabra
Seleccionar algunos bits, borrar otros 0
and $t0, $t1, $t2
$t2
0000 0000 0000 0000 0000 1101 1100 0000
$t1
0000 0000 0000 0000 0011 1100 0000 0000
$t0
0000 0000 0000 0000 0000 1100 0000 0000
Ing. JoséAlberto Díaz García
33
Útil para incluir bits en una palabra
Ponga algunos bits en 1, deje los otros sin
cambiar.
or $t0, $t1, $t2
$t2
0000 0000 0000 0000 0000 1101 1100 0000
$t1
0000 0000 0000 0000 0011 1100 0000 0000
$t0
0000 0000 0000 0000 0011 1101 1100 0000
Ing. JoséAlberto Díaz García
34
Útil para invertir bits en una palabra
Cambiar 0 a 1, y 1 a 0
MIPS cuenta con una instrucción para realizar la
función NOR con tres operandos
a NOR b == NOT ( a OR b )
nor $t0, $t1, $zero
Registro 0: siempre
tiene ceros
$t1
0000 0000 0000 0000 0011 1100 0000 0000
$t0
1111 1111 1111 1111 1100 0011 1111 1111
Ing. JoséAlberto Díaz García
35
Transferencia de datos entre registros y
memoria
Formato de las instrucciones (ensamblador)
lw $dest, offset($addr)
sw $src, offset($addr)
load word
store word
Usos:
Accesar una variable en la memoria principal
Accesar un elemento de un arreglo
Ing. JoséAlberto Díaz García
36
8
R0=0 (constant)
R1
R2=0x10
R3
R4
R5 =R5
629310
+
0x00
0x04
0x08
0x0c
0x10
0x14
0x18
0x1c
Variable X
Variable Y
Variable Z = 692310
R30
R31
Registros
lw R5,8(R2)
Ing. JoséAlberto Díaz García
Memoria
37
12=0xc
R0=0 (constant)
R1
R2=0x08
R3
R4
R5=105
+
Dirección base
0x00
0x04
0x08
0x0c
0x10
0x14
0x18
0x1c
a[0]
a[1]
a[2]
a[3]=105
a[3]
a[4]
R30
R31
Registros
Programa en C: int a[5];
a[3] = z;
Offset para escalar
Memoria
Ensamblador:
sw $5,12($2)
Ing. JoséAlberto Díaz García
38
Representación binaria de
instrucciones para transferir datos
6 bits
5 bits
5 bits
16 bits
op
rs
rt
offset
Utilizado por instrucciones para cargar y
almacenar
Dirección
op: Operación básica de la instrucción (opcode)
rs: primer registro con primer operando fuente
rt: segundo registro con operando fuente
offset: offset para la dirección con signo en 16 bits (32,768 a +32,767)
También se le llama instrucciones con formato I
Ing. JoséAlberto Díaz García
39
Utilizados para el acceso frecuente de datos
Enumerados del 0 al 31
Un dato de 32-bits se denomina palabra
Nombres del ensamblador
$t0, $t1, , $t9 para valores temporales
$s0, $s1, , $s7 para variables almacenadas
§2.3 Operandos del hardware del computador
Las instrucciones aritméticas utilizan operandos
que se encuentran almacenados en los registros
MIPS tiene un grupo de registros de 32 × 32-bits
Principio de Diseño #2: Pequeño es rápido
p.e. memoria principal: millones de posiciones
Ing. JoséAlberto Díaz García
40
Ejemplo de operandos en registros
Código C:
f = (g + h) - (i + j);
f, , j in $s0, , $s4
Código MIPS compilado:
add $t0, $s1, $s2
add $t1, $s3, $s4
sub $s0, $t0, $t1
Ing. JoséAlberto Díaz García
41
Memoria principal utilizada para componer datos
Arreglos, estructuras, datos dinámicos
Aplicar operaciones aritméticas
Cargar valores de memoria a registros
Almacenar resultados de un registro a memoria
La memoria se direcciona por medio de un Byte
Cada dirección se identifica por un Byte
Las palabras se alinean en memoria
Las direcciones deben ser múltiplos de 4
Las MIPS son Big Endian
Los bytes más significativos por lo menos direccionan una
palabra
c.f. Little Endian: Bytes menos significativos por lo menos en una
dirección
Ing. JoséAlberto Díaz García
42
Ejemplo 1 operandos en memoria
Código C:
g = h + A[8];
g en $s1, h en $s2, dirección base de A en $s3
Compilado en código MIPS:
Índice 8 requiere un offset de 32
4 Bytes por palabra
lw $t0, 32($s3)
add $s1, $s2, $t0
offset
# cargue palabra
Registro base
Ing. JoséAlberto Díaz García
43
Código C:
A[12] = h + A[8];
h en $s2, dirección base de A en $s3
Código compilado en MIPS:
El índice 8 requiere un offset de 32
lw $t0, 32($s3)
# cargue word
add $t0, $s2, $t0
sw $t0, 48($s3)
# almacena word
Ing. JoséAlberto Díaz García
44
Los registros son más rápidos de accesar que la
memoria
Las operaciones con datos de memoria
requieren de instrucciones relacionadas con la
carga y el almacenamiento.
Más instrucciones para ejecutar
Los compiladores utilizan la mayor cantidad de
registros para almacenar las variables
Solo se almacenan en memoria las variables menos
frecuentes.
La optimización de registros es muy importante.
Ing. JoséAlberto Díaz García
45
Compare con el formato R
6 bits
5 bits
5 bits
5 bits
5 bits
op
rs
rt
rd
6 bits
5 bits
5 bits
16 bits
op
rs
rt
offset
6 bits
shamt funct
Formato R
Formato I
Note la similitud!
Ing. JoséAlberto Díaz García
46
Lenguaje máquina para
lw $9, 1200($8) == lw $t1, 1200($t0)
31
6 bits
5 bits
5 bits
16 bits
op
rs
rt
offset
35
8
9
1200
Decimal
0000010010110000
Binaria
100011 01000 01001
Ing. JoséAlberto Díaz García
0
47
Los saltos condicionales nos permiten realizar
decisiones
beq R1, R2, LABEL if R1==R2 goto LABEL
bne R3, R4, LABEL if R3!=R4 goto LABEL
Ejemplo
Código C
L1:
if (i==j) goto L1;
f = g + h;
f = f - i;
Ensamblador
L1:
beq $s3, $s4, L1
add $s0, $s1, $s2
sub $s0, $s0, $s3
Ing. JoséAlberto Díaz García
48
Ejemplo
Código C
if (i==j) f = g + h;
else f = g - h;
Ensamblador
Else:
Exit:
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit;
# salto incondicional nuevo
sub $s0, $s0, $s3
Nueva instrucción: Salto incondicional jump
j LABEL # goto Label
Ing. JoséAlberto Díaz García
49
6 bits
5 bits
5 bits
16 bits
op
rs
rt
offset
Estas instrucciones utilizan formato I
offset se le agrega al PC cuando se realiza el salto
beq r0, r1, offset
tiene el efecto:
Conversión a
word offset
if (r0==r1) pc = pc + 4 + (offset << 2)
else pc = pc + 4;
El Offset se especifica en las palabras de la instrucción
(¿Porqué?)
¿Cuál es el rango que puede tomar la etiqueta del salto?
Ing. JoséAlberto Díaz García
50
Lenguaje máquina
para
$20
$19
beq $s3, $s4, L1
add $s0, $s1, $s2
L1: sub $s0, $s0, $s3
PC
PC+4
Etiqueta
para beq
31
Offset de 1-instrucción
6 bits
5 bits
5 bits
16 bits
op
rs
rt
offset
4
19
20
1
Decimal
0000000000000001
Binaria
000100 10011 10100
Ing. JoséAlberto Díaz García
0
51
bne, beq realiza una comparación de igualdad
slt realiza una comparación de magnitud
Registro de
condición
slt $t0,$s3,$s4
# if $s3<$s4 $t0=1;
# else $t0=0;
Combina el salto con bne o beq:
slt $t0,$s3,$s4
bne $t0,$zero, Less
# if (a<b)
# goto Less;
¿Porque no se incluye la instrucción blt en el
hardware?
Si se realiza por hardware baja el rendimiento de la máquina
El ensamblador realiza esta función si se requiere (generando
dos instrucciones)
Ing. JoséAlberto Díaz García
52
Representación binaria de - Jump
6 bits
26 bits
op
address
Las instrucciones de salto utilizan el
formato j (op=2)
¿Qué sucede durante la ejecución?
PC = PC[31:28] : (IR[25:0] << 2)
Concatena los cuatro Conversión a
word offset
bits más
significativos del PC
para formar una
dirección de 32 bits
Ing. JoséAlberto Díaz García
53
Lenguaje máquina para:
Asuma L5 se encuentra en la dirección 0x00400020
j L5
y
PC <= 0x03FFFFFF
LSB 28
bits
>>2
31
6 bits
26 bits
op
address
2
0x0100008
000010
00000100000000000000001000
Ing. JoséAlberto Díaz García
0x0100008
0
Decimal/Hex
Binario
54
Instrucciones para Constantes / Inmediatas
Las constantes pequeñas se utilizan con cierta
frecuencia (50% de los operandos)
p.e.
A = A + 5;
B = B + 1;
C = C - 18;
Instrucciones MIPS inmediatas (Formato I):
addi $29, $29, 4
slti $8, $18, 10
andi $29, $29, 6
ori $29, $29, 4
Instrucciones aritméticas sign-extend immed.
Instrucciones lógicas sin sign extend immed.
Permite hasta constantes de 16 bits
¿Cómo carga una constante en un registro?
ori $5, $zero, 666
Ing. JoséAlberto Díaz García
55
Porque 16 bits caben perfectamente en
instrucciones de 32 bits.
Porque la mayoría de las constantes son
pequeñas (p. e. < 16 bits)
Principio de diseño #4: Haga el caso
común rápido
Ing. JoséAlberto Díaz García
56
and, andi ancho de un bit AND
or, ori ancho de bit OR
Ejemplo
$s0
11011111010110100100100011110101
$s1
11110000111100001111000011110000
and
$s2
11010000010100000100000011110000
ori
$s3,s2,252
(25210)
00000000000000000000000011111100
$s3
$s2,$s0,$s1
11010000010100000100000011111100
Ing. JoséAlberto Díaz García
57
Inmediatas de 32-Bits y direcciones
Las operaciones inmediatas generan constantes de 16
bits.
¿Que sucede cuando necesito constantes mas grandes?
Utiliza "load upper immediate - lui (Formato I) para poner
los 16 bits más significativos de la constante en el registro.
lui $t0, 1010101010101010
$t0
1010101010101010
(original contents)
0000000000000000
Lleno con ceros
Luego utilice ori para llenar en los 16 bits menos significativos:
ori $t0, $t0, 1010101010101010
$t0
1010101010101010
Ing. JoséAlberto Díaz García
1010101010101010
0000000000000000
58
Instrucciones MIPS para desplazamientos
Instrucciones MIPS para desplazamientos lógicos
Desplace a la izquierda: Instrucción SLL (shift-left logical)
Desplace a la derecha: Instrucción SRL (shift-right logical)
$s0
11011111010110100100100011110101
sll
$s1,$s0,8
Se introducen ceros
$s1
01011010010010001111010100000000
srl
$s2,$s1,4
Se introducen ceros
$s2
00000101101001001000111101010000
Ing. JoséAlberto Díaz García
59
Codificación de las instrucciones de
desplazamiento
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
op
rs
rt
rd
shamt funct
sll
0
rs
rt
rd
shamt
0
srl
0
rs
rt
rd
shamt
6
NO SE UTILIZAN
Aplicaciones
Acceso a los campos de los bits
Multiplicación / División en potencias de 2
Ejemplo: acceso a arreglo
Ing. JoséAlberto Díaz García
sll $t0,$t1,2 # $t0=$t1*4
add $t3,$t1,$t2
lw $t3, 0($t3)
60
¿Cuál es la instrucción en lenguaje ensamblador
de la siguiente instrucción en lenguaje máquina?
0x00AF8020
Convierta a binario
0000 0000 1010 1111 1000 0000 0010
0000
Decodifique
op: 00000
rs: 00101
rt: 01111
rd: 10000
shamt: 00000
funct: 100000
Solución: add $s0, $a1, $t7
Ing. JoséAlberto Díaz García
61
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
shamt: cantidad de posiciones a desplazar
Corrimiento lógico a la izquierda.
Desplace a la izquierda y llene con 0 bits
sll por i bits múltiples por 2i
Corrimiento lógico a la derecha
Desplace a la derecha y llene con ceros
srl por i bits divisibles por 2i (solo sin signo)
Ing. JoséAlberto Díaz García
62
En caso contrario, continúe secuencialmente
beq rs, rt, L1
si (rs == rt) salte a la instrucción con etiqueta L1;
bne rs, rt, L1
si (rs != rt) salte a la instrucción con etiqueta L1;
§2.7 Instrucciones para tomar decisiones
Saltar a una instrucción con etiqueta si la
condición es cierta
j L1
Salte incondicionalmente a la instrucción la
con etiqueta L1
Ing. JoséAlberto Díaz García
63
Código C:
if (i==j) f = g+h;
else f = g-h;
f, g,
in $s0, $s1,
Compilado en código MIPS:
bne
add
j
Else: sub
Exit:
$s3, $s4, Else
$s0, $s1, $s2
Exit
$s0, $s1, $s2
Ensamblador calcula la
dirección
Ing. JoséAlberto Díaz García
64
Código C:
while (save[i] == k) i += 1;
i en $s3, k en $s5, la dirección para
almacenar en $s6
Compilado en código MIPS:
Loop: sll
add
lw
bne
addi
j
Exit:
$t1,
$t1,
$t0,
$t0,
$s3,
Loop
Ing. JoséAlberto Díaz García
$s3, 2
$t1, $s6
0($t1)
$s5, Exit
$s3, 1
65
Un bloque básico es una secuencia de
instrucciones sin:
Saltos anidados (excepto al final)
Etiquetas para saltos (excepto al inicio)
El computador identifica los
bloques básicos para
optimizarlos
En los procesadores
avanzados se puede acelerar
la ejecución de bloques
básicos.
Ing. JoséAlberto Díaz García
66
El resultado es 1 si la condición es
verdadera
De lo contrario, es 0
slt rd, rs, rt
if (rs < rt) rd = 1; else rd = 0;
slti rt, rs, constante
if (rs < constante) rt = 1; else rt = 0;
Utilice en combinación con beq, bne
slt $t0, $s1, $s2
bne $t0, $zero, L
Ing. JoséAlberto Díaz García
# if ($s1 < $s2)
#
branch to L
67
¿Por qué no blt, bge, etc.?
Hardware para <, ,
slower than =,
Combinado con saltos involucra más trabajo
por instrucción, requiere un reloj más lento.
Todas la instrucciones penalizadas
beq y bne son el caso común
Este es un buen compromiso de diseño
Ing. JoséAlberto Díaz García
68
Comparar signo: slt, slti
Comparar sin signo: sltu, sltui
Ejemplo
$s0 = 1111 1111 1111 1111 1111 1111 1111 1111
$s1 = 0000 0000 0000 0000 0000 0000 0000 0001
slt $t0, $s0, $s1 # con signo
1 < +1
$t0 = 1
sltu $t0, $s0, $s1
+4,294,967,295 > +1
Ing. JoséAlberto Díaz García
# sin signo
$t0 = 0
69
1.
2.
3.
4.
5.
Colocar los parámetros en los registros
Transferir el control a los procedimientos
Asignar memoria al procedimiento
Realizar las operaciones del procedimiento
Colocar el resultado en el registro para el
llamado
6. Retornar al lugar de llamado del
procedimiento
Ing. JoséAlberto Díaz García
§2.8 Manejo de procedimientos en el hardware del computador
Pasos requeridos
70
$a0 $a3: argumentos (reg s 4 7)
$v0, $v1: valores de resultados (reg s 2 y 3)
$t0 $t9: temporales
Pueden sobreescribirse por un call
$s0
$s7: almacenar
Deben ser almacenados/salvados por un call
$gp: puntero global para datos estáticos (reg 28)
$sp: puntero de pila (reg 29)
$fp: puntero de marco o frame (reg 30)
$ra: dirección de retorno (reg 31)
Ing. JoséAlberto Díaz García
71
Instrucciones para procedimientos y
calls o llamados
Llamados a un procedimiento: salte y lazo
jal etiquetadeprocedimiento
La dirección de la próxima instrucción se coloca en
$ra
Salta a la dirección indicada
Retorno de un procedimiento: salto a un registro
jr $ra
Copia el contenido de $ra al contador de programa
También se puede utilizar saltos calculados
Por ejemplo en las instrucciones para case/switch
Ing. JoséAlberto Díaz García
72
Ejemplo de un procedimiento tipo hoja
Código C:
int ejemplo hoja (int g, h, i, j)
{ int f;
f = (g + h) - (i + j);
return f;
}
Argumentos g, , j en $a0, , $a3
f en $s0 (desde aquí, se necesita salvar $s0
en la pila)
Resultado en $v0
Ing. JoséAlberto Díaz García
73
Código MIPS:
ejemplo hoja:
addi $sp, $sp, -4
sw
$s0, 0($sp)
add $t0, $a0, $a1
add $t1, $a2, $a3
sub $s0, $t0, $t1
add $v0, $s0, $zero
lw
$s0, 0($sp)
addi $sp, $sp, 4
jr
$ra
Ing. JoséAlberto Díaz García
Save $s0 on stack
Procedure body
Result
Restore $s0
Return
74
Procedimientos que llaman a otros
procedimientos
Para llamados anidados, el que llama a los
procedimientos necesita almacenar en la
pila:
Su dirección de retorno
Cualquier argumento y temporales que se
necesitan después del llamado
Recuperar de la pila después del llamado
Ing. JoséAlberto Díaz García
75
Código en C:
int fact (int n)
{
if (n < 1) return f;
else return n * fact(n - 1);
}
Argumento n en $a0
Resultado en $v0
Ing. JoséAlberto Díaz García
76
Ejemplo de un procedimiento no hoja
Código MIPS:
fact:
addi $sp, $sp, -8
sw
$ra, 4($sp)
sw
$a0, 0($sp)
slti $t0, $a0, 1
beq $t0, $zero, L1
addi $v0, $zero, 1
addi $sp, $sp, 8
jr
$ra
L1: addi $a0, $a0, -1
jal fact
lw
$a0, 0($sp)
#
#
#
#
#
ajusta la pila a 2 itemes
almacena la dirección de
retorno
almacena el argumento
prueba si n < 1
# si sí, resultado es 1
# pop 2 itemes de la pila
# y retorna
lw
$ra, 4($sp)
addi $sp, $sp, 8
mul $v0, $a0, $v0
#
#
#
#
#
#
#
jr
# y retorna
$ra
Ing. JoséAlberto Díaz García
else decrementa n
llamado recursivo
recupera el valor original
de n
y dirección de retorno
pop 2 itemes de la pila
multiplica para resultado
77
Datos locales localizados por el call
P. e., C variables automáticas
Marco de procedimiento (registro de activación)
Utilizado por algunos compiladores para manejar el
almacenamiento en la pila
Ing. JoséAlberto Díaz García
78
Texto: código de programa
Datos estáticos: variables
globales
P.e.., variables estáticas en C,
arreglo de constantes y filas de
caracteres o strings
$gp se inicializa para
direccionar y permitir
desplazamientos dentro del
segmento
Datos dinámicos: apilado
E.g., malloc en C, new en Java
Stack: almacenamiento
automático
Ing. JoséAlberto Díaz García
79
§2.9 Comunicándose con la gente
Conjunto de caracteres codificados en Bytes
ASCII: 128 caracteres
95 gráficos, 33 control
Latin-1: 256 caracteres
ASCII, +96 caracteres gráficos adicionales
Unicodigo: conjunto de caracteres de32-bits
Utilizado en Java, C++ muchos caracteres,
La mayoría de los alfabetos del mundo, más símbolos
UTF-8, UTF-16: codificación en largo variable
Ing. JoséAlberto Díaz García
80
Se pueden utilizar operaciones de un bit
MIPS byte/halfword load/store
El caso más común es el procesamiento de
una hilera de caracteres
lb rt, offset(rs)
lh rt, offset(rs)
La extensión de signo a 32 bits en rt
lbu rt, offset(rs)
lhu rt, offset(rs)
Extensión de cero en 32 bits en rt
sb rt, offset(rs)
sh rt, offset(rs)
Almacene solo lo de la derecha byte/halfword
Ing. JoséAlberto Díaz García
81
Código C (naïve):
Hilera de caracteres que termina con un Null
void strcpy (char x[], char y[])
{ int i;
i = 0;
while ((x[i]=y[i])!='\0')
i += 1;
}
Direcciones en x, y en $a0, $a1
i en $s0
Ing. JoséAlberto Díaz García
82
Código MIPS:
strcpy:
addi
sw
add
L1: add
lbu
add
sb
beq
addi
j
L2: lw
addi
jr
$sp,
$s0,
$s0,
$t1,
$t2,
$t3,
$t2,
$t2,
$s0,
L1
$s0,
$sp,
$ra
$sp, -4
0($sp)
$zero, $zero
$s0, $a1
0($t1)
$s0, $a0
0($t3)
$zero, L2
$s0, 1
0($sp)
$sp, 4
Ing. JoséAlberto Díaz García
#
#
#
#
#
#
#
#
#
#
#
#
#
ajuste la pila a un item
salvar $s0
i = 0
direc de y[i] en $t1
$t2 = y[i]
direc de x[i] en $t3
x[i] = y[i]
sale del lazo si y[i] == 0
i = i + 1
próxima iteración del lazo
recupera lo salvado en $s0
pop item 1 de la pila
retorne
83
Inmediatos de 16-bit son suficientes
Para la ocasión constantes de 32-bit
lui rt, constante
Copia la constante de 16-bit a la izquierda de rt
Limpia los 16 bits de la derecha de rt a 0
lhi $s0, 61
0000 0000 0111 1101 0000 0000 0000 0000
ori $s0, $s0, 2304 0000 0000 0111 1101 0000 1001 0000 0000
Ing. JoséAlberto Díaz García
§2.10 MIPS direccionamiento para 32-Bit inmediatos o direccionamiento
La mayoría de las constantes son pequeñas
84
Las instrucciones con salto especifican:
Opcode, dos registros, dos etiquetas de dirección
La mayoría de las etiquetas de dirección son
saltos cercanos
Hacia delante o atrás
op
rs
rt
Dirección o constante
6 bits
5 bits
5 bits
16 bits
Direccionamiento relativo al PC
Dirección de etiqueta = PC + offset × 4
El PC ha incrementado en 4 en este
momento
Ing. JoséAlberto Díaz García
85
Para los saltos (j y jal) las etiquetas pueden
estar en cualquier lugar en el segmento de texto
Codifica la dirección en la instrucción
op
Dirección
6 bits
26 bits
Direccionamiento para salto
(Pseudo)Direct
Dirección de la etiqueta = PC31
(dirección× 4)
Ing. JoséAlberto Díaz García
28
:
86
Ejemplo de direccionamiento con etiqueta
Código del lazo del ejemplo anterior
Asuma el lazo a partir de la posición 80000
$t1, $s3, 2
80000
0
0
19
9
4
0
add
$t1, $t1, $s6
80004
0
9
22
9
0
32
lw
$t0, 0($t1)
80008
35
9
8
0
bne
$t0, $s5, Exit 80012
5
8
21
2
addi $s3, $s3, 1
80016
8
19
19
1
j
80020
2
Loop: sll
Loop
20000
80024
Exit:
Ing. JoséAlberto Díaz García
87
Si la etiqueta de salto está muy largo del
offset de 16 bits, el ensamblador deberá
reescribir el código.
Ejemplo
beq $s0,$s1, L1
bne $s0,$s1, L2
j L1
L2:
Ing. JoséAlberto Díaz García
88