Arquitectura de Las Computadoras UNIDAD II C

Arquitectura de las Universidad Nacional de la
Patagonia Austral
Computadoras
Unidad Académica Caleta
Olivia
2022
UNIDAD II – Parte C
El repertorio de instrucciones
Arquitectura de las computadoras

Estructura del curso
2022
1. Evolución y caracterización de los computadores.

2. Arquitectura del MIPS: Introducción.
3. Tipo de datos.
4. El repertorio de instrucciones.
5. Aritmética del computador.
6. El camino de datos.
7. Sección de control.
8. CPU Segmentada (Pipelining)
2
Esquema de contenidos
2022
1. Introducción: Visión del programador
2. Formato de instrucciones
3. Modos de direccionamiento
4. Instrucciones típicas
5. Llamadas a subrutinas
6. Pila o stack
3
Introducción: La visión del programador
2022 • El funcionamiento de la CPU está determinado por las
instrucciones que ejecuta.
• El conjunto de instrucciones distintas que puede
ejecutar se denomina repertorio de instrucciones
• En los computadores actuales las instrucciones se
presentan como números y se almacenan en memoria
(programa almacenado)
• El lenguaje utilizado por el ordenador se denomina
lenguaje máquina. El lenguaje ensamblador es una
representación simbólica más cercana al humano.
4
Visión software: Jerarquía de traducción
swap: muli $2, $5, 4
2022 swap( int v[ ], int
k) { add $2, $4, $2
int temp; lw $15, 0($2)
temp=v[k]; lw $16, 4($2)
v[k]=v[k+1]; sw $16, 0($2)
v[k+1]=temp;
sw $15, 4($2)
}
jr $31
Lenguaje de alto
nivel (C) Lenguaje ensamblador
(MIPS)
Lenguaje máquina
00000000101001100010100101000110000000010110101100100000100000
10001100011000100000000000000001000110011100100000000000000000
10101100111110100000000000000001010110010111010001000000000000
00000011000001000000010000000100000000000000001000110001000110
5
Formato de instrucciones
2022
Elementos de una instrucción máquina:
• Código de operación.
• Especifica el tipo de operación a realizar: Suma, resta,
movimiento de datos, …
• Referencia a operandos fuente
• La instrucción puede involucrar ninguno, uno o varios operandos
fuente.
• Los operandos pueden especificarse utilizando diferentes modos
de direccionamiento.
• Referencia al operando resultado
• Si la instrucción produce un resultado debe especificar el
operando destino.
• El operando puede especificarse utilizando diferentes modos de
direccionamiento.
• Referencia a la siguiente instrucción.
• Normalmente la ejecución del programa es secuencial y la
dirección de la siguiente instrucción está implícita.
• En las instrucciones de salto se especifica la dirección de la
siguiente instrucción.
6
Formato de instrucciones
2022 • Dentro del computador cada instrucción se representa
por una secuencia de bits
• La instrucción se divide en campos correspondientes a
los elementos constitutivos de la misma (código de
operación, operandos, etc.)
• La descripción en campos y bits se denomina formato
de instrucción
Opcode Op. Fuente 1 Op. Fuente n Op. Destino Instruc.siguiente
7
Diseño del repertorio de instrucciones
Se debe decidir:
2022
• Longitud de las instrucciones
• Todas de la misma longitud.
• De distinta longitud dependiendo del tipo de operación.
• Número de campos (dependiendo del tipo de instrucción).
• Número de bits por campo.
• Codificación de cada campo.
Factores a tener en cuenta para decidir el formato:
• Número de operaciones distintas
• Aritméticas, lógicas, de control, de movimiento de datos.
• Número de operandos de cada instrucción.
• Sin operandos, con 1,2,3… operandos.
• Modos de direccionamiento:
• Inmediato, absoluto, de registro, indirecto…
• Tamaño y tipos de datos:
• Bit, byte, palabra, doble palabra…
• Caracteres, BCD, signo magnitud, complemento a 2, punto flotante…
8
Repertorio de instrucciones escogido: MIPS
2022 • Arquitectura MIPS

