A basic 2-bit ALU The Von Neuman Model register a 5 bit register b 5 bit 32 Registers 32 bit 32 bit Digitalteknik och Datorarkitektur 5hp MIPS is a Register-toregister architecture ALU OP Föreläsning 5: strängar, arrayer, loopar, if-satser, subrutiner och stacken 14 april 2008 karlmarklund@ituuse register c 5 bit 32 bit 32 bit ALU add addi sub subi seq Anger vilken operation vill vi utföra rd, rs, imm Den generella formen för instruktion i MIPS-assembler op Anger vilket register som innehåller den första operanden Anger vilket register som skall lagra resultatet Anger vilket register som innehåller den andra operanden Det finns ingen subi instruktion eftersom det funkar lika bra med addi och negativ immediate konstant Vi har hittils kollat på dessa instruktioner Varje cell har en unik adress Fyra bytes bildar ett ord (word) om 32 bitar MEMORY Address Content 0xFFFFFFFF 0xFFFFFFFE 0xFFFFFFFD 0xFFFFFFFC 0x00000003 0x00000002 0x00000001 0x00000000 I MIPS består minnet av 2 32 celler Varje cell i minnet kan lagra åtta bitar, dvs en byte MIPS is a Load-Store architecture which means only load and store instructions are allowed to access memory lw sw rt, address rt, address Assemblator-direktiv vi känner till data text word space Address format (register) imm imm(register) label label +/- imm label +/- imm(register) Address computation Content of register Immediate Immediate + content of register Address of label Address of label + /- immediate Address of label +/- (Immediate + content of register) 1
Raden ger den minst signifikanta siffran Kolumnen ger den mest signifikanta siffran Vi ser i tabellen att ASCII-värdet för är Ett direktiv som lagrar en nullterminerad sträng i datasegment STR: data asciiz "abcdefghijklmnopqrstuvxyz" text globl main strings Load Byte: lb la $t0, STR lw $t1, 0($t0) Varje tecken tilldelas ett ASCII-värde, på åtta bitar och kan alltså lagras i en byte ASCII-värdet för ett tecken kan skrivas som ett tvåsiffrigt hexadecimalt tal Åh Va kul ett nytt häftigt direktiv lb lb lb lb $t2, 0($t0) $t3, 1($t0) $t4, 2($t0) $t5, 3($t0) ASCII = American Standard Code for Information Interchange Vår sträng startar på adress Vår sträng startar på adress Kör på skolans SUN-Ray system c 0x63 0x10010002 b 0x62 0x10010001 b 0x62 0x10010001 c 0x63 0x10010002 [] 636261 0x68676665 0x6c6b6a69 0x706f6e6d [0x10010010] 0x74737271 0x79787675 0x0000007a 0x00000000 [] 626364 0x65666768 0x696a6b6c 0x6d6e6f70 [0x10010010] 0x71727374 0x75767778 0x797a0000 0x00000000 x68 c b 0x63 0x62 0x10010002 0x10010001 Little Endian c b 0x63 0x62 0x10010002 0x10010001 Intel x86, använder little endian Skumt Vi lagrar samma sträng och får olika ord? SPARC b c 0x62 0x63 0x10010001 0x10010002 Ett ord adresseras med adressen till den minst signifikanta byten Power PC och SPARC använder big endian Big Endian b c 0x62 0x63 0x10010001 0x10010002 Ett ord adresseras med adressen till den mest signifikanta byten 2
En MIPS-processor kan konfigureras att använda antingen Big Endian eller Little Endian SPIM är en simulator och har valt att använda sama byte-order som den underliggande fysiska maskinen print_string_and_integers Här skriver vi ut en sträng med hjälp av Här skriver vi ut ett heltal med hjälp av data STR: asciiz "Hello world, your lucky number is: " text globl main system call code for print_str address of string to print la $a0, STR system call code for print_int integer to print addi $a0, $zero, 44 SPIM fuskar lite genom att stödja några operativsystems-liknande systemanrop Load Immediate Det går även att klicka på denna ikon Om man känner sig lite vågad behöver man inte steppa sitt program Det går att köra från början till slut I Windows är det inte helt oväntat bara att trycka på F5 Utskriften sker till en konsoll som öppnas i ett eget fönster loops text globl main add $t0, $zero, $zero loop-counter i addi $s0,$zero, 5 loop limit N loop: beq $t0, $s0, done for i = 0(N-1) integer to print Branch on EQual: beq add $a0, $zero, $t0 Om $t0 == $t5, hoppa till system call code for print_int etiketten done Annars fortsätt med nästa instruktion addi $t0, $t0, 1 i ++ j loop done: Jump är av J-typ Exempel på bra kommentarer Vilken typ av instrukton är beq? En R-typ eller en I-typ? Maskinkod: 0x11100006 Hexadecimalt 0x11 0x10 0x00 0x06 Decimalt 1*16 1 + 1 = 17 1*16 1 = 16 0 6*16 0 = 6 Register 8 Register 16 Branch offset 6 Binärt 0001 0001 0001 0000 0000 0000 0000 0110 000100 01000 10000 0000 0000 0000 0110 op rs rt immediate OP-kod = 4 för beq Aha beq är en I-typ 3
if_then_elses Branch Not Equal: bne Viktigt att ge etiketter namn som beskriver vad programet gör data STR_THEN: asciiz "lika!" STR_ELSE: asciiz "olika!" text globl main Tillsammans med bra etiketter blir det enklare att dokumentera sitt program li $t0, 15 a addi $t1, $zero, 15 b if: bne $t0, $t1, else if (a==b) then: system call for print_str la $a0, STR_THEN j end_if else: system call for print_str la $a0, STR_ELSE end_if: arrays data NL: asciiz "\n" SIZE: word 10 ARRAY: word 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 text globl main add $t0, $zero, $zero array index i lw $t2, SIZE loop: beq $t0, $t2, done for e in ARRAY lw $a0, 0($t0) print e print \n la $a0, NL addi $t0, $t0, 1 next element Tusan Nått gick galet! Exception occurred at PC=0x00400034 Bad address in data/stack read: 0x00000000 j loop done: arrays data NL: asciiz "\n" Vi får endast ladda SIZE: word 10 data från datasegmentet ARRAY: word 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 text globl main add $t0, $zero, $zero array index i 0x00000000 ligger helt klart utanför lw $t2, SIZE detta loop: beq $t0, $t2, done for e in ARRAY lw $a0, 0($t0) print e print \n la $a0, NL Vi satt ju $t0 till noll i början försöker addi $t0, $t0, 1 ladda ord från next element j loop adress noll i minnet och där ligger ju inte vår array done: arrays För att det skall fungera måste vi göra följande ändringar Shif Left Logical: sll Att multiplicera med 4 är samma sak som att shifta två bitar till vänster data NL: asciiz "\n" SIZE: word 10 ARRAY: word 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 text globl main add $t0, $zero, $zero array index i la $t1, ARRAY lw $t2, SIZE loop: beq $t0, $t2, done for e in ARRAY sll $t4, $t0, 2 a = 4*i add $t3, $t1, $t4 p = ARRAY + a lw $a0, 0($t3) print ARRAY[i] print \n la $a0, NL addi $t0, $t0, 1 next element j loop done: 4
array_of_strings Börjar att deklarera tre strängar i datasegmentet Varje etikett motsvarar nu startadressen för en sträng Largra dessa startadresser i datasegementet, dvs skapa en array av adresser till strängar data STR_1: asciiz "The sum of " STR_2: asciiz " and " STR_3: asciiz " is " ARRAY_OF_STRINGS: Each element is an address to a string word STR_1, STR_2, STR_3 0x10010010 0x10010014 Etiketten ARRAY_OF_STRINGS har adress 0x10010018 På denna plats lagras adressen till STR_1 array_of_strings (text segment part one) text globl main Just for fun, get the address of label "ARRAY_OF_STRINGS": la $t0, ARRAY_OF_STRINGS addi $a1, $zero, 3 a addi $a2, $zero, 11 b Must copy $a0 since the s used later needs $a0 Hämta adressen till STR_1 The sum of add $t0, $a0, $zero Print "The sum of " lw $a0, ARRAY_OF_STRINGS Hämta adressen till STR_2 and Print the value of a add $a0, $zero, $a1 Print " and " lw $a0, ARRAY_OF_STRINGS + 4 Andra elementet i ARRAY_OF_STIRINGS ligger fyra byte längre fram array_of_strings (text segment part two) Hämta adressen till STR_3 is Print the value of b add $a0, $zero, $a2 Print " is " lw $a0, ARRAY_OF_STRINGS + 8 Print the sum a + b add $a0, $a1, $a2 Tredje elementet i ARRAY_OF_STIRINGS ligger åtta byte längre fram ASCII( T ) = 0x54 Strängen termineras av 0x00 (NUL) ASCII( h ) = 0x68 ASCII( e ) = 0x65 m u s f o d n a Etiketten ARRAY_OF_STRINGS har adress 0x10010018 ARRAY_OF_STRINGS + 4 5
Attans svårt att få grepp på det här problemet Det blir enklare att lösa problem om man delar upp dem i delproblem Äh kom igen nu! Vi kör med taktiken söndra och härska så skall ni se att det löser sig Vi vill även kunna skriva kod som går att återanvända på ett enkelt sätt Det är dags att lära oss skriva subrutiner subroutines Subrutiner tar alltid indata i $aregister, eller om de inte räcker till på stacken Jump Register data STR: asciiz "The sum is " Vi börjar alltid med att NL: asciiz "\n END: asciiz "The End\n" dokumentera våra subrutiner text DESCRIPTION: Given two number A and B, print out the sum of these numbers INPUT: $a0 - number A, $a1 - number B OUTPUT: $v0 - the sum of A and B sum: Must copy $a0(a) since the s used later needs $a0 add $t0, $a0, $zero Print "The sum is " la $a0, STR Print the sum of A and B Print Sum = A + B add $a0, $t0, $a1 Print "\n" la $a0, NL Return Sum add $v0, $zero, $a0 Subrutiner ger alltid utdata i $v-register, eller om de inte räcker till, på stacken Avslutar alltid med för att hoppa tillbaka till instruktionen direkt efter den anropande jal (Jump And Link) subroutines (main) Vi anropar sedan subrutinen med jal vilket kommer att sparar returadressen i Ytterligare ett anrop till subrutinen sum addi $a0, $zero, 3 addi $a1, $zero, 11 jal sum addi $a0, $zero, 7 addi $a2, $zero, 99 jal sum Print "The End" la $a0, END För att anropa en subrutin måste vi se till att ge korrekt indata i $a-registren Precis som det är en väldans dålig idé att försöka ta en tallrik i mitten av stapeln så vore det hemskt dumt om vi slarvade bort någon returadress innan vi behöver den När vi kör programmet får vi ett oändligt antal The End Dett beror på att innehåller adressen till instruktionen direkt efter den sista Jump And Link Det är därför vi använder oss av en stack En stack är en datastruktur som endast tillåter två operationer PUSH för att lägga något överst på stacken POP för att läsa och ta bort det som ligger överst på stacken 6
Stacken växer neråt: från höga adresser till låga Detta för att inte krocka med det övriga data-segmentet Till vår hjälp har vi det speciella registret $sp vars innehåll (adress) definierar toppen på stacken $sp PUSH register $t0 addi $sp, $sp, -4 sw $t0, 0($sp) POP value on top of stack to $t0 subroutines (main) För att det skall fungera måste vi spara undan returadressen, ett utmärkt ställe för detta är stacken Nu kan vi återställa genom att poppa tillbaka returadressen från stacken globl main Push return address addi $sp, $sp, -4 sw, 0($sp) addi $a0, $zero, 3 addi $a1, $zero, 11 jal sum addi $a0, $zero, 7 addi $a2, $zero, 99 jal sum Print "The End" la $a0, END lw $t0, 0($sp) addi $sp, $sp, 4 Pop return address lw, 0($sp) addi $sp, $sp, 4 När vi skriver subrutiner som i sin tur anropar andra subrutiner eller sig själv (rekursion) måste vi pusha och poppa returadressen på stacken Kom ihåg att detta gäller även för main som också är en subrutin som anropas av det lilla operativsystemet SPIM använder Frid och fröjd! För subrutiner som inte anropar någon subrutin, så kallde lövprocedurer, behöver vi inte spara returadressen på stacken Registerkonventionen Indata till subrutiner lagras i $a-register Om $a-registren inte räcker till tas övrig indata på stacken Utdata från subrutiner lagras i $v-register Om $v-registren inte räcker till ges övrig utdata på stacken subroutine_and_array_of_stringss data STR_a1: asciiz "The sum of " STR_a2: asciiz " and " STR_a3: asciiz " is " Två arrayer av strängar Tillfälliga värden lagras i $t-register STR_b1: asciiz "These two numbers " STR_b2: asciiz " and " STR_b3: asciiz " sum up to " NL: asciiz "\n" För sådant som man vill skall "överleva" anrop till subrutiner används $s-register Om en subrutin i sin tur behöver använda något $s-register måste värdet i detta register vara oförändrat efter återhopp till anroparen Ett bra sätt är att först pusha innhållet i registet på stacken, använda det, och sedan poppa tillbaka det gamla värdet Konvention: överenskommelse, en godtycklig men hävdvunnen eller allmänt erkänd ordning eller praxis som följs då inget särskilt talar där emot ARRAY_a: ["The sum of ", " and ", " is "] word STR_a1, STR_a2, STR_a3 ARRAY_b: ["These two numbers ", " and ", " sum up to "] word STR_b1, STR_b2, STR_b3 7
subroutine_and_array_of_stringss DESCRIPTION: Given two number A and B, print out the sum of these numbers INPUT: $a0 - Address to an array of three strings $a1 - a number A $a2 - a number B EXAMPLE: $a0 = ["The sum of ", " and ", " is "] $a1 = 3 $a2 = 15 This will result in the following being printed on the console: "The sum of 3 and 15 is 18" print_sum: subroutine_and_array_of_stringss (main) addi $sp, $sp, -4 Push return address sw, 0($sp) la $a0, ARRAY_a addi $a1, $zero, 3 addi $a2, $zero, 11 jal print_sum la $a0, ARRAY_b addi $a1, $zero, 7 addi $a2, $zero, 99 jal print_sum lw, 0($sp) Pop return address addi $sp, $sp, 4 subroutine_and_array_of_stringss DESCRIPTION: Given two number A and B, print out the sum of these numbers INPUT: $a0 - Address to an array of three strings $a1 - a number A $a2 - a number B EXAMPLE: $a0 = ["The sum of ", " and ", " is "] $a1 = 3 $a2 = 15 This will result in the following being printed on the console: "The sum of 3 and 15 is 18" print_sum:? Del av inlämningsuppgift? Här väljer vi ett input element Här kan vi ändra hur många bitar vi vill ha I detta fall vill vi ha 8 bitar Här väljer vi verktyget för att dra ledningar För att dela upp ledningen i 8 stycken, dvs en per bit använder vi en splitter Vi måste ange hur många bitar som kommer in, i detta fall 8 För att det skall funka måste vi även sätta Fan Out till minst 8 The fanout is simply the number of inputs that can be connected to an output before the current required by the inputs exceeds the current that can be delivered by the output while still maintaining correct logic levels 8
Under Project kan vi lägga till kretsar (Add Circuit) Vi lägger till en som vi döper till xor Konstuerar funktionen XOR med hjälp av AND-, OR- och NOT grindar Nu kan vi dra ledningar och koppla in output element på vanligt sätt Genom att dubbelklicka på main kommer vi tillbaka till vår första krets Logisim kommer med olika färdiga kretsar, bland annat en 32-bits adderare Om vi klickar en gång på xor kan vi nu lägga till denna krets som en komponent i main Bara att testa! Först gör ni en 1-bits adderare I dag har vi lärt oss hantera strängar i MIPS och SPIM Vi har även lärt oss mer om little- och big endian som ni använder för att bygga en 8- bits adderare som ni använder för bygga den slutliga 32-bits adderaren En 32-bits adderare som ni bygger sjäva i Logisim En sträng är alltså inget annat än en array av bytes med ASCII-värden Hur arrayer fungerar har vi oxå kollat på I MIPS kan vi nu skriva loopar, if-satser och subrutiner Till och med arrayer av strängar har vi kikat på 9