CE_O2. Nios II. Subrutiner med mera.

Transkript

1 IS1500 Lösningsförslag till övning CE_O CE_O2. Nios II. Subrutiner med mera Binära lagringsformat R-type: (Register-format) ra (5 bit) rb (5 bit) rc (5 bit) operationskod (17 bit) Detta format är lämpligt för de instruktioner som använder innehåll från tre register vid sin exekvering. Typexempel är ADD och liknande. Instruktionen add rc,ra,rb medför att innehållet i angivet register rb adderas till innehållet i angivet register ra. Resultatet skrivs därefter till angivet register rc. Motsvarande gäller för många instruktioner, bland annat sub, and, or, nor, xor, mul och div. Jämförelseinstruktionerna i Nios II kodas med R-formatet, likaså instruktionerna för skift och rotation (se en senare uppgift). I-type: (Immediate-format ra (5 bit) rb (5 bit) IMM16 (16 bit) op kod (6 bit) Detta format används för instruktioner som använder en 16 bitars konstant, IMM16, samt två register. Typexempel är ADDI och liknande. Instruktionen addi rb,ra,imm16 medför att en 16 bitar stor konstant IMM16 först utvidgas till 32 bitar med sign-extension;, och sedan adderas med innehållet i angivet register ra. Resultatet av additionen skrivs därefter till angivet register rb. Motsvarande gäller för ett flertal instruktioner, som subi, andi, andhi, ori, orhi, xori, xorhi och muli. De flesta jämförelseinstruktioner i Nios II finns i en immediate-variant som kodas med I-formatet. Formatet används även av LOAD och STORE-instruktioner med offset lagrad i IMM16-fältet. Även för Load och Store görs sign-extension innan IMM16-värdet används; det medför att offset kan vara både positiva och negativa. J-type: (Jump-format) IMMED26 (26 bit) op kod (6 bit) Detta format används endast av instruktionen CALL. Hoppadressen tas fram som de 4 mest signifikanta bitarna från aktuellt värde i PC, följt av 26 bitar från IMMED26 och slutligen 2 nollor i de minst signifikanta bitarna. Effektiva adressen skrivs till PC och medför subrutinanrop varvid returadressen sparas som vanligt i register r31 = ra. Lösningsförslag till övning CE_O2, sida 1 (av 12)

2 2.2. Subrutinanrop med CALL eller CALLR Instruktionen callr medför att hela innehållet i angivet register kopieras till programräknaren (Program Counter, PC). Instruktionen call (som är en av de få instruktioner som använder J-formatet) har plats för en 26-bitars konstant. Effektiva adressen, det vill säga det värde som skrivs till programräknaren, bildas på följande sätt. Ur aktuellt värde i PC tar hårdvaran de 4 mest signifikanta bitarna, sedan används de 26 bitarna från instruktionen. Till sist kompletterar hårdvaran med 2 nollor i de 2 minst signifikanta positionerna. Konsekvensen blir att man kan anropa godtycklig adress på den "sida" om 256 Mbyte som anges av de 4 mest signifikanta bitarna i PC. Det värde som finns i CALL-instruktionens IMM26-fält multipliceras med 4 (skiftas 2 steg vänster) innan det används. Det värde som står i CALL-instruktionen anger alltså word-offset inom aktuell "sida". Här nedanför visas ett exempel med instruktionen call 0x x11c440 (0x / 4, 26-bit absolute address) 0 (opcode) PC (= 0x ) call instr (= 0x11c440) zeroes......since instruction addresses must end with binary (= 0x ) För både call och callr gäller att returadressen, det vill säga adressen till instruktionen närmast efter call/callr, sparas i register r31. Register r31 kallas även ra (return address register). Lösningsförslag till övning CE_O2, sida 2 (av 12)

3 2.3. Retur från subrutin Man ska alltid använda instruktionen ret som helt enkelt kopierar innehållet i register r31 till PC. Man kan tro att det skulle gå lika bra med instruktionen JMP r31, men det är inte tillåtet. Instruktionen ret har binärkoden Instruktionen jmp r31 är EJ tillåten, men skulle ha binärkod Påminnelse: ra är bara är ett annat namn för register r31. Instruktionerna ret och jmp r31 har alltså olika maskinkod. I Nios II Processor Reference Handbook står dessutom följande: It is illegal to jump to the address contained in register r31. To return from subroutines called by call or callr, use ret instead of jmp Multiplikation med upprepad addition a) Flödesschema för subrutinen muladd: start total = 0 i = 1 i tal1 YES total = total + tal2 NO return value = total i = i + 1 return Lösningsförslag till övning CE_O2, sida 3 (av 12)

