MIPS-arkitekturen

1. MIPS-arkitekturen Instruktionsmodellen. Datorarkitekturer

2. Instruktionsmodellen hos MIPS • 32 generella register $0-$31 (32 bitars) • ($0) = 0, $31 används vid subrutinanrop • Programräknaren, PC, innehåller adressen till nästa instruktion som ska utföras • Minnet innehåller både instruktioner och data Datorarkitekturer

3. Det finns tre grupper av instruktioner i processorn: • Aritmetiska/logiska instruktioner – utför databearbetning • Dataöverföringsinstruktioner – överför data från minnet till processorn eller från processorn till minnet • Hoppinstruktioner – styr programflödet Datorarkitekturer

4. Några instruktioner • Alla instruktioner är 32 bitar stora: Datorarkitekturer

5. Ett exempel: Skriv ett assemblerprogram för MIPS som utför följande C-sats: x = y + (z - 32); • x finns på adress 0x80040020 • y finns på adress 0x80040024: adressen för x + 4 • z finns på adress 0x80040028: adressen för x + 8 lui $8, 0x8004ori $8, 0x0020 # lägg adressen för x i reg $8 lw $16, 8($8) # läs in znop addi $17, $16, -32 # reg $17 = z-32 (16-bitarstal) lw $18, 4($8) # läs in ynop add $19, $17, $18 # addera y med (z-32) sw $19, 0($8) # skriv resultatet på adressen för x Datorarkitekturer

6. Aritmetiska instruktioner • Aritmetiska instruktioner har två källoperander och en destinationsoperand • Operanderna är alltid i register utom ena källoperanden som också kan vara en konstant Datorarkitekturer

7. Logiska instruktioner Datorarkitekturer

8. Instruktioner för minnet • Minnesaccesser kan göras med 8, 16 el 32 bitar • Adressen räknas ut som summan av innehållet i ett register plus en offset • Offset är 16 bitar stor: -32768 – 32767 Datorarkitekturer

9. Att lägga en adress i ett register • Instruktioner är 32 bitar långa • Adresser är 32 bitar långa • Hur lägger vi en adress i ett register? • Lösning: • Använd två instruktioner lui $rt,adress.hi# load upper immediate ori $rt,$rt,adress.lo # or immediate • Load upper immediate lägger ett 16-bitar stort tal i de 16 mest signifikanta bitarna i ett register; de övriga bitarna nollställs Datorarkitekturer

10. Instruktionenefter en branch-instruktionutförsalltid. Därförplaceras en no-operation (nop) efterbeqellerbneom man intekanhitta en “nyttig” instruktion Villkorliga hopp – branch Översätt följande C-kod till assembler. a, b, x och y finns i register $16-$19. if (a == b) { x = 0; } y = x; Omskriven C-kod: if (a != b) goto L1; x = 0; L1: y = x; Assemblerkod: bne $16,$17,L1 nop or $18,$0,$0 L1: or $19,$0,$18 Datorarkitekturer

11. Ovillkorliga hopp – jump Datorarkitekturer

12. Huvudprogram Subrutin Subrutinanrop Subrutinen ska hoppa tillbaka till olika ställen beroende på varifrån den anropades. Datorarkitekturer

13. Exempel • Skriv assemblerkoden för följande C-program: • x och y finns i register $16 och $17 • A och B i minnet på adress 0x0A004000 och 0x0A004004 Huvudprogram x = 34; y = 124; A = max(x,y); y = 19; B = max(x,y); Subrutin int max(int x, int y) { if (x > y) { return x; } else { return y; } } Datorarkitekturer

14. Subrutinen: x är i $4 och y i $5, returvärde i $2 max: slt $1,$4,$5 # $1 = 1 om $4 < $5 (dvs om x < y) annars $1=0 bne $1,$0,L1 # hoppa till L1 om $1!=0 (dvs om x < y) nop or $2,$0,$4 # $2 = x jr $31 # return x nop L1: or $2,$0,$5 # $2 = y jr $31 # return y nop Huvudprogram: start: ori $16,$0,34 # x = 34 ori $17,$0,124 # y = 124 or $4,$0,$16 # första parametern or $5,$0,$17 # andra parametern jal max # anropa subrutinen lui $8,0x0A00 ori $8,0x4000 sw $2,0($8) # skriv i A ori $17,$0,19 # y = 19 or $4,$0,$16 # första parametern or $5,$0,$17 # andra parametern jal max # anropa subrutinen sw $2,4($8) # skriv i B Datorarkitekturer

15. # .set noreorder bortkommenterad! .text .globl start .ent start # Subrutinen: x är i $4 och y i $5, returvärde i $2 max: blt $4,$5,L1 # hoppa till L1 om $4 < $5 (dvs om x < y) or $2,$0,$4 # $2 = x jr $31 # return x L1: or $2,$0,$5 # $2 = y jr $31 # return y Resultat: max: slt $1,$4,$5 # $1 = 1 om $4 < $5 (dvs om x < y) annars $1=0 bne $0,$1,L1 # hoppa till L1 om $1!=0 (dvs om x < y) nop # efter en branch! jr $31 # dessa två or $2,$0,$4 # är omkastade jr $31 # de här or $2,$0,$5 # också Datorarkitekturer

16. op rs rt offset op rs rt rd sa funk op hoppadress 6 5 5 5 5 6 Kodning av instruktioner i minnet • Alla instruktioner är 32 bitar stora, 4 byte • De kodas binärt på något av tre följande sätt: Datorarkitekturer

17. op rs rt offset I-typ (Immediate) • Instruktioner av I-typ är t.ex.: addi, ori, beq, lw, sw • op är en 6-bitar stor operationskod • rs, och rt är 5 bitar och pekar ut operanderna i register • offset är 16 bitar och används som konstant eller adressdifferens Datorarkitekturer

18. op rs rt rd sa funk R-typ (Register) • Instruktioner av R-typ är t.ex.: add, or, sub • op är en 6-bitar stor operationskod • rs, rt, och rd är 5 bitar och pekar ut operanderna i register • sa är 5 bitar “shift amount” • funk är 6 bitar funktionskod Datorarkitekturer

19. op hoppadress J-typ (jump) • Instruktioner av J-typ är t.ex.: j, jal • op är en 6-bitar stor operationskod • hoppadressen är en 26 bitar stor konstant Datorarkitekturer

20. Instruktionsmodellen definierar hur man skriver program på lägsta nivå Viktig för förståelsen för hur datorer är uppbyggda Nödvändig för de som vill ha mesta möjliga prestanda Nödvändig för de som skriver en kompilator Sammanfattning av instruktionsmodellen Datorarkitekturer

21. Viktiga begrepp: • instruktionsarkitektur • register • käll- och destinationsoperand • aritmetiska/logiska instruktioner • minnesinstruktioner • hoppinstruktioner • operationskod Datorarkitekturer