• Pionera de las arquitecturas RISC
• Muy sencilla y uniforme
• Creada en Stanford (John Hennessy)
• Utilizada por SGI, NEC, Toshiba
9
MIPS: Ejemplo de sencillez
2022 SUMA de dos variables b y c, resultado en a.
add a, b, c #a=b+c
SUMA de tres variables (b,c,d) y resultado en a.

add a, b, c #a=b+c
add a, a, d # a = a + d= (b+c)+d
10
Repertorio de instrucciones MIPS
2022 • Longitud de instrucción fija: 32 bits
• La arquitectura MIPS realiza la mayor parte de los
cálculos con datos almacenados en registros
• MIPS es sencilla y eficiente
• El acceso a memoria se hace a través de operaciones
de carga/almacenamiento (transferencia de datos)
• MIPS direcciona bytes individuales, para indicar la
dirección de una palabra en memoria hay que indicar
su dirección (dirección de su primer byte).
11
Registros del MIPS
• 32 registros de 32 bits
Númeo Nombre Uso convencional
0 $zero Valor constante 0
1 $at Reservado por el ensamblador
2-3 $v0-$v1 Para resultados y evaluación de expresiones
4-7 $a0-$a3 Argumentos
8-15 $t0-$t7 Temporales
16-23 $s0-$s7 Salvados
24-25 $t8-$t9 Temporales
26-27 $k0-$k1 Reservado para núcleo de SO
28 $gp Puntero global
29 $sp Puntero de pila
30 $fp Puntero de bloque de activación
31 $ra Dirección de retorno
12
Ejemplo de instrucción MIPS
2022 Ejemplo:
add $t0, $s1, $s2
Se representa en lenguaje MIPS como:
000000 10001 10010 01000 00000 100000

s1 s2 t0
En representación decimal:
0 17 18 8 0 32
13
Ejemplo de instrucción MIPS
Ejemplo:
add $t0, $s1, $s2
Se representa en lenguaje MIPS como:
000000 10001 10010 01000 00000 100000

op rs rt rd shamt funct
Campos:
op: código de operación.
rs: primer registro operando fuente
rt: segundo registro operando fuente
rd: registro operando destino
shamt: tamaño de desplazamiento (shift amount)
funct: código de función.
14
Formatos de las instrucciones MIPS
2022 MIPS tiene 3 tipos de formatos:
TIPO R: Operaciones aritméticas y lógicas
TIPO I: Transferencia de datos, salto condicional e
instrucciones con operandos inmediatos.
TIPO J: Instrucciones de bifurcación.
TIPO R (Registro)
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
15
TIPO I (Inmediato)
op rs rt dirección
6 bits 5 bits 5 bits 16 bits
16
TIPO J (Jump)
op dirección
6 bits 26 bits
17
¿Dónde están los operandos?: Modos
de direccionamiento
2022 Los operandos pueden estar:
• En la instrucción:
• Rápido y simple.
• Sólo para constantes
• En la memoria principal:
• Direccionamiento implica muchos bits.
• Acceso lento
• En los registros de la CPU:
• Hay pocos registros: el direccionamiento implica pocos bits
• Acceso rápido
18
¿Dónde están los operandos?: Modos
de direccionamiento
2022 Modos de direccionamiento del MIPS:
• Modo de direccionamiento inmediato.
• Modo de direccionamiento registro.
• Modo de direccionamiento base con
desplazamiento.
• Modo de direccionamiento relativo al PC.
• Modo de direccionamiento pseudodirecto.
19
Direccionamiento inmediato
2022 • El operando es una constante que aparece en
la instrucción
op rs rt DATO
INSTRUCCION
20
Modo de direccionamiento registro
2022
• El operando está en un registro
INSTRUCCION
DATO
REGISTRO
21
Modo de direccionamiento base con
desplazamiento
2022
• El operando está en la memoria en la dirección:
constante en la instrucción + contenido registro
op rs rt Dirección
INSTRUCCION +
Dirección
REGISTRO
DATO
MEMORIA
22
Modo de direccionamiento relativo al PC
2022
• El operando está en la memoria en la dirección:
constante en la instrucción + contador de programa (PC).
op rs rt Dirección
INSTRUCCION +
Dirección
PC
DATO
MEMORIA
23
Modo de direccionamiento pseudodirecto
2022
• El operando está en la memoria en la dirección: 26 bits de
instrucción CONCATENADOS CON los bits de mayor peso del
contador de programa (PC).
op Dirección
INSTRUCCION
Dirección
PC
DATO
MEMORIA
24
Instrucciones aritmético-lógicas
2022 TIPO R Direccionamiento registro
SUMA add $t0, $s1, $s2 # $t0 = $s1+$s2
000000 10001 10010 01000 00000 100000