4 b) Funktionen muladd kan skrivas så här i C: int muladd( int a, int b ) int i; int total = 0; for( i = 1; i <= a; i = i + 1 ) /* b is added to total, a times */ total = total + b; return( total ); Översättning från for-slinga till while-slinga ger följande: int muladd( int a, int b ) int total = 0; int i = 1; while( i <= a) total = total + b; i = i + 1; return( total ); Översättning från while-slinga till if-goto ger nästa version av funktionen: int muladd( int a, int b ) total = 0; i = 1; L1: if( i > a ) goto L2; total = total + b; i = i + 1; goto L1; L2: return( total ); Nu är det dags att översätta från vår förenklade C-kod till assemblerkod. Vi placerar alla variablerna i register, och väljer dessutom att ha variabeln total i returvärdesregistret r2. För i väljer vi r8. Före anrop till en funktion ska funktionens första parameter placeras i r4, andra parametern i r5 och så vidare. De två tal som ska multipliceras finns alltså i r4 och r5 när funktionen muladd börjar exekvera. muladd: movi r2,0 # total = 0 movi r8,1 # i = 1 L1: bgt r8,r4,l2 # if( i > a ) goto L2 /* a finns i r4 */ add r2,r2,r5 # total = total + b /* b finns i r5 */ addi r8,r8,1 # i = i + 1 br L1 # goto L1 L2: ret # total finns i r2 Lösningsförslag till övning CE_O2, sida 4 (av 12)

5 c) Körtiden för muladd beror på vilka värden som multipliceras, närmare bestämt på det ena värdet som finns i register r4. Detta värde avgör hur många varv som slingan mellan L1 och L2 körs. I värsta fall är värdet i storleksordningen 2 miljarder, och då körs slingan 2 miljarder varv. På den Nios II/s som används på laborationerna tar detta omkring 8 miljarder klockcykler, eller närmare 3 minuter. För att komma fram till detta värde gjordes följande beräkningar. Instruktionerna i slingan är bgt add addi br. Instruktionen bgt hoppar framåt, och hoppet tas normalt inte; detta fall ger en körtid på 1 klockcykel. Instruktionerna add och addi tar 1 klockcykel vardera. Instruktionen br hoppar bakåt; detta fall ger en körtid på 2 klockcykler. Summan är alltså 5 klockcykler per varv. Programkoden före och efter själva slingan bidrar bara i försumbar utsträckning till körtiden, när r4 innehåller stora värden. Låt oss också beräkna körtiden för multiplikation med 10. Vi antar att talet 10 finns i register r4. Slingan körs då 10 varv vilket tar 50 klockcykler. Det tillkommer 3 extra cykler för bgt i sista varvet, då hoppet tas. Vidare tar de båda movi-instruktionerna 1 klockcykel vardera, och ret tar 4 klockcykler. Totalt tar funktionen muladd alltså klockcykler = 59 klockcykler för multiplikation med Skifta och rotera bitarna i ett ord Man skiljer mellan operationer/instruktioner för SHIFT och ROTATE. SHIFT skiftar innehållet i utpekad operand varvid oftast nollor fylls på och utskiftade bitar slängs bort. Exempel: innehåll i R9 = 0x bitar slli r9, r9, 2 # skifta innehåll i r9 vänster 2 steg 0:or in till höger bort Innehåll i R9 efteråt = 0x c = 0x x 4 ROTATE ser till att varje utskiftad bit skiftas in i den utpekade operanden. bitar ut Exempel: innehåll i R9 = 0x roli r9, r9, 2 # rotera innehåll i r9 vänster 2 steg Innehåll i R9 efteråt = 0x d samma bitar in till höger Lösningsförslag till övning CE_O2, sida 5 (av 12)

