Ec Spim2

rogramac|n en e|
ensamb|ador de MIS
LS18uC1u8A uL CCMu1AuC8LS
hLLp://www.arcos.lnf.uc3m.es/~ec
Grupo de Arquitectura y Tecnologa de Computadores
(ARCOS)
Conten|dos
rcLlcas con SlM:
rograma, documenLacln y enunclados.
MlS:
8loques, reglsLros, memorla, ensamblador.
SlM: SlM:
uso del slmulador.
ldeas de dlseno de programas:
1lpos daLos bslcos, esLrucLuras de conLrol, funclones.
http://arcos.inf.uc3m.es/~ec
2
rcLlcas con SlM rcLlcas con SlM
Web de la aslgnaLura:
hLLp://www.arcos.lnf.uc3m.es/~ec/
Lnunc|ado de |as prct|cas
Lntregadores de prct|cas
Mater|a| para |a prct|ca
Lntregadores de prct|cas
Ca|endar|o de prct|cas
Slmulador y documenLacln.
hLLp://www.cs.wlsc.edu/~larus/splm.hLml
4
SW de| s|mu|ador usado en prct|cas
Manua|es
Las prcLlcas se reallzarn en las aulas 4.0.l.16 y
4.0.l.18.
Ll enLorno de Lraba[o para la reallzacln de las
prcLlcas ser Wlndows y el slmulador de MlS,
CSplm.
Lntorno de traba[o
CSplm.
IMCk1AN1L: Se usar una unlca cuenLa comparLlda
para Wlndows. Ll alumno es responsable de proLeger
sus flcheros frenLe a coplas, borrndolos al sallr de la
cuenLa y haclendo coplas de segurldad.
5
PerramlenLas de apoyo a las prcLlcas:
loro de la aslgnaLura:
hLLp://www.lab.lnf.uc3m.es/foro
Ll alumno debe reglsLrarse en el foro para poder escrlblr pregunLas o
comenLarlos. no es necesarlo el reglsLro para slo lecLura.
Segu|m|ento de prct|cas
IMCk1AN1L: Cs an|mamos a usar e| foro de LC ya que con vuestras
|ntervenc|ones benef|c||s a otros compaeros con |as m|smas dudas!
ara mandar correo:
ec[arcos.lnf.uc3m.es
C en parLlcular, a los profesores de prcLlcas.
6
lnLroduccln a MlS lnLroduccln a MlS
Cdigo fuente en
un lenguaje de
programacin de
alto nivel
Cdigo fuente en
lenguaje
ensamblador (de
bajo nivel)
a = b + c;
add $t0 $t0 $t1
Lengua[e ensamb|ador
Cdigo objeto
(lenguaje mquina)
CDIGO EJECUTABLE
(instrucciones binarias)
11110010100010
Libreras
8
CaracLerlsLlcas del MlS 82000 / 83000:
rocesadores de 32 blLs.
ArqulLecLura 8lSC (8educed lnsLrucLlon SeL CompuLer )
Pay 32 reglsLros de 32 blLs.
hLLp://es.wlklpedla.org/wlkl/MlS_(procesador)
Introducc|n a MIS
hLLp://es.wlklpedla.org/wlkl/MlS_(procesador)
ara las prcLlcas, se uLlllzar un slmulador basado
en MlS 82000 / 83000:
SlM.
verslones para Un|x, L|nux, Mac CS y W|ndows
9
Introducc|n a MIS
10
8anco de keg|stros (I)
8anco de keg|stros (II)
uso especlflco de los reglsLros:
5zero Llene cableado el valor numerlco cero.
Los reglsLros 5a0, 5a1, 5a2 y 5a3 se uLlllzan para pasar parmeLros a subruLlnas.
5v0 y 5v1 se uLlllzan para devolver valores de subruLlnas.
Ll reglsLro 5ra conLlene la dlreccln de reLorno y se uLlllza para volver despues de
una llamada a subruLlna.
Los reglsLros 5s0, 5s1, 5s2, 5s3, 5s4, 5sS, 5s6 y 5s7 son reglsLros salvados.
12
Los reglsLros 5s0, 5s1, 5s2, 5s3, 5s4, 5sS, 5s6 y 5s7 son reglsLros salvados.
Los reglsLros 5t0, 5t1, 5t2, 5t3, 5t4, 5tS, 5t6, 5t7, 5t8 y 5t9 son reglsLros
Lemporales.
Ll reglsLro 5gp conLlene el punLero global.
Ll reglsLro 5sp conLlene el punLero de plla.
Ll reglsLro 5fp conLlene el punLero de marco de plla.
Ll reglsLro 5at esL reservado para el uso por el ensamblador y no debe ser usado
por los programadores.
Los reglsLros 5k0 y 5k1 esLn reservados para su uso por el nucleo del slsLema
operaLlvo
8anco de keg|stros (III)
nombrado de los reglsLros:
nombre slmbllco: L[. $L0
numero de reglsLro (0..31). L[. $8
Adems de los reglsLros generales, exlsLen 3 reglsLros
especlales de 32 blLs:
13
Adems de los reglsLros generales, exlsLen 3 reglsLros
especlales de 32 blLs:
pc es el reglsLro conLador de programa que almacena la
dlreccln de la slgulenLe lnsLruccln a e[ecuLar.
h| y |o almacenan el resulLado de operaclones de
mulLlpllcacln o dlvlsln que generan resulLados de 64 blLs:
h| almacena la parLe alLa del reglsLro
|o almacena la parLe ba[a del reglsLro
8eservado
(2 C8)
0xffffffff
0x80000000
Mode|o de memor|a
8eservado (4M8)
SegmenLo de 1exLo
SegmenLo de uaLos
SegmenLo de lla
0x00000000
0x00400000
0x10000000
0x7fffefff
0x7ffff000 - 0x7fffffff 8eservado (4k8)
0x80000000
rograma de
usuarlo
Etiqueta:
cdigo instruccin, pseudo
instruccin directiva
operandos
Cada lnea del programa en ensamablador
contiene una nica sentencia:
Sentencia
MIS: ensamb|ador
# esLo es un comenLarlo hasLa fln de llnea
.daLa
lLem: .word 1
.LexL
.globl maln
maln: lw $L0, lLem
instruccin directiva
15
ulrecLlvas del ensamblador:
DIRECTIVAS USO
.data Los elementos siguientes se almacenan en segmento de
datos.
.text Los elementos siguientes se almacenan en segmento de
cdigo (texto).
.ascii tira de caracteres Almacena cadena caracteres NO terminada en carcter nulo.
MIS: ensamb|ador
http://arcos.inf.uc3m.es/~ec 16
.ascii tira de caracteres Almacena cadena caracteres NO terminada en carcter nulo.
.asciiz tira de caracteres Almacena cadena caracteres terminada en carcter nulo.
.byte 1, 2, 3 Almacena bytes en memoria, consecutivamente.
.half 300, 301, 302 Almacena medias palabras en memoria, consecutivamente.
.word 80000, 80001 Almacena palabras en memoria, consecutivamente.
.float 1.23, 2.13 Almacena float en memoria, consecutivamente.
.double 3.0e21 Almacena double en memoria, consecutivamente.
.space 10 Reserva un espacio de 10 bytes en el segmento actual.
.extern etiqueta n Declara que etiqueta es global de tamao n.
.globl etiqueta Declara etiqueta como global.
.align n Alinea el siguiente dato en un lmite de 2^n.
Crdenam|ento de |os bytes (I)
3 2 1 0
Menos
slgnlflcaLlvo
Ms
slgnlflcaLlvo
ulrecclones
n n+1 n+2 n+3
a) 8|g Lnd|an
El simulador SPIM no usa el
ordenamiento real del procesador
MIPS, sino que toma el
ordenamiento de la mquina en la
que se ejecuta:
Intel 80x86: little-endian.
Macintosh: big-endian.
3 2 1 0
Menos
slgnlflcaLlvo
Ms
slgnlflcaLlvo
ulrecclones
n+3 n+2 n+1 n
a) 8|g Lnd|an
b) L|tt|e Lnd|an
La directiva .align permite alinear en
memoria datos a 2^n bytes.
Crdenam|ento de |os bytes (II)
.data
cadena: .asciiz "Hola Mundo \n"
DATA
[0x10000000]...[0x10010000] 0x00000000
Programa en ensamblador MIPS
Representacin en PCSpim
[0x10000000]...[0x10010000] 0x00000000
[0x10010000] 0x616c6f48 0x6e754d20 0x0a206f64 0x00000000
[0x10010010]...[0x10040000] 0x00000000
STACK
Interpretacin
[0x10000000]...[0x10010000] 0x00000000
[0x10010000] 0xaloH 0xnuM- 0x \n- od
[0x10010010]...[0x10040000] 0x00000000
v v v v
1lpos de lnsLrucclones:
ArlLmeLlcas y lglcas
add 8d, 81, 82 # add, addl, addu, addlu
Comparacln
seq 8d, 81, 82 # seq, sge, sgL, sle, slL, slLl, ...
Carga y almacenamlenLo
MIS: ensamb|ador
Carga y almacenamlenLo
la 8d !"#$! # la, lb, lbu, lh, lw (Carga)
sw 8o !"#$! # sb, sh, sw (AlmacenamlenLo)
SalLo condlclonal e lncondlclonal
beq 81, 82, !"#$! # beqz, bge, bgL, ble, ...
Mane[o excepclones / lnLerrupclones
rfe, nop, break %, syscall.
hLLp://www.arcos.lnf.uc3m.es/~ec/splm/88-SlM.doc
L|amadas a| s|stema
L[emplo:
rograma que lmprlme dlferenLes Llpos de daLos:
hLLp://www.arcos.lnf.uc3m.es/~ec/e[emplos/Llpos_daLos.s
Cperaclones con numeros negaLlvos y desbordamlenLo:
L[emp|o (I)
Cperaclones con numeros negaLlvos y desbordamlenLo:
hLLp://www.arcos.lnf.uc3m.es/~ec/e[emplos/overflow.s
Slo las lnsLrucclones load/sLore acceden a memorla
FORMATO CLCULO DE LA DIRECCIN EJEMPLO
(registro) Contenido del registro (cr) Lw $t0, ($t2)
Valor Valor inmediato (vin) Lw $t0, 0x10010008
Valor (registro) Vin + cr Lw $t0, 0x10010000($t1)
Modos de d|recc|onam|ento(I)
Valor (registro) Vin + cr Lw $t0, 0x10010000($t1)
Identificador Direccin del identificador (did) Lw $t0, array
Identificador +/- valor Did +/- vin Lw $t0, array+8
Identificador (registro) Did + vin Lw $t0, array($t1)
Identificador +/- valor(registro) Did +/- vin + cr Lw $t0, array+4($t1)
a0 0X005f0000
.data
array: .byte 0,1,2,3,4,5,6,7
palabra: .word 100
otro_array: .byte 12,13,14,15
la $a0 array #$a0=direccin de array
lb $t0 ($a0) #$t0=primer byte de array
lb $t1 array #$t1=$t0
Load/Store
Registros MIPS
Modos de d|recc|onam|ento(II)
Alineamiento
a0
t0
t1
0X005f0000
0
La arquitectura MIPS dispone de un coprocesador
para los nmeros en punto-flotante (Coprocesador 1)
Dispone de sus propios registros: $f0..$f31 con una
longitud de 32 bits.
Opera con nmeros de simple precisin (32 bits) y
doble precisin (64 bits) para los cuales utiliza dos
IU (Coprocesador 1)
doble precisin (64 bits) para los cuales utiliza dos
registros.
Adems, el coprocesador 1 dispone de una serie de
instrucciones especficas para la manipulacin de
nmeros en punto flotante.
http://www.arcos.inf.uc3m.es/~ec/spim/RR-
SPIM.doc
8anco de keg|stros de IU
uso especlflco de los reglsLros:
Los reglsLros 5f0 y 5f2 se uLlllzan para devolver valores de
subruLlnas
Los reglsLros 5f4, 5f6, 5f8, 5f10, 5f16 y 5f18 son reglsLros
Lemporales. Ls declr, no hay garanLla de que una subruLlna no
25
Lemporales. Ls declr, no hay garanLla de que una subruLlna no
vaya a modlflcar su valor.
Los reglsLros 5f12 y 5f14 se uLlllzan para pasar parmeLros a
subruLlnas.
Los reglsLros 5f20, 5f22, 5f24, 5f26, 5f28 y 5f30 son reglsLros
salvados.
.data
entero: .byte 5
flotante: .float 3.0
.text
.globl main
Ejemplo (II)
http://www.arcos.inf.uc3m.es/~ec/ejemplos/ejemplo.s
26
main:
lb $t0 entero # $t0=5
mtc1 $t0 $f0 #$f0=7.00649e-045
cvt.s.w $f1 $f0 #$f1= 5.00000
l.s $f0 flotante #$f0= 3.00000
add.s $f12 $f1 $f0 #$f12= 8.00000
li $v0 2
syscall
lnLroduccln a SlM lnLroduccln a SlM
SPIM
USUARIO
hola.s
!"#$%&'(
!&)*'(
SIM
!+,%"-$%&'(
CPU MIPS 2000
hola
./0#(%&'(
USUARIO
memoria
!"#$%&'(
Llamadas al sistema
1. LdlLar el flchero de ensamblador
!&)*'(
SIM: Ln e| |aborator|o (1)
Usuari@
hola.s
!&)*'(
2. Lnsamblar
!+,%"-$%&'(
hola.s
Usuari@
!+,%"-$%&'(
CPU
hola
Memoria
3. L[ecuLar/uepurar
./0#(%&'(
Usuari@
./0#(%&'(
CPU
hola
Memoria
L[ecuLar slmulador: xsp|m o CSp|m.
help -- ayuda
load "llLL" -- leer programa en memorla.
prlnL $n -- muesLra el conLenldo del reglsLro n.
prlnL Auu8 -- muesLra el conLenldo de la memorla en la dlreccln Auu8.
breakpolnL <Auu8> -- lndlca un punLo de parada de e[ecucln.
SIM
breakpolnL <Auu8> -- lndlca un punLo de parada de e[ecucln.
deleLe <Auu8> -- borra Lodos los punLos de parada.
llsL -- llsLa los punLos de parada.
run -- comenzar a e[ecuLar el programa.
conLlnue -- conLlnuar la e[ecucln del programa.
sLep <n> -- e[ecuLar n lnsLrucclones
exlL -- sallr del slmulador.
CSp|m
.data
msg_hola: .asciiz Hola mundo!\n"
.text
.globl main
hola.s
no|a Mundo!
main:
# printf(Hola mundo!\n") ;
li $2 4 #$2=$v0
la $4 msg_hola #$4=$a0
syscall #print_string
li $2 10 #$2=$v0
syscall #exit
CSp|m ] xsp|m
load "hola.s"
breakpolnL maln
conLlnue
sLep 1 hola.s con pseudo-instrucciones
hola.s con instrucciones
CSp|m]xsp|m
sLep 1
[0x0040002c] 0x34020004 orl $2, $0, 4 , 8: ll $2 4
[0x00400030] 0x3c011001 lul $1, 4097 [msg_hola] , 9: la $4 msg_hola
[0x00400034] 0x3424000c orl $4, $1, 12 [msg_hola]
[0x00400038] 0x0000000c syscall , 10: syscall
hola mundo
exlL
salir del simulador.
hola.s con pseudo-instrucciones
ldeas de dlseno de programas ldeas de dlseno de programas
var
integer resultado ;
integer op1 = 100 ;
integer op2 = -10 ;
integer op3 = 25 ;
...
.data
resultado: .space 4 # 4 bytes
op1: .word 100
op2: .byte -10
op3: .half 25
...
.text
.globl main
Ideas de d|seo para SIM
1|pos de datos bs|cos (enteros)
...
begin
resultado := op1 + op2 ;
resultado := resultado + op3;
...
End.
main: lw $t1 op1
lb $t2 op2
add $t3 $t1 $t2
lh $t4 op3
add $t3 $t3 $t4
la $t4 resultado
sw $t3 ($t4)
#sw $t3 resultado
...
var
vec: array [1..5] of integer;
mat: array [1..2,1..3] of
integer := [[11, 12, 13],
[21, 22, 23]];
...
.data
vec: .space 20 #5 elem.*4 bytes
mat: .word 11, 12, 13
.word 21, 22, 23
...
.text
1|pos de datos bs|cos (vectores)
...
begin
m[1][2] := m[1][1] +
m[2][1] ;
...
End
.text
.globl main
main: lw $t1 mat+0
lw $t2 mat+12
add $t3 $t1 $t2
sw $t3 mat+4
...
var
c1: char ;
c2: char := h ;
ac1: string := hola ;
...
begin
.data
c1: .space 1 # 1 byte
c2: .byte h
ac1: .asciiz hola
...
1|pos de datos bs|cos (str|ng)
begin
write(ac1) ;
...
End.
.text
.globl main
main: li $v0 4
la $a0 ac1
syscall
...
var
b1: boolean;
b2: boolean := false ;
...
begin
.data
b1: .space 4 # 4 bytes
b2: .word 0
...
.text
.globl main
1|pos de datos bs|cos (boo|ean)
begin
if (b2 = true) then
begin
b1 := true ;
end;
...
End.
.globl main
main:
if_1: la $t0 b2
beq $t0 $0 fi_1
la $t0 b1
li $t1 1
sb $t1 ($t0)
fi_1: ...
if (a < b) then
begin
{ accin 1 }
End;
else
begin
.data
a: .word 1
b: .word 2
.text
.globl main
main:
if_2: lw $t1 a
Lstructuras de dec|s|n (|f)
begin
{ accin 2 }
End;
if_2: lw $t1 a
lw $t2 b
slt $t0 $t1 $t2
then_2: ...
# accin 1
else_2: ...
# accin 2
fi_2: ...
b fi_2
beq $t0 $0 else_2
SalLo lncondlclonal
SalLo condlclonal
case (i) of
begin
10:
begin
{accin 1}
end;
...
lw $t1 i
li $t2 10
...

Lstructuras de dec|s|n (sw|tch)
beq $t1 $t2 case_1_1
b default_1
...
else:
begin
{accin por defecto}
end;
End;
case_1_1: ...
# accin 1
default_1: ...
# accin por defecto
esac_1: ...
b esac_1
var
vec: array[0..3] of
integer := [1,2,3,0] ;
i: integer;
Begin
.data
vec: .word 1,2,3,0
...
.text
.globl main
main: move $t0 $0 #contador
repeat_1: # accin
Lstructuras de repet|c|n (repeat unt||)
i:=0;
repeat
{ accin }
...
i := i + 1 ;
until (vec[i] = 0) ;
End.
repeat_1: # accin
lw $t1 vec($t0)
beq $t1 $0 fin_repeat_1
addu $t0 $t0 4
b repeat_1
fin_repeat_1: ...
var
vec: array[0..3] of integer
:= [1,2,3,0] ;
i: integer;
begin
i:=0;
.data
vec: .word 1,2,3,0
...
.text
.globl main
main: move $t0 $0
Lstructuras de repet|c|n (wh||e)
i:=0;
while (vec[i] <> 0) do
begin
/* accin */
...
i := i + 1 ;
end;
End.
main: move $t0 $0
while_1: lw $t1 vec($t0)
beq $t1 $0 fin_while_1
# accin
addu $t0 $t0 4
b while_1
fin_while_1: ...
Subrut|nas
ma|n: .
.
[a| subrut|na subrut|na:
Una subrutina es equivalente a un procedimiento
o funcin en los lenguajes de alto nivel.
ra=ul8([al_subruLlna)+1
C=ul8(subruLlna)
[a| subrut|na
.
.
[al subruLlna2
.
subrut|na:
..
..
..
..
[r 5ra
C = ra
(return address)
Comun|cac|n programa-subrut|na(I)
La funcln llamanLe debe:
Sa|vaguardar reg|stros:
una subruLlna puede modlflcar cualquler reglsLro 5an y 5tn.
ara preservar su valor, es necesarlo guardar en plla esos
reglsLros anLes de la llamada a subruLlna.
aso de argumentos:
aso de argumentos:
Se uLlllzarn los reglsLros generales 5a0, 5a1, 5a2 y 5a3 y 5f12 y
5f14. Sl se neceslLan pasar ms parmeLros deber usarse la
plla
L|amada a subrut|na:
Se reallzar la llamada a subruLlna medlanLe [a| (o bal)
!"#$%&'()$%)*+!,
Comun|cac|n programa-subrut|na (II)
La funcln llamada debe:
keserva de| marco de p||a y sa|vaguarda de reg|stros.
Se deber reservar espaclo en la plla para almacenar los reglsLros
5sn. 5fp y 5ra se almacenarn slo sl la ruLlna crea un nuevo
marco de plla ($sp = $sp - Lamano del marco de plla)
Mod|f|cac|n de 5fp (-%,#& /"+!*&%0
Mod|f|cac|n de 5fp (-%,#& /"+!*&%0
Se debe esLablecer el nuevo valor del punLero del marco de plla
5fp ($fp = $sp + Lamano del marco de plla - 4)
L[ecuc|n de| cuerpo de |a subrut|na
L[ecucln de la subruLlna y devolucln de los argumenLos de
sallda en 5v0 y 5v1 (o 5f0,5f2).
Comun|cac|n programa-subrut|na (III)
Al Lermlnar, la funcln llamada debe:
kestaurac|n de va|ores guardados
8esLaurar los valores de los reglsLros que se guardaron en la plla.
L|berac|n de| marco de p||a
Llberar el espaclo reservado para el marco de plla. ($sp = $sp +
Llberar el espaclo reservado para el marco de plla. ($sp = $sp +
marco de plla)
Sa||da de |a subrut|na
volver a la lnsLruccln slgulenLe a aquella que lnvoc a la
subruLlna: [r 5ra
Ll marco de plla es una zona de memorla reservada
denLro de la plla, para almacenar daLos Lemporales
de una funcln, como son:
Los reglsLros que no qulera o deba modlflcar.
Las varlables locales de la funcln.
Subrut|na: Marco de p||a
Las varlables locales de la funcln.
Ll marco de plla es lmpresclndlble sl se qulere
reallzar funclones recurslvas.
La creacln y el uso del marco de plla debe segulr un
esLrlcLo convenlo.
1) PUSH
1) Desplazar una palabra de memoria el puntero de
pila $sp (hacia una posicin menor)
subu $sp $sp 4
2) Almacenar el dato en la posicin liberada en 1)
sw $ra 4($sp)
$sp
dato
$sp
Iunc|ones ush]op
sw $ra 4($sp)
2) POP
1) Cargar en un registro el dato en la posicin
siguiente (superior) a $sp
lw $ra 4($sp)
2) Desplazar una palabra de memoria el puntero de
pila $sp (hacia una posicin mayor)
addu $sp $sp 4
$sp
dato
$sp
dato
Function factorial
( a: integer ) : integer
begin
if (a < 2) then
return 1 ;
return a * factorial(a-1) ;
End.
factorial(a=4)
(a < 2) ?
6 * 4
factorial(a=3)
(a < 2) ?
L[emp|o: factor|a|
End.
begin
...
resultado := factorial(4) ;
End.
2 * 3
factorial(a=2)
(a < 2) ?
1 * 2
factorial(a=1)
(a < 2) ?
factorial:
# frame stack
subu $sp $sp 12
sw $ra 12($sp)
sw $fp 8($sp)
FP
ra
...
+
Iactor|a|: aso argumentos (1]3)
sw $fp 8($sp)
addu $fp $sp 12
FP
SP
...
fp
...
...
ra
# if ($a0 < 2) then return 1;
bge $a0 2 b_else
li $v0 1
b b_efs
# return a * factorial(a-1);
FP
fp
ra
...
a
+
# return a * factorial(a-1);
b_else: sw $a0 -8($fp)
addi $a0 $a0 -1
jal factorial
lw $v1 -8($fp)
mul $v0 $v0 $v1
SP
a0 (a)
fp
...
...
...
...
a-1
a
# end frame stack
b_efs: lw $ra 12($sp)
lw $fp 8($sp)
addu $sp $sp 12
jr $ra
FP
...
...
+
SP
a0 (a)
fp
...
ra
...
8|b||ograf|a
roblemas resuelLos de LsLrucLura de CompuLadores.
&' )"*+,"- .' /' )"*+,"- /' 01234567- .' 8"**$6$*7'
Ld. aranlnfo Cengage Learnlng, 2008.

Ec Spim2

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Ec Spim2

Hochgeladen von

Copyright:

Verfügbare Formate

rogramac|n en e|

Ideas de d|seo para SIM

Das könnte Ihnen auch gefallen