s1 s2 t0
RESTA sub $t0, $s1, $s2 # $t1 = $s1-$s2
000000 10001 10010 01001 00000 100010

s1 s2 t0
25
AND and $t0, $s1, $s2 # $t0 = $s1 AND $s2
000000 10001 10010 01000 00000 100100

s1 s2 t0
OR or $t0, $s1, $s2 # $t0 = $s1 OR $s2
000000 10001 10010 01000 00000 100101

s1 s2 t0
26
2022 • Hay instrucciones aritméticas de tipo I (modo
direccionamiento inmediato)
TIPO I
op rs rt dirección
SUMA addi $s1, $s2,4 # $s1 = $s2 + 4
001000 10010 10110 0000 0000 0000 0100

s2 s1
27
Instrucciones de transferencia
2022 • Almacenamiento de información en la memoria.
• Instrucciones MIPS de acceso a la memoria:
• lw (load word) carga una palabra desde memoria
• sw (store word) almacena una palabra en memoria
• Memoria con direccionamiento de bytes (8 bits):
• En MIPS las direcciones son múltiplos de 4 (restricción de
alineación).
Computador de 32 bits: 4 bytes/palabra
MIPS: Big Endian/Little Endiam
28
Instrucciones de transferencia:
Direccionamiento de la memoria
Palabra de 32 bits:
2022 31 0
8bits 8bits 8bits 8bits
Direc. 4n Direc. 4n+1 Direc. 4n+2 Direc. 4n+3
4n-1 …
4n 8bits
MEMORIA
Ejemplo Big Endian: DIRECCION 4n 4n+1 8bits
4n+2 8bits
4n+3 8bits
…
29
Instrucciones de transferencia: lw
2022 Ejemplo:
lw $s1,1200($s2) # $s1 = Mem [1200+$s2]
Explicación:
• Carga una palabra de 32 bits desde la memoria
• La pone en un registro ($s1)
• La dirección de memoria se encuentra en un
registro ($s2) más un desplazamiento (1200)
• Cuidado!: Sólo las direcciones múltiplo de 4
son válidas (palabras de 32 bits)
30
Instrucciones de transferencia: lw
2022 TIPO I Direccionam. base con desplazamiento
op rs rt dirección
lw lw $s1,1200($s2) # $s1 = Mem [$s2 +1200]
35 18 17 1200
s2 s1
100011 10010 10001 0000 0100 1011 0000

s2 s1
31
Instrucciones de transferencia: sw
2022 Ejemplo:
sw $s1,8 ($s2) # Mem [8+$s2] = $s1
Explicación:
• Guarda una palabra de 32 bits en la memoria
• La palabra esta en el registro ($s1)
• La dirección de memoria se encuentra en un
registro ($s2) más un desplazamiento (8)
• Cuidado!: Sólo las direcciones múltiplo de 4
son válidas (palabras de 32 bits)
32
2022 .
sw $s1,8($s2) # Mem [8+$s2] = $s1 .
.
Dirección base ($s2) 4n
4n+1 A[0]
4n+2
4n+3
Desplazamiento (8)
4n+4
4n+5
A[1]
4n+6
4n+7
4n+8
$s0
4n+9
$s1
4n+10 A[2]
$s2 4n
4n+11
.
.
registers .
33
2022 TIPO I Direccionam. base con desplazamiento
op rs rt dirección
sw sw $s1,1200($s2) # Mem [1200+$s2] = $s1
43 18 17 1200
s2 s1
101011 10010 10001 0000 0100 1011 0000

s2 s1
34
Carga de constantes en registros: load
upper inmediate
2022 TIPO I Direccionamiento inmediato
op rs rt dirección
lui lui $t0, 255 # Carga 255 en los 16 bits

