Documentos de Académico
Documentos de Profesional
Documentos de Cultura
TEMAII
TEMAII
ARQUITECTURA DE COMPUTADORES
Programa
1. Introduccin
2. Instrucciones
Repertorio de Instrucciones
Propiedades
Procesadores MIPS
3. Formato de Instruccin
4. Modos de Direccionamiento
5. Tipos de Instrucciones
Tipo R
Tipo I
Tipo J
6. Ejemplos
7. Conclusiones
2
1. Introduccin
Los computadores ejecutan programas.
Programa: secuencia de operaciones conducentes a resolver un problema
determinado.
Caractersticas de los programas
Estn compuestos por secuencias de instrucciones o sentencias.
Se escriben utilizando una notacin formal conveniente.
Pueden ser escritos por personas (programadores), o bien pueden ser
generados automticamente mediante una herramienta adecuada.
Un programa en ejecucin se encuentra cargado en memoria principal.
Lenguaje de programacin: una notacin formal para describir algoritmos o
funciones que sern ejecutadas por un computador.
Lenguaje ensamblador.
7
Lenguaje ensamblador
El lenguaje ensamblador (o lenguaje de ensamble, assembly language) es la
representacin simblica de la codificacin binaria de un computador.
Cdigos de operacin representados mediante cdigos nemotcnicos.
Datos y referencias codificadas mediante nombres simblicos (smbolos o etiquetas).
s w a p (in t v [], in t k )
{in t te m p ;
te m p = v[k];
v[k ] = v [k + 1 ];
v [k + 1 ] = te m p ;
}
C c o m p ile r
A ss e m b ly
la n g u a g e
p ro g ra m
(fo r M IP S )
sw ap :
m u li $ 2 , $ 5 ,4
a d d $ 2 , $ 4 ,$ 2
lw $1 5 , 0($ 2)
lw $1 6 , 4($ 2)
s w $1 6, 0($2 )
sw $1 5, 4($2 )
jr $ 3 1
A ss e m b le r
B in a ry m a ch in e
la n g u a g e
p ro g ra m
(fo r M IP S )
0 00 000 0 0 10 10 00 01 00 0 00 00 00 00 11 00 0
0 00 0 00 00 10 00 11 10 00 0 11 00 00 01 00 00 1
1 00 0 11 00 01 10 00 10 00 0 00 00 00 00 00 00 0
1 00 0 11 00 11 11 00 10 00 0 00 00 00 00 00 10 0
1 01 0 11 00 11 11 00 10 00 0 00 00 00 00 00 00 0
1 01 0 11 00 01 10 00 10 00 0 00 00 00 00 00 10 0
0 00 0 00 11 11 10 00 00 00 0 00 00 00 00 01 00 0
10
Program
Compiler
Assembler
Linker
Computer
11
Terminologa
Cdigo (programa) fuente: cdigo escrito por el programador.
Puede estar escrito en cualquier lenguaje: alto nivel, ensamblador, cdigo
mquina (inusual).
Puede contener errores sintcticos porque el programador haya escrito mal el
programa.
12
Solucin mixta:
Programar en alto nivel la mayor parte del cdigo.
Programar en ensamblador las partes crticas en cuanto a velocidad.
Programar en ensamblador los sistemas con un tamao de memoria muy reducido.
13
Jerarqua de traduccin
C program
Compiler
Assembler
Linker
Loader
Memory
14
15
Edicin
Cdigo fuente
(ensamblador)
Identificacin de
los datos de
entrada y de los
resultados
Ensamblaje
Cdigo
objeto
Diagrama de
flujo y/o
pseudocdigo
Errores
sintcticos
Montaje
Errores lgicos
Cdigo
ejecutable
Programa fuente
en ensamblador
Verificacin
16
Compilador
Traductor de lenguaje de alto nivel a ensamblador.
Hoy todos los compiladores traducen directamente a lenguaje mquina.
En tal caso generan un fichero con el cdigo objeto equivalente al cdigo fuente
completo, junto con informacin necesaria para el montaje.
18
2. Instrucciones
Repertorio o juego de instrucciones: conjunto de instrucciones de
mquina que es capaz de ejecutar el computador. Debe ser:
Completo: debe permitir resolver cualquier problema.
Eficaz: los programas deben ser ejecutados en un tiempo razonable.
CPU
Coprocessor 1 (FPU)
Registers
Registers
$0
$0
$31
$31
Arithmetic
unit
Multiply
divide
Lo
Arithmetic
unit
Hi
Cause
Status
EPC
22
23
COP
MD
OP1
OP2
RES
25
El cdigo de operacin:
Permite distinguir entre los distintos formatos de instruccin de un computador.
Indica la longitud y formato de los operandos (a veces en campos modificadores
asociados al mismo).
Las longitudes de los formatos son fraccin o mltiplo del tamao de la palabra
del computador.
Para acortar la longitud de los formatos se utiliza direccionamiento implcito:
ninguna instruccin, salvo las de salto o bifurcacin, contiene la direccin de la
siguiente instruccin que se va a ejecutar.
26
Formato de Instrucciones
MIPS presenta tres formatos bsicos de instruccin (32 bits):
o
El compromiso elegido por los diseadores del MIPS es guardar todas las
instrucciones con la misma longitud, por eso se requieren diferentes clases de
formatos de instruccin para diferentes clases de instrucciones.
27
4. Modos de direccionamiento
Los operandos no estn contenidos en la instruccin de forma directa por:
Ahorro de espacio.
Empleo de cdigo reubicable y reentrante.
Hay datos formando estructuras ms o menos complejas.
En el registro de instruccin.
En palabras de extensin o ampliacin.
29
30
rs
rt
rd
...
funct
Registers
Register
Notacin: $n
Los registros tienen alias, indicando la funcin para la que estn dedicados
segn los convenios adoptados por programadores y compiladores.
Ejemplo: add $16, $17, $18 suma el contenido del registro 17 con el
registro 18 y lo almacena en el registro 16.
31
rs
rt
Register
Memory
Address
Byte
Halfword
Word
Notacin: desplazamiento($n)
Ejemplo: lw $16, 20($17) carga (load) en el registro 16 la palabra
contenida 20 bytes ms all de la direccin almacenada en el registro 17.
32
rs
rt
Memory
Address
PC
Word
Direccionamiento inmediato
Campos:
Inmediato de 16 bits.
Los datos inmediatos se extienden a 32 bits.
En ciertas instrucciones se hace extensin de signo.
En otras instrucciones se hace extensin con ceros.
Tambin se usa para indicar la longitud de un desplazamiento.
En este caso el inmediato es de 5 bits.
rs
rt
Immediate
Direccionamiento pseudodirecto
Campos:
Direccin de 26 bits.
La direccin se desplaza dos bits a la izquierda, y se concatena a los
cuatro primeros bits del contador de programa.
Se utiliza en instrucciones de salto.
Pseudodirect addressing
op
Memory
Address
PC
Word
Direccionamiento implcito
Un operando tiene direccionamiento implcito cuando est determinado por el
cdigo de operacin.
En MIPS hay pocos casos.
Ejemplo: jal 2500 almacena la direccin de la siguiente instruccin del
programa (PC + 4) en el registro de retorno $ra y salta a la direccin de memoria
correspondiente a la palabra 2500 (direccin 10000), donde empieza una
subrutina.
36
5. Tipos de Instrucciones
Transferencia de datos: mover, cargar, almacenar.
Aritmticas para enteros: sumar, restar, multiplicar, dividir, etc.
Aritmticas para coma flotante: sumar, restar, multiplicar, dividir, etc.
Operaciones lgicas: and, or, not, xor, etc.
Activacin condicional: si es r1 igual r2 entonces, saltar; si r1 es menor
que r2, entonces saltar, etc.
Instrucciones de rotacin y desplazamiento: desplazar hacia la
izquierda/derecha, etc.
Instrucciones de control de programa: saltar, saltar si menor, saltar y
enlazar direccin, etc.
Instrucciones de control de sistema: provocar excepcin, llamar al
sistema operativo, etc.
37
Tipo R
Cd. Op.
Registro
fuente 1
Registro
fuente 2
Registro
destino
xxxxxx
rs
rt
rd
shamt
funct
31-26
25-21
20-16
15-11
10-6
5-0
Tipo R
(shamt: shift amount
en instrucciones de
desplazamiento)
Funct
Operacin
Registro operando 2
Operando 1 Operando 2
Destino
Shamt
Funcin
17
18
32
000000
10001
10010
01000
00000
100000
Tipo I
Tipo I (carga o
almacenamiento,
ramificacin
condicional)
Cd. Op.
Registro
base
Registro
destino
Desplazamiento
xxxxxx
rs
rt
Inmediato
16
31-26
25-21
20-16
15-0
lw $t0, 32($s2)
Operacin
Registro base
Base
Destino
Desplazamiento
35
18
32
100011
10010
01000
0000000000010000
Tipo J
Cd. Op.
Direccin destino
Tipo J
xxxxxx
direccin
(salto
incondicional)
26
31-26
25-0
j 2500
Operacin
Destino
Cdigo
operacin
PC
Destino
4000
2500
000010
00000000000000000000111110100000
00000000000000000010011100010000
40
I
I
I
I
I
I
I
I
I
I
-------------------------------------rd = rs+rt
rd = rs+ext_signo(inm16,32)
rd = rs+rt
rd = rs+ext_signo(inm16,32)
lo = rs/rt; hi = rem(rs/rt)
lo = rs/rt; hi = rem(rs/rt)
hi-lo = rs1*s2
hi-lo = rs1*s2
rd = rs-rt
rd = rs-rt
and
andi
nor
or
ori
xor
xori
rd,rs,rt
rd,rs,inm16
rd,rs,rt
rd,rs,rt
rd,rs,inm16
rd,rs,rt
rd,rs,inm16
I
I
I
I
I
I
I
rd
rd
rd
rd
rd
rd
rd
=
=
=
=
=
=
=
rs
rs
rs
rs
rs
rs
rs
sll
sllv
sra
srav
srl
srlv
rd,rt,shamt5
rd,rt,rs
rd,rt,shamt5
rd,rt,rs
rd,rt,shamt5
rd,rt,rs
I
I
I
I
I
I
rd
rd
rd
rd
rd
rd
=
=
=
=
=
=
desp_log(rt,shamt5,izquierda)
desp_log(rt,rs4..0,izquierda)
desp_arit(rt,shamt5,derecha)
desp_arit(rt,rs4..0,derecha)
desp_log(rt,shamt5,derecha)
desp_log(rt,rs4..0,derecha)
AND rt
AND ext_ceros(inm16,32)
NOR rt
OR rt
OR ext_ceros(inm16,32)
XOR rt
XOR ext_ceros(inm16,32)
41
T
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
Descripcin
-------------------------------------rt = ext_signo(Mem[desp+rs]7..0,32)
rt = ext_ceros(Mem[desp+rs]7..0,32)
rt = ext_signo(Mem[desp+rs]15..0,32)
rt = ext_ceros(Mem[desp+rs]15..0,32)
rd31..16 = inm16; rd15..0 = 0
rt = Mem[desp+rs]
coprocesadorZ(rt) = Mem[desp+rs]
rt31.16 = Mem[desp+rs]
rt15..0 = Mem[desp+rs]
Mem[desp+rs] = rt7..0
Mem[desp+rs] = rt15..0
Mem[desp+rs] = rt
Mem[desp+rs] = coprocesadorZ(rt)
Mem[desp+rs] = rt31.16
Mem[desp+rs] = rt15..0
rd = rt; rd: registro UCP; rt: registro del coprocesador Z
rd = hi
rd = lo
rd = rt; rd: registro UCP; rt: registro del coprocesador Z
hi = rd
lo = rd
42
T
I
I
I
I
Descripcin
-------------------------------------Si rs < rt, rd = 1; si no, rd = 0
Si rs < ext_signo(inm16,32), rd = 1; si no, rd = 0
Si rs < rt, rd = 1; si no, rd = 0
Si rs < ext_signo(inm16,32), rd = 1; si no, rd = 0
bcZf
bcZt
beq
bgez
bgezal
bgtz
blez
bltz
bltzal
bne
j
jal
jalr
jr
I
I
I
I
I
I
I
I
I
I
I
I
I
I
Si
Si
Si
Si
Si
Si
Si
Si
Si
Si
PC
ra
rd
PC
I
I
I
I
etiqueta
etiqueta
rs,rt,etiqueta
rs,etiqueta
rs,etiqueta
rs,etiqueta
rs,etiqueta
rs,etiqueta
rs,etiqueta
rs,rt,etiqueta
objetivo
objetivo
rs,rd
rs
rfe
syscall
break
codigo20
nop
43
MIPS:
int a, b, c;
c = a + b;
44
C:
MIPS:
int a, b, c, d, e;
a = ( b + c ) ( d + e );
45
46
47
48
Sentencias de Control
Destacamos las siguientes instrucciones:
beq r1, r2, etiqueta (branch if equal)
Compara los valores contenidos en ambos registros.
Si son iguales, el flujo de programa salta a la instruccin que corresponde
a la etiqueta.
Si no lo son, la instruccin que se ejecuta es la siguiente a sta.
Ejemplos
C:
if (i==j) goto L1;
f = g + h;
L1: f = f i;
MIPS:
# Suponiendo que a las 5 variables de f a j les
# corresponden los registros de $s0 a $s4
L1:
# f = g + h
# L1: f = f - i
50
6. Ejemplos:
Condicin IF-THEN
C (variables enteras):
FALSA
COND?
MIPS:
if (x >= y) {
x = x+2;
y = y-2;
};
IF:
lw
lw
blt
addiu
addiu
sw
sw
CIERTA
BLOQUE_THEN
$s0,X
$s1,Y
$s0,$s1,END
$s0,$s0,2
$s1,$s1,-2
$s0,X
$s1,Y
END:
51
Condicin IF-THEN-ELSE
CIERTA
COND?
FALSA
C (variables enteras):
MIPS:
if (x >= y) {
x = x+2; y = y+2;
}
else {
x = x-2; y = y-2;
}
IF:
ELSE:
BLOQUE_ELSE
THEN:
BLOQUE_THEN
lw
lw
bge
addiu
addiu
sw
sw
j
addiu
addiu
sw
sw
$s0,X
$s1,Y
$s0,$s1,THEN
$s0,$s0,-2
$s1,$s1,2
$s0,X
$s1,Y
END
$s0,$s0,2
$s1,$s1,-2
$s0,X
$s1,Y
END:
52
Condicin REPEAT-UNTIL
MIPS:
C (variables enteras):
BLOQUE_REPEAT
COND?
FALSA
CIERTA
a = 81;
b = 18;
do {
mcd = b;
resto = a % b;
a = b;
b = resto;
} while (resto <> 0);
#
#
#
#
Variable
Variable
Variable
Variable
A: $s0
B: $s1
MCD: $s2
RESTO: $s3
li
$s0,81
li
$s1,18
REPEAT:
move
$s2,$s1
div
$s0,$s1
mfhi
$s3
move
$s0,$s1
move
$s1,$s3
UNTIL: bnez
$s3,REPEAT
# Habra que salvar
# las variables A, B, MCD
# y RESTO en memoria
Algoritmo ejemplo: clculo del mximo comn divisor, con gestin de variables
mediante registros.
53
Condicin WHILE-DO
MIPS
C (variables enteras):
COND?
CIERTA
BLOQUE_WHILE
FALSA
n = 5; fant = 1;
f = 1; i = 2;
while (i <= n) {
faux = f;
f = f + fant;
fant = faux;
i = i+1;
}
#
#
#
#
#
Variable N: $s0
Variable F: $s1
Variable FANT: $s2
Variable I: $s3
Variable FAUX: $s4
li
$s0,5
li
$s2,1
li
$s1,1
li
$s3,2
WHILE: bgt
$s3,$s0,END
move
$s4,$s1
addu
$s1,$s1,$s2
move
$s2,$s4
addiu $s3,$s3,1
j
WHILE
END:
# Salvar variables
# en memoria
Condicin FOR
MIPS (versin PASCAL):
C (variables enteras):
i:= valor_inicial
BLOQUE_FOR
n = 5;
fant = 1;
f = 1;
for (i=2; i<=n; i++) {
faux := f;
f := f + fant;
fant := faux;
}
i := i+1
#
#
#
#
#
Variable N: $s0
Variable F: $s1
Variable FANT: $s2
Variable I: $s3
Variable FAUX: $s4
li
$s0,5
li
$s2,1
li
$s1,1
FOR:
move
$t0,$s0
li
$s3,2
bgt
$s3,$t0,END
j
BODY
INC:
addiu $s3,$s3,1
BODY: move
$s4,$s1
addu
$s1,$s1,$s2
move
$s2,$s4
COND: bne
$s3,$t0,INC
END:
# Salvar variables en memoria
55
Ejemplo
C:
int a, V[100];
int i, j, k;
while (V[i] == k)
{
i = i + j;
}
MIPS:
# Suponiendo que a corresponde a $s0, V[0] a $s1,
# y las variables i, j, k a $s2 - $s4:
Bucle: add $t1, $s2, $s2
# t1 = 2*i
add $t1, $t1, $t1
# t1 = 4*i
add $t1, $t1, $s1
# t1 = dir. de V[i]
lw $t0, 0($t1)
# t0 = V[i]
bne $t0, $s4, Fin
# si i!=k salta
add $s2, $s2, $s3
# i = i + j
j Bucle
Fin:
56
Ejemplo
C:
int a, b, c, i, j;
if (i == j)
{
a = b + c;
}
else
{
a = b - c;
}
MIPS:
# Suponiendo que a, b, c corresponde a $s0 - $s2
# y las variables i,
bne $s3, $s4,
add $s0, $s1,
j Fin
SiNo: sub $s0, $s1,
Fin:
j a $s3 - $s4:
SiNo
# Si i!=j ir a SiNo
$s2
# se evita si i!=j
# Salta a Fin
$s2
# se ejecuta si i!=j
57
7. Conclusiones
Programa y Lenguaje de Programacin: Alto y bajo nivel.
Lenguaje Ensamblador y su correspondencia con el Lenguaje Mquina.
Aplicaciones de la programacin en Ensamblador.
Repertorio de Instrucciones del Lenguaje Mquina (caractersticas).
Formato de Instrucciones.
Modos de Direccionamiento.
Ejemplos en los procesadores MIPS.
58