6 SHIFT och ROTATE kan göras åt höger eller vänster. SHIFT och ROTATE kan göras med olika antal steg. Skift finns ofta i två olika versioner, logiskt och aritmetiskt. ARITMETISKT SKIFT HÖGER motsvarar division med 2. För att det ska fungera ska teckenbiten repeteras så att negativa tal fortsätter att vara negativa, och positiva fortsätta att vara positiva. Här är ett exempel där vi dividerar ett negativt tal med 4. Logiskt högerskift ger fel resultat: Exempel: innehåll i R9 = 0xfffffff4 = srli r9, r9, 2 0:or in till vänster # skifta innehåll i r9 höger 2 steg bitar bort Innehåll i R9 efteråt = 0x3ffffffd = (fel!) Aritmetiskt högerskift ger rätt resultat: Exempel: innehåll i R9 = 0xfffffff4 = srai r9, r9, 2 kopior av teckenbiten in till vänster # aritmetiskt skift av innehåll i r9 höger 2 steg bitar bort Innehåll i R9 efteråt = 0xfffffffd = 3 (rätt!) SKIFT VÄNSTER motsvarar multiplikation med 2. Det ger risk för att talområdet överskrids; för tal med teckenbit sker det när teckenbiten växlar värde. Nios II har ingen hårdvara som upptäcker detta, utan programmeraren får skriva programkod som undersöker värdena före och efter operationen. Nios-II har följande instruktioner: Rotation: rol, ror och roli. Instruktionerna rol och ror är ROtate Left repektive ROtate Right. Instruktionerna använder R-format med tre register. Exempel: rol rc,ra,rb medför att innehållet i ra roteras det antal steg som anges av innehåll i rb (endast 5 bitar används, högst 31 stegs rotation) och resultatet placeras i register rc. Lösningsförslag till övning CE_O2, sida 6 (av 12)

7 Instruktionen roli är en "immediate-variant" av rol där man anger antal steg som en konstant med maxvärde 31. Det finns ingen immediate-variant av ror, men "rotate right IMM5" kan utföras med instruktionen roli (32 minus IMM5). Instruktionerna sll och srl samt slli och srli är logiska skiftinstruktioner. Instruktionerna sra och srai är aritmetiska skiftinstruktioner Intruktionerna utan "i" använder R-format enligt ovan och instruktionerna med "i" utnyttjar IMM5-fält precis som rotate-instruktionerna ovan. De aritmetiska skift-instruktionerna sra och srai duplicerar teckenbiten precis som det önskades enligt ovan. Man kan fråga sig vad man ska ha dessa instruktioner till. Ett svar är att in- och utmatning på låg nivå kan kräva detta slags operationer på bitnivå. Exempelvis kan ett program behöva undersöka varje bit i ett ord, och räkna hur många av bitarna som är ettställda Multiplikation med konstant, med hjälp av skift och addition Idén är att bilda produkten 10A genom att addera 2A + 8A, där 2A och 8A beräknas med skift-instruktioner. a) Vi får följande program om värdet A finns i r4. Koden fungerar för negativa tal i r4 om de lagras med 2-komplementsrepresentation. mul10: slli r4,r4,1 # r4 får värdet 2A slli r8,r4,2 # r8 får värdet 8A add r2,r4,r8 # r4 får värdet 2A+8A dvs 10A ret # och så återhopp från subrutinen b) Denna subrutin ska ta 11 klockcykler på den Nios II/s som används på laborationerna. Instruktionen slli tar 3 klockcykler med den hårdvara som finns på laborationerna, add tar 1 cykel och ret tar 4 cykler. c) Talområdet för heltal utan tecken (unsigned int) i Nios II är Om produkten blir större än så så överskrids talområdet och resultatet blir fel. d) Subrutinen mul10 fungerar bra för negativa tal, så länge talområdet inte överskrids. Talområdet för heltal med tecken (signed int) i Nios II är ( ) ( ). Är produkten större än , eller mer negativt än ( ), så överskrids talområdet och resultatet blir fel. Lösningsförslag till övning CE_O2, sida 7 (av 12)