más significativos de $t0
15 0 8 255
t0
001111 00000 01000 0000 0000 1111 1111
t0
35
Carga de constantes en registros: carga
de 32 bits
2022
• Es necesario utilizar otra instrucción para
cargar los 16 bits menos significativos
• Supongamos que queremos cargar en $s0:
Constante = 0000 0000 0011 1101 0000 1001 0000 0000
61 2304
• DOS PASOS:
• Carga de los 16 bits más significativos
lui $s0, 61
• Suma de los 16 bits menos significativos
addiu $s0, $s0, 2304
36
Instrucciones de cambio de flujo
2022 • Hacen que el programa salte a otra instrucción distinta
de la siguiente
• Pueden saltar siempre o dependiendo de una condición
• La instrucción debe indicar la dirección de la nueva
instrucción
• De forma absoluta
• De forma relativa
• MIPS dispone de:
• Salto incondicional: j, jr
• Salto condicional: beq, bne
• Apoyo al salto condicional: slt
37
Salto incondicional: jump
2022 TIPO J Direccionamiento pseudodirecto
op dirección
6 bits 26 bits
Se concatena una dirección de 26 bits (2500) desplazados 2 bits a la izquierda con los 4 bits de
mayor peso del PC (10000)
j j 2500 # ir a dirección (PC=10000)
PC anterior = 0000 xx xxxx xxxx xxxx xxxx xxxx xxxx xx
PC nuevo = 0000 00 0000 0000 0000 1001 1100 0110 00
2 2500
000010 00 0000 0000 0000 1001 1100 0100

38
Salto incondicional: jump register
jr jr $t1 # salto a la dirección almacenada en

el registro t1
0 9 0 0 0 8
t1
000000 01001 00000 00000 00000 001000
t1
39
Salto condicional: branch if equal
2022 TIPO I Direccionamiento relativo al PC
op rs rt salto
beq beq $s1, $s2, 25 # si ($s1 == $s2) avanzar 100
4 17 18 25
s1 s2
000100 10001 10010 0000 0000 0001 1001

s1 s2
41
Salto condicional: branch if equal
2022
TIPO I beq $s1, $s2, 25 # si ($s1 == $s2) avanzar 100
op rs rt salto
Salto = 0000 0000 0001 1001(se desplaza 2 lugares antes de
incrementar el PC)
PC anterior = 0100 1101 0000 0011 1010 1100 0101 1000
= 0100 1101 0000 0011 1010 1100 0101 1000

0000 0000 0000 0000 0000 0000 0110 0100
PC nuevo = 0100 1101 0000 0011 1010 1100 1011 1100
40
Salto condicional (hacia adelante)
2022
beq reg1, reg2, salto
Salto = 0000 0000 0010 0111

PC = 0100 1101 0000 0011 1010 1100 0101 1000
0100 1101 0000 0011 1010 1100 0101 1000

0000 0000 0000 0000 0000 0000 1001 1100
0100 1101 0000 0011 1010 1100 1111 0100
42
Salto condicional (hacia atrás)
2022
beq reg1, reg2, salto
Salto = 1111 0000 0010 0111 (C)

PC = 0100 1101 0000 0011 1010 1100 0101 1000
0100 1101 0000 0011 1010 1100 0101 1000

1111 1111 1111 1111 1100 0000 1001 1100
0100 1101 0000 0011 0110 1100 1111 0100
Concateno los bits mas Sumo los bits del complemento
significativos del PC desplazado y el PC
43
Salto condicional: branch if not equal
2022 TIPO I Direccionamiento relativo al PC
op rs rt salto
bne bne $s1, $s2, 25 # si ($s1 != $s2) avanzar 100
5 17 18 25
s1 s2
000101 10001 10010 0000 0000 0001 1001

s1 s2
44
Salto condicional: set on less than
slt slt $t0, $s1, $s2 # if $s1 < $s2 then $t0=1
else $t0 = 0
0 16 17 8 0 42
s1 s2 t0
000000 10001 10010 01000 00000 101010

s1 s2 t0
45
Salto condicional: set on less than
2022 • También hay una versión tipo I (modo direccionamiento
inmediato)
TIPO I
op rs rt valor
slti slti $t0, $s1, 10 # if $s1 < 10 then $t0=1
else $t0 = 0
001010 10001 01000 0000 0000 0000 1010

