Datorarkitekturer

1. Datorarkitekturer • Introduktion till assemblerprogrammering: • konventioner • syntetiska instruktioner • Kopplingen till C Datorarkitekturer

2. Assemblerprogrammering • MIPS-arkitekturen är inte enkel att programmera med assembler • Flera enkla operationer utförs med instruktioner som heter något helt annat: • ori $8,$0,50000– för att lägga en 16-bitars konstant i ett register • addu $9,$8,$0 – för att kopiera innehållet i ett register till ett annat (man slipper speciella kopieringsinstruktioner) • Förenkling: • Använd en konvention för hur register används och ge dem enkla namn • Använd syntetiska instruktioner Datorarkitekturer

3. Programmeringskonventioner • Konventionen styr • hur register används • hur subrutiner anropas Varför? • Genom konventioner kan man blanda rutiner skrivna i många olika programmeringsspråk Datorarkitekturer

4. $0 - zero – alltid noll $1 - at – reserverat för assemblatorn $2-$3 - v0-v1 – returvärde från funktioner $4-$7 - a0-a3 – argument till subrutiner $8-$15 - t0-t7 – temporära register $16-$23 - s0-s7 – variabler $24-$25 - t8-t9 – temporära register $26-$27 - k0-k1 – reserverade för operativsystemet $28 - gp – Global pekare $29 - sp– stackpekare $30 - s8/fp – variabel eller frame pointer $31 - ra – återhoppsadress Registeranvändning (boken sid 103) Datorarkitekturer

5. Tillgängliga register • Följande register är helt lediga för programmeraren: • t0-t9 – temporära värden • s0-s8 – variabler • Följande register är tillgängliga men har specialfunktion • zero – alltid noll • v0-v1 – returvärden • a0-a3 – argument Datorarkitekturer

6. Syntetiska instruktioner (1) • Ladda konstant (load immediate): • Syntax: li reg,konstant • Exempel 1: • Syntetisk instruktion:li s0,-5 • Verklig instruktion:addiu s0,zero,-5 • Exempel 2: • Syntetisk instruktion:li s4,0x12345 • Verkliga instruktioner:lui s4,0x1ori s4,s4,0x2345 Datorarkitekturer

7. Syntetiska instruktioner (2) • Addera med konstant: • Syntax: add dest-reg,src-reg,konstant • Exempel: • Syntetisk instruktion:add t0,s1,0x1234 • Verkliga instruktioner:addi t0,s1,0x1234 • Syntetisk instruktion:add t0,s1,0x12345 • Verkliga instruktioner:lui at,0x1 ori at,at,0x2345add t0,s1,at Datorarkitekturer

8. Syntetiska instruktioner (3) • Läs/skriv i minnet: • Syntax:lw dest-reg,effektiv adress • effektiv adress är något av • konstant(adr-reg) • address • Exempel: • Syntetisk instruktion:lw t0,0x1234567 • Verkliga instruktioner: lui t0,0x123lw t0,0x4567(t0) Datorarkitekturer

9. Syntetiska instruktioner (4) • Hoppinstruktioner: • Syntax:blt rs, rt, adress • adress i 16-bitars 2-komplement • Exempel: • Syntetisk instruktion:blt a0,a1,adress • Verkliga instruktioner: slt at,a0,a1bne zero,at,adress • Syntetisk instruktion:b adress • Verkliga instruktioner: beq zero,zero,adress Datorarkitekturer

10. Syntetiska instruktioner (5) • Kopieringsinstruktion: • Syntax:move rd, rs • Exempel: • Syntetisk instruktion:move v0,a1 • Verklig instruktion: addu v0,a1,zero Datorarkitekturer

11. Använd syntetiska instruktioner • Skriv assemblerkoden för följande C-program: • x och y finns i register s0 och s1 • 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

12. Subrutinen: x är i a0 och y i a1, returvärde i v0 max: blt a1,a0,L1 # hoppa till L1 om a1 < a0 (dvs om y < x) nop jr ra # return y move v0,a1 # v0 = y ELSE L1: jr ra # return x move v0,a0 # v0 = x IF Datorarkitekturer

13. C-konstruktioner i assembler • De flesta C-konstruktioner är enkla att göra i assembler: • if-satser • switch-satser • while-slingor • for-slingor Datorarkitekturer

14. IF-satser if (villkor) { … /* görs om villkoret är uppfyllt */} else { … /* görs om villkoret inte är uppfyllt */} • Vanliga villkor: ==, !=, >, >=, <, <= Datorarkitekturer

15. IF-satsen i assemblerkod bXX t0,t1,L1 nop … # görs om villkoret # inte är uppfyllt b ifend nopL1: … # görs om villkoret är # uppfylltifend: # slut på if-satsen • bXXersätts med något av: beq, bne, bgt, bge, blt, ble Datorarkitekturer

16. While-slingor while (villkor) { … /* satser som ska repeteras */} ersätts med: L1: if (!villkor){ goto L2; } … /* satser som ska repeteras */ goto L1;L2: ; Datorarkitekturer

17. For-slingor for (start-tillstånd; villkor; sats){ /* satser som ska repeteras */} ersätts med start-tillstånd; while (villkor){ /* satser som ska repeteras */sats;} Datorarkitekturer

18. Do-While-slingor do { /* satser som ska repeteras */while (villkor); ersätts med L1: ; /* Satser som ska repeteras*/ if (villkor) { goto L1; } Datorarkitekturer

19. Subrutiner är inte alltid så enkla som man kan tro: Hur skickas parametrarna? Hur skickas returvärdet? Var finns lokala variabler? int max(int x, int y){ int temp; if (x > y) { temp = x; } else { temp = y; } return temp; } Subrutiner Datorarkitekturer

20. Subrutin • Följande steg ska utföras vid anrop och exekvering av en subrutin: • Placera parametrarna på en plats där subrutinen kan komma åt dem • Hoppa till första instruktionen i subrutinen • Subrutinen allokerar minne som behövs • Subrutinen exekverar • Subrutinen placerar returvärdet på ett ställe där huvudprogrammet kan komma åt det • Subrutinen hoppar tillbaka till huvudprogrammet Datorarkitekturer

21. Räddande register Tack vare att MIPS-arkitekturen har många register kan de användas vid subrutinanrop: • a0-a3– argument (parametrar) till subrutinen • v0-v1– returvärden • ra– lagrar återhoppsadressen under tiden subrutinen exekverar • s0-s8 – lokala variabler i subrutinen men… • Det finns inte oändligt många register... Datorarkitekturer

22. Push-operation av s0 subu sp,sp,4sw s0,0(sp) Pop av s0 från stacken lw s0,0(sp)addiu sp,sp,4 sp sp sp push s0 pop s0 Stack – lägg saker på hög s0 Datorarkitekturer

23. Använd stacken • Skriv assemblerkoden för funktionen xmpl: int xmpl(int g, int h, int j, int k) { int e; int f; e = (g + h) - (i + j); f = max(e, h) + g; return f; } int max(int x, int y) { if (x > y) { return x; } else { return y; } } • Lägg e och f i register s0 och s1 • xmpl anropar en annan funktion: max • Vad händer med återhoppsadressen? Datorarkitekturer

24. Anatomin hos ett program • Ett program består av (minst) tre segment: • Text-segment – instruktionerna • Data-segment – datastrukturer som är åtkomliga för hela programmet • Stack-segment – lokala datastrukturer samt register m.m. vid subrutinanrop • Data-segmentet är dessutom uppdelat i två delar: • Statisk data – data som alltid finns tillgänglig • Dynamisk data – utrymme för data som skapas under programmets exekvering Datorarkitekturer