8 2.7. STACKOPERATIONER a) Visa hur en stack fungerar. En stack är en speciell datastruktur. Det går att reservera plats och lägga in nya data, och det går att ta bort gamla data. Stackstrukturen har en begränsning: data måste tas bort i omvänd ordning mot hur de lades in. Det betyder att det senast inlagda värdet måste tas bort först, sedan kan det näst senast inlagda tas bort, och så vidare. I Nios II växer stacken alltid i riktning mot adress 0. Ett av processorns register används som stackpekare. Stackpekaren innehåller alltid adressen till det senast inlagda värdet. Man brukar säga att stackpekaren pekar på det senast inlagda värdet. När ett 4 byte stort värde ska läggas in på stacken så minskas stackpekaren först med 4, så att stackpekaren pekar på ett lagom stort ledigt utrymme. Sedan skrivs värdet till det lediga utrymmet. Denna operation kallas push, och man talar ibland om att pusha ett värde på stacken. (fortsättning följer) stack pointer 0x3fff0 0x3ffec 0x3fff0 adress 0 adress 0x3fff0 adress 0xffffffff adress 0 adress 0x3fff0 X 1 adress 0xffffffff nyast äldst 2 ännu nyare inte längre nyast äldst Lösningsförslag till övning CE_O2, sida 8 (av 12)

9 Operationen att ta bort ett tidigare pushat värde brukar kallas pop. Man talar om att poppa ett värde från stacken. Ska ett värde tas bort från stacken så görs de omvända operationerna, i omvänd ordning. Först läses det senast inlagda värdet. Det värdet finns ju på den minnesadress som stackpekaren anger (pekar på). Vi förutsätter att värdet är 4 byte stort. 0x3fff0 0x3ffec adress 0 1 adress 0x3ffec 2 X just nu nyast blir snart nyast äldst Sedan ökas stackpekarens värde med 4. adress 0xffffffff I och med att stackpekaren ökats med 4 så ligger det poppade värdet utanför stacken, och kommer att skrivas över vid nästa push-operation. b) Operationen PUSH rx (byt rx mot något av registren r2 r23) subi sp,sp,4 stw rx,0(sp) Operationen POP rx ldw rx,0(sp) addi sp,sp,4 c) Makron: register sp är samma som register r27 (se sid 3-2 i manualen kapitel 3: Programming Model).macro PUSH reg subi sp,sp,4 stw \reg,0(sp).endm.macro POP reg ldw \reg,0(sp) addi sp,sp,4.endm Lösningsförslag till övning CE_O2, sida 9 (av 12)

10 2.8. Subrutinanrop i flera nivåer (nästlade anrop) Vilka speciella åtgärder måste vidtagas om man gör ett subrutinanrop i en subrutin? Kallas även inkapslad subrutin eller nested procedure. SVAR: Man måste se till att returadressen alltid förblir oförstörd. Det innebär att det innehåll som finns i r31 vid anrop av en subrutin måste finnas kvar i r31 eller kunna placeras i r31 innan man gör returhopp med instruktionen RET. Man kan skydda innehållet i r31 på olika sätt. Det enklaste torde vara att se till att man aldrig ändrar innehållet i r31. Men om man ska anropa en subrutin från en subrutin måste man innan man gör subrutinanrop omplacera innehållet i r31. Det kan man göra på olika sätt och det vanligaste är att kopiera r31 till en stackarea med en PUSH-operation i början av subrutinen och att sedan återställa innehållet i r31 med en POP-operation i slutet av subrutinen innan retur med RET. Assemblerprogrammeraren måste också ha fullständig kontroll över vilka register som används i olika programdelar av anroparen/caller respektive den anropade/callee. Varje subrutin har rätt att förutsätta att register r8-r15 får användas helt fritt dvs att den som anropar en subrutin måste uppträda som om innehåll i register r8-r15 kan förstöras av den anropade subrutinen. Den som anropar en subrutin måste alltså vid behov skydda innehåll i r8-r15 (t.ex. på stacken) under den tid subrutinen exekveras. En subrutin som vill använda register r16-r23 måste skydda och återställa dessa register innan returhopp eftersom det ska förutsättas att en callee (anropare) kan ha använt r16-r23. Vilka krav som gäller för parametervärden i r2-r7 bör/måste framgå av specifikationer för anroparen och den anropade Subrutin med parameteröverföring av värden i register Skriv välkommenterad Nios II assemblerkod för en subrutin, sumv, som adderar två 32-bitars heltal vars värden lagrats i register r4 och r5 innan anropet av sumv. Resultatet av beräkningen ska finnas i register r2 efter returhopp från sumv. Nedan visas hur motsvarande c-liknande programkod ser ut Handkompilera denna kod till assemblerkod för Nios-II int sumv(int x, int y) return (x+y); SVAR: SUMV: ADD r2, r4, r5 # addera r2 <-- r4 + r5 RET # PC <-- r31 (JMP r31 är förbjuden) Lösningsförslag till övning CE_O2, sida 10 (av 12)