s1 t0
46
Llamadas a subrutinas
2022 PROGRAMA
PRINCIPAL
subrutina
subrutina
47
2022 El programa debe realizar los siguientes pasos:
1. Facilitar parámetros de entrada a la subrutina.
2. Transferir el control a la subrutina (jump-and-link)
3. Ejecutar la subrutina
4. Situar resultados en un lugar accesible por el
programa
5. Retornar el control al punto de origen.
6. Leer/utilizar los resultados
48
Llamadas a subrutinas:jump-and-link (jal)
2022 • jal funciona como la instrucción jump

• Guarda la dirección de retorno (dirección
siguiente a la dirección de la instrucción de
salto) en el registro 31 ($ra)
• Para pasar valores y recoger resultados:
• $a0 - $a3 parámetros de entrada
• $v0 - $v1 resultados
49
Llamadas a subrutinas: jump-and-link
TIPO J Direccionamiento pseudodirecto
op dirección
6 bits 26 bits
jal jal 2500 # $ra=PC + 4;

Ir a subrutina en 10000
PC anterior = 0000 xx xxxx xxxx xxxx xxxx xxxx xxxx xx
PC nuevo = 0000 00 0000 0000 0000 1001 1100 0100 00
3 2500
000011 00 0000 0000 0000 1001 1100 0100

50
2022 El programa debe realizar los siguientes pasos:
1. Facilitar parámetros de entrada a la subrutina ($a0-
$a3).
2. Transferir el control a la subrutina (jal
dirección_subrutina)
3. Ejecutar la subrutina
4. Situar resultados en un lugar accesible por el
programa ($v0-$v1)
5. Retornar el control al punto de origen (jr $ra)
6. Leer/utilizar los resultados
Si no son suficientes los 4 registros como argumentos

de entrada y los 2 registros de retorno de valores :
PILA o STACK.
51
Pila o Stack
2022 • Es una parte de la memoria que implementa una estructura LIFO
(last in first out)
• El registro 29 ($sp) es el puntero de pila
• La pila crece de direcciones de memoria superiores a inferiores:
• Al poner un dato (PUSH) se debe decrementar $sp en 4 bytes
• Al quitar un dato (POP) se debe incrementar $sp en 4 bytes
La pila siempre apunta una dirección con un contenido
• Push (apilar) – Busca el primer lugar vacío
• addi $sp, $sp, -4 # Ajustar el puntero de pila
• sw $t0, 0($sp) # Guardo el registro $t0 en la pila
• Pop (desapilar) busca el primer lugar con contenido

• lw $t0, 0($sp) # Contenido de la pila al registro $t0
• addi $sp, $sp, 4 # Ajustar el puntero de pila
52
Pila o Stack: Guardando datos al llamar
a una subrutina.
2022
Recuperando el estado del sistema al llamar a una subrutina:
• Al invocar desde un programa a una subrutina:
• Guardar los valores de los registros en una pila.
• Al regresar al programa:
• Recuperar los valores de los registros de la pila.
Convenios para guardar/restaurar registros:
• Guarda el invocador: el procedimiento invocador es el
responsable de guardar/restaurar los registros a conservar.
• Guarda el invocado: el invocado es el responsable
53
Pila o Stack. Ejemplo de utilización
2022 • Vamos a ver como funcionan los dos convenios para
guardar/restaurar registros con el siguiente ejemplo:
clear_array(int A[], int n){

int j;
for(j=0; j<n; ++j)
A[j]=0;
}
$a0= dirección array A

$a1= valor de n
54
Pila o Stack. Ejemplo de utilización.
Guarda el invocador
2022 • Salvamos 2 registros en la pila, saltamos a la
subrutina y recuperamos al volver
clear_array:
addi $sp, $sp, -8 add $s0, $zero, $zero
sw $s0, 0($sp) add $s1, $zero, $a0
sw $s1, 4($sp) for:
jal clear_array beq $s0, $s1, exit
lw $s0, 0($sp) sw $zero, 0($s0)
lw $s1, 4($sp) addi $s0, $s0, 4 Incremento indice
addi $sp, $sp, 8 j for
exit:
jr $31
55
Guarda el invocador
2022
addi $sp, $sp, -8 # Ajusto la pila para dos elementos

sw $s0, 0($sp)
sw $s1, 4($sp) # Salvo los registros $s0 y $s1
jal clear_array
lw $s0, 0($sp)
# Llamo al procedimiento
lw $s1, 4($sp)
# Restauro los dos registros
addi $sp, $sp, 8
# Restauro el espacio de pila
56
Guarda el invocador
2022
clear_array:
add $s0, $zero, $zero # $s0= j=0
add $s1, $zero, $a0 # $s1 dirección A[n+1]
for:
beq $s0, $a1, exit
# Saltamos a exit si j=n+1
sw $zero, 0($s1)
addi $s1, $s1, 4 # A[j] = 0
j for exit:
jr $ra # j++
# retorno al programa invocador
57
Guarda el invocado
2022
clear_array: for:
addi $sp, $sp, -8 beq $s0, $a1, exit
sw $s0, 0($sp) sw $zero, 0($s1)
sw $s1, 4($sp)
addi $s1, $s1, 4
add $s0, $zero, $zero j for
add $s1, $zero, $a0
exit:
lw $s0, 0($sp)
lw $s1, 4($sp)
addi $sp, $sp, 8
jr $ra
58
Pila o Stack: Guardando datos al llamar
a una subrutina.
2022 Llamada a subrutina:
Los registros $t0-$t9 son libres de ser modificados
Los registros $s0-$s7 deben ser preservados
PILA o STACK.
Programas MIPS:
• $t0-$t9: “registros temporales” que NO son
preservados por el invocado. Si los quiere
preservar, lo tiene que hacer el invocador.
• $s0-$s7: “registros salvados” que SI deben ser
preservados por el invocado en el caso de que
los use.
59
Subrutinas anidadas
2022 • Problemas en los anidamientos:
• Dirección de retorno en $ra
• Valores de los registros: argumentos ($a0-$a3), temporales ($t0-t9),
salvados ($s0-s7).
• Solución: Guardar en pilas.
• Es necesario un convenio único para coordinación entre
programadores.
• La subrutina invocada:
• La subrutina invocada guarda los registros $s0-$s7 que vaya a utilizar
• La subrutina invocada debe guardar en la pila el registro $ra
• Así puede llamar a otra subrutina con jal
• Antes de retornar al procedimiento invocador es necesario recuperar
$ra de la pila
• El invocador:
• El invocador guarda los registros $t0-$t9 y $a0-$a3 que necesite
60
Subrutinas anidadas. Ejemplo de utilización
2022 • Vamos a analizar el siguiente ejemplo:

int factorial(n){ /retorna el valor de tmp
int tmp;
if(n<1)
tmp = 1;
else
tmp = n * factorial(n-1);
return tmp;
}
$a0= valor de n
$v0= tmp
Resultado estará en $v0$
61
2022 factorial: else:

addi $sp, $sp, -8 addi $a0, $a0, -1
sw $a0, 0($sp) jal factorial
sw $ra, 4($sp)
lw $a0, 0($sp)
slti $t0, $a0, 1
lw $ra, 4($sp)
beq $t0, $zero, else
addi $sp, $sp, 8
if:
addi $v0, $zero, 1
mult $v0, $v0, $a0
addi $sp, $sp, 8
jr $ra
jr $ra
62
2022 factorial: #ajusto la pila para 2 elementos

addi $sp, $sp, -8
# salvo el argumento n
sw $a0, 0($sp)
sw $ra, 4($sp) # salvo la dirección de retorno
slti $t0, $a0, 1 # comprueba si n<1 / $t0=1 if $a < 1

beq $t0, $zero, else
if:
# Si $t0 = 0 ir al “else:” si no ir al “if:”
addi $v0, $zero, 1
addi $sp, $sp, 8 # tmp=1
jr $ra
# elimina dos elementos de la pila
Retornar al punto después de jal.
63
2022 else:
# el argumento se carga con n-1 addi $a0, $a0, -1
# llama a factorial con n-1 jal factorial
# retorno de jal: restaura argumento n lw $a0, 0($sp)