11 2.10. Huvudprogram med parameteröverföring av värden i register Skriv välkommenterad Nios II assemblerkod för ett huvudprogram som använder subrutinen sumv, se föregående uppgift, för att addera två heltal. Nedan visas ett exempel på hur ett sådant c-program kan se ut Handkompilera denna kod till assemblerkod för Nios-II int a, b, res; extern int sumv(int par1, int par2) int main() a = 3; b = 4;... /* annat programarbete */ res = sumv (a, b);... return (0); SVAR:.data # placera i data-area.align 2 # på adress delbar med 4 A:.word 0 # reservera plats för A B:.word 0 # reservera plats för B RES:.word 0 # reservera plats för RES.text # placera i program-area.align 2.global main main: MOVIA r16, A # adressen till A finns nu i r16 MOVIA r17, 3 # MOVI r17, 3 fungerar också STW r17, 0(r16)# nu finns värde 3 i A MOVIA r18, B # r16 är ledig och skulle fungera MOVIA r19, 4 # r17 är ledig och skulle fungera STW r19, 0(r18)# nu finns värde 4 i B... MOVIA r20, A # adressen till A finns nu i r20 LDW r4, 0(r20) # nu finns parameter 1 i r4, värdet från A MOVIA r21, B # adressen till B finns nu i r21 LDW r5, 0(r21) # nu finns parameter 2 i r5, värdet från B CALL SUMV # returvärde levereras i r2 MOVIA r22, RES # adressen til RES finns nu i r22 STW r2, 0(r22) # skriv resultatet till minnets plats RES Lösningsförslag till övning CE_O2, sida 11 (av 12)

12 2.11. Subrutin med parameteröverföring av adresser i register int suma(int * x, int * y) return (*x + *y); Handkompilering till assemblerkod för Nios-II: SUMA: LDW r2, 0(r4) # hämta värde till r2 LDW r8, 0(r5) # hämta värde 2 till r8 ADD r2, r2, r8 # addera RET # retur med summan i r Huvudprogram med parameteröverföring av värden i register int a, b, res; extern int sumv(int* par1, int * par2) int main() a = 3; b = 4;... /* annat programarbete */ res = sumv (&a, &b);... return (0); Handkompilering till assemblerkod för Nios-II:.data # placera i data-area.align 2 # på adress delbar med 4 A:.word 0 # reservera plats för A B:.word 0 # reservera plats för B RES:.word 0 # reservera plats för RES.text # placera i program-area.align 2.global main main: MOVIA r16, A # adressen till A finns nu i r16 MOVIA r17, 3 # MOVI r17, 3 fungerar också STW r17, 0(r16)# nu finns värde 3 i A MOVIA r18, B # r16 är ledig och skulle fungera MOVIA r19, 4 # r17 är ledig och skulle fungera STW r19, 0(r18)# nu finns värde 4 i B... MOVIA r4, A # nu finns parameter 1 i r4, adressen till A MOVIA r5, B # nu finns parameter 2 i r5, adressen till B MOVIA r16, SUMA # nu finns adressen till SMA i r16 CALLR r16 # returvärde kommer i r2 MOVIA r16, RES # återanvändning av r16 STW r2, 0(r16) # skriv resultatet till RES i minnet Lösningsförslag till övning CE_O2, sida 12 (av 12)