# restaura la dirección de retorno lw $ra, 4($sp)
addi $sp, $sp, 8
# ajusta la pila: eliminar 2 elementos
mult $v0, $v0, $a0
#tmp=n*factorial(n-1)
jr $ra
# retorna al invocador
64
Almacenamiento de caracteres:
Representación ASCII, 8 bits
2022 • Las instrucciones lb y sb permiten cargar/almacenar 8
bits
• lb carga 1 byte de memoria y lo sitúa en los 8 bits más
a la derecha de un registro (hace extensión de signo en
los bits más significativos)
• sb almacena en memoria los 8 bits menos significativos
del registro
• Existe lbu, sin extensión de signo
lb lb $t0, 0($s0) # Leer byte de la fuente
sb sb $t0, 0($s0) # Escribir byte en destino
65

Arquitectura de Las Computadoras UNIDAD II C

Cargado por

Copyright:

Formatos disponibles

Arquitectura de Las Computadoras UNIDAD II C

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Arquitectura de Las Computadoras UNIDAD II C

Cargado por

Copyright:

Formatos disponibles

Arquitectura de las Universidad Nacional de la

Arquitectura de las computadoras

1. Evolución y caracterización de los computadores.

Opcode Op. Fuente 1 Op. Fuente n Op. Destino Instruc.siguiente

2022 • Arquitectura MIPS

SUMA de tres variables (b,c,d) y resultado en a.

Se representa en lenguaje MIPS como:

000000 10001 10010 01000 00000 100000

Se representa en lenguaje MIPS como:

000000 10001 10010 01000 00000 100000

SUMA add $t0, $s1, $s2 # $t0 = $s1+$s2

000000 10001 10010 01000 00000 100000

000000 10001 10010 01001 00000 100010

AND and $t0, $s1, $s2 # $t0 = $s1 AND $s2

000000 10001 10010 01000 00000 100100

000000 10001 10010 01000 00000 100101

SUMA addi $s1, $s2,4 # $s1 = $s2 + 4

001000 10010 10110 0000 0000 0000 0100

Computador de 32 bits: 4 bytes/palabra

MIPS: Big Endian/Little Endiam

Direc. 4n Direc. 4n+1 Direc. 4n+2 Direc. 4n+3

lw lw $s1,1200($s2) # $s1 = Mem [$s2 +1200]

100011 10010 10001 0000 0100 1011 0000

sw sw $s1,1200($s2) # Mem [1200+$s2] = $s1

101011 10010 10001 0000 0100 1011 0000

lui lui $t0, 255 # Carga 255 en los 16 bits

PC nuevo = 0000 00 0000 0000 0000 1001 1100 0110 00

000010 00 0000 0000 0000 1001 1100 0100

jr jr $t1 # salto a la dirección almacenada en

beq beq $s1, $s2, 25 # si ($s1 == $s2) avanzar 100

000100 10001 10010 0000 0000 0001 1001

TIPO I beq $s1, $s2, 25 # si ($s1 == $s2) avanzar 100

= 0100 1101 0000 0011 1010 1100 0101 1000

Salto = 0000 0000 0010 0111

0100 1101 0000 0011 1010 1100 0101 1000

Salto = 1111 0000 0010 0111 (C)

0100 1101 0000 0011 1010 1100 0101 1000

bne bne $s1, $s2, 25 # si ($s1 != $s2) avanzar 100

000101 10001 10010 0000 0000 0001 1001

000000 10001 10010 01000 00000 101010

001010 10001 01000 0000 0000 0000 1010

2022 • jal funciona como la instrucción jump

TIPO J Direccionamiento pseudodirecto

jal jal 2500 # $ra=PC + 4;

000011 00 0000 0000 0000 1001 1100 0100

Si no son suficientes los 4 registros como argumentos

• Pop (desapilar) busca el primer lugar con contenido

clear_array(int A[], int n){

$a0= dirección array A

addi $sp, $sp, -8 # Ajusto la pila para dos elementos

# retorno al programa invocador

2022 • Vamos a analizar el siguiente ejemplo:

2022 factorial: else:

2022 factorial: #ajusto la pila para 2 elementos

slti $t0, $a0, 1 # comprueba si n<1 / $t0=1 if $a < 1

Retornar al punto después de jal.

# retorno de jal: restaura argumento n lw $a0, 0($sp)

lb lb $t0, 0($s0) # Leer byte de la fuente

sb sb $t0, 0($s0) # Escribir byte en destino

También podría gustarte