Chapter 6 Digital Design and Computer Architecture, 2nd Edition

Prezentacja na temat: "Chapter 6 Digital Design and Computer Architecture, 2nd Edition"— Zapis prezentacji:

1 Chapter 6 Digital Design and Computer Architecture, 2nd Edition
David Money Harris and Sarah L. Harris

2 Rozdział 6 :: Tematyka Wstęp Język Asembler Język maszynowy
Programowanie Tryby adresowania Światła, Kamera, Akcja: Kompilacja, Asemblacja, & Ładowanie Przerwania

3 Wstęp Przeskoczenie o kilka poziomów abstrakcji
Architektura: jak programista widzi komputer Zdefiniowane instrukcje & lokalizacja operandu(operand locations) Mikroarchitektura: jak zaimplementować architektur w sprzęcie(kolejne wykłady)

4 Język Asembler Instrukcje: komendy w języku komputera
Język asembler: instrukcje w formacie czytelnym Język maszynowy: format czytelny dla komputera (1 i 0) Architektura MIPS: Stworzona przez John Hennessy i jego kolegów w Stanford w latach 80. Wykorzystywana w wielu komercyjnych systemach np. Silicon Graphics, Nintendo i Cisco Kiedy pozna się jedną architekturę, wtedy łatwo nauczyć się innych.

5 John Hennessy Rektor Stanford Uniwersytetu
Profesor Wydziału Inżynierii Elektrycznej i Informatyki w Stanford od 1977 Wynalazł komputer o zmniejszonej liczbie instrukcji (RISC) z Davidem Pattersonem Stworzył architekturę MIPS w Stanford w 1984 i założył MIPS Computer Systems W 2004, sprzedano ponad 300 millionów MIPS mikroprocesorów

6 Zasady projektowania architektury
Zasadnicze reguły projektowe stworzone przez Hennessy i Pattersona: Prostota sprzyja regularności Wykonuj szybko powszechne przypadki Mniejsze jest szybsze Dobre projektowanie wymaga dobrych kompromisów

7 Instrukcje: Dodawanie
add: mnemonik wskazujący operację do wykonania b, c: źródłowe operandy ( na których operacja jest wykonywana) a: operand docelowy ( do którego jest zapisywany wynik) Kod C a = b + c; Kod asemblera MIPS add a, b, c

8 Instrukcje: Odejmowanie
Podobny do dodawania – zmiana tylko mnemonika sub: mnemonik b, c: źródłowe operandy a: docelowy operand Kod C a = b - c; Kod asemblera MIPS sub a, b, c

9 Pierwsza zasada projektowa
Prostota sprzyja regularności Zwięzły format instrukcji Takie same operandy (dwa źródłowe i jeden docelowy) Łatwiej zakodować i zaimplementować w sprzęcie

10 Wielokrotność instrukcji
Bardziej złożony kod jest realizowany przez kilka instrukcji MIPS. Kod C a = b + c - d; Kod asemblera MIPS add t, b, c # t = b + c sub a, t, d # a = t - d

11 Druga zasada projektowa
Wykonuj szybko powszechne przypadki MIPS zawiera tylko proste powszechnie wykorzystywane instrukcje Sprzęt do dekodowania i wykonywania instrukcji może być prosty, mały i szybki Bardziej skomplikowane instrukcje (które nie są powszechnie wykorzystywane) są wykonywane z wykorzystaniem kilku prostych instrukcji MIPS jest reduced instruction set computer (RISC), z małą liczbą prostych instrukcji Inne architektury, takie jak Intel x86, są complex instruction set computers (CISC)

12 Operandy Położenie operanda: fizyczne umiejscowienie w komputerze
Rejestry Pamięć Stałe (zwane bezpośrednimi)

13 Operandy: Rejestry MIPS ma 32 32-bitowe rejestry
Rejestry są szybsze niż pamięć MIPS zwana “32-bitową architekturą” ponieważ operuje na 32-bitowych danych

14 Trzecia zasada projektowa
Mniejsze jest szybsze MIPS zawiera tylko niewielką liczbę rejestrów

15 MIPS zbiór rejestrów Nazwa Numer rejestru Wykorzystanie $0
Stała wartość 0 $at 1 asembler tymczasowy $v0-$v1 2-3 Zwraca wartość funkcji $a0-$a3 4-7 Argumenty funkcji $t0-$t7 8-15 tymczasowe $s0-$s7 16-23 Zapisane zmienne $t8-$t9 24-25 Więcej tymczasowych $k0-$k1 26-27 OS tymczasowe $gp 28 Wskaźnik globalny $sp 29 Wskaźnik stosu $fp 30 Wskaźnik ramkiframe $ra 31 Adres powrotu funkcji

16 Operandy: Rejestry Registery: Registery specjalnego przeznaczenia:
$ przed nazwą Np: $0, “rejestr zero”, “dollar zero” Registery specjalnego przeznaczenia: $0 zawsze przechowuje wartość 0. Rejestry zapisujące, $s0-$s7, wykorzystywane do przechowywania zmiennych tymczasowe rejestry, $t0 - $t9, wykorzystywane do przechowywania pośrednich wartości podczas wiekszych obliczeń Pozostałe rejestry w dalszej części

17 Instrukcje z rejestrami
Powrót do instrukcji add Kod C a = b + c Kod asemblera MIPS # $s0 = a, $s1 = b, $s2 = c add $s0, $s1, $s2

18 Operandy: Pamięć Za dużo danych do przechowania tylko w 32 rejestrach
Przechowywanie danych w pamięci Pamięć jest duża ale wolna Często wykorzystywane zmienne trzymamy w rejestrach

19 Word-Adresowalna Pamięć
Każda 32-bitowe słowo danych ma unikalny adres Uwaga: MIPS wykorzystuje bajtowo-adresowalną pamięć, o tym w dalszej części.

20 Odczytanie z Word-Adresowalnej pamięci
Odczyt z pamięci load Mnemonik: load word (lw) Format: lw $s0, 5($t1) Obliczenie adresu: dodać bazowy adres ($t1) do ofsetu (5) adres = ($t1 + 5) Wynik: $s0 przechowuje wartość spod adresu ($t1 + 5) Dowolny rejestr może być użyty jako bazowy adres

21 Odczyt Word-Adresowalnej pamięci
Np: odczytaj słowo danych z pamięci o adresie 1 do $s3 adres = ($0 + 1) = 1 $s3 = 0xF2F1AC07 po załadowaniu Asembler Kod lw $s3, 1($0) # read memory word 1 into $s3

22 Zapis Word-adresowalnej pamięci
Zapis do pamięci: store Mnemonic: store word (sw)

23 Zapis Word-Adresowalnej pamięci
Np: Zapisz (store) wartość z $t4 do adresu pamięci 7 dodaj adres bazowe ($0) do ofsetu (0x7) adres: ($0 + 0x7) = 7 Ofset może być zapisany dziesiętnie (domyślnie) albo hexadecymalnie Asembler kod sw $t4, 0x7($0) # write the value in $t4 # to memory word 7

24 Byte-adresowalna pamięć
Każda bajtowa dana ma unikalny adres Odczyt/zapis słów albo pojedynczych bajtów: load byte (lb) and store byte (sb) 32-bit word = 4 bajty, więc słowo adresowe jest zwiększane co 4

25 Odczytanie Byte-Adresowej Pamięci
Adres słowa pamięci musi być mnożona przez 4. Np. Adres słowa pamięci 2 jest 2 × 4 = 8 Adres słowa pamięci 10 jest 10 × 4 = 40 (0x28) MIPS jest adresowana bajtowo, a nie słowami

26 Odczytanie Byte-Adresowej Pamięci
Przykład: Odczytanie słowa danych z pamięci o adresie 4 do $s3. $s3 przechowuje wartość0xF2F1AC07 po załadowaniu Kod asemblera MIPS lw $s3, 4($0) # read word at address 4 into $s3

27 Zapis Byte-adresowej pamięci
Przykład: przechowuje wartość z rejestru$t7 do pamięci pod adresem 0x2C (44) Kod asemblera MIPS sw $t7, 44($0) # write $t7 into address 44

28 Big-Endian & Little-Endian Pamięć
Jak są ponumerowane bajty w słowie? Little-endian (Liliputy): bajty numerowane są od najmniej znaczącego bajtu Big-endian (Blefuski): bajty numerowane od najbardziej znaczącego Słowo adresowe jest takie samo dla big- i little-endian

29 Big-Endian & Little-Endian Pamięć
Jonathan Swift’s Podróże Guliwera: Little-Endians rozłupywali jajka mniejszym końcem a Big-Endians rozłupywali jajka na większym końcu Nie ma znaczenia który typ adresacji jest używany – z wyjątkiem kiedy dwa systemy muszą wymienić dane!

30 Przykład Big-Endian & Little-Endian Example
Załóżmy że $t0 przechowuje wartość 0x Po wykonaniu poniższego kodu na systemie big-endian, jaka wartość jest w $s0? W systemie little-endian? sw $t0, 0($0) lb $s0, 1($0)

31 Przykład Big-Endian & Little-Endian
Załóżmy że $t0 przechowuje wartość 0x Po wykonaniu poniższego kodu na systemie big-endian, jaka wartość jest w $s0? W systemie little-endian? sw $t0, 0($0) lb $s0, 1($0) Big-endian: 0x Little-endian: 0x

32 Czwarta zasada projektowa
Dobre projektowanie wymaga dobrych kompromisów Podobny format instrukcji zapewnia uniwersalność add, sub: wykorzystuje 3 operandy rejestrów lw, sw: wykorzystuje 2 operandy rejestrów i stałą Mała liczba formatów instrukcji po dodaniu 1-3 zasad projektowania (prostota sprzyja regularności i mały jest szybszy).

33 Operandy: Stałe/Bezpośrednie
lw i sw wykorzystują stałą albo bezpośrednią bezpośrednia dostępna z instrukcji liczba 16-bitowa z uzupełnieniem do dwóch addi: dodaje bezpośrednio Odejmowanie bezpośrednie (subi) czy jest potrzebne? Kod C a = a + 4; b = a – 12; Kod asemblera MIPS # $s0 = a, $s1 = b addi $s0, $s0, 4 addi $s1, $s0, -12

34 Kod maszynowy Binarna reprezentacja instrukcji
Komputery rozumieją tylko 0 i 1 32-bitowe instrukcje Uoraszczanie wymusza regularność : 32-bitowe dane & instrukcje 3 formaty instrukcji: R-Typ: operandy rejestrowe I-Typ: operandy bezpośrednie J-Typ: skok (wyjaśnione w dalszej części)

35 R-Typ Register-typ 3 operandy rejestrowe: Inne pola:
rs, rt: rejestry źródłowe rd: rejestr docelowy Inne pola: op: kod operacji albo opcode (0 dla R-typu instrukcji) funct: funkcja z opcode, mówi komputerowi jaka operacja ma zostać wykonana shamt: liczba przesunięcia dla instrukcji przesunięcia, w przeciwnym przypadku ustawiane na 0

36 Przykład R-Typu Note kolejność rejestrów w kodzie asemblera:
add rd, rs, rt

37 I-Typ Bezpośrednie-typ 3 operandy: Pozostałe pola:
rs, rt: rejestry operandów imm: bezpośrednia 16-bitowa w kodzie uzupełnienia do dwóch Pozostałe pola: op: opcode Upraszczanie wymusza regularność: wszystkie instrukcje mają opcode Rodzaj operacji jest są zdefiniowany przez opcode

38 Przykład I-Typ Note różna kolejność rejestrów w asemblerze i kodzie maszynowym: addi rt, rs, imm lw rt, imm(rs) sw rt, imm(rs)

39 Język maszynowy : J-Typ
Jump-typ 26-bit adres operand (addr) Wykorzystywana do skosku (j)

40 Podsumowanie: Formaty instrukcji

41 Siła zapisanego programu
32-bitowe instrukcje & dane przechowane w pamięci Sekwencyjność instrukcji: brak różnicy pomiędzy dwoma aplikacjami W celu uruchomienia programu: Nie ma potrzeby pisania go ponownie Po prostu nowy program jest przechowywany w pamięci Wykonanie programu: Procesor „chwyta” (czyta) sekwencyjnie instrukcje z pamięci Procesor wykonuje określone operacje

42 Zapisany program Program
Licznik programu (PC): przechowuje numer aktualnie wykonywanej instrukcji

43 Interpretacja kodu maszynowego
Zaczynamy od opcode: wtedy wiadomo jak przetworzyć pozostałą część Jeśli opcode jest 0 Instrukcja R-typu Bity funkcji określają jaka operacja W przeciwnym przypadku opcode określa typ operacji

44 Programowanie Języki wysokiego poziomu:
e.g., C, Java, Python Napisane na wyższym poziomie abstrakcji Oprogramowanie wysokiego-poziomu posiada: instrukcje if/else pętle for pętle while tablice Wywołanie funkcji

45 Ada Lovelace, 1815-1852 Napisała pierwszy program komputerowy
Jej program obliczał liczby Bernoulliego na analitycznym silniku Charlesa Babbage Była córką poety Lord Byron

46 Instrukcje logiczne and, or, xor, nor andi, ori, xori
and: przydatne do maskowania bitów Maskowanie wartości najmniej znaczącego bajtu 0xF234012F AND 0x000000FF = 0x F or: przydatne do łączenia pól bitowych Połącz 0xF z 0x000012BC: 0xF OR 0x000012BC = 0xF23412BC nor: przydatne do inwersji bitów: A NOR $0 = NOT A andi, ori, xori 16-bitowa bezpośrednia uzupełniana zerami (bit znaku nie) nori jest niepotrzebna

47 Instrukcje logiczne Przykład 1

48 Instrukcje logiczne przykład 1

49 Instrukcje logiczne przykład 2

50 Instrukcje logiczne przykład 2

51 Instrukcje przesunięcia
sll: przesunięcie logiczne w lewo Przykład: sll $t0, $t1, 5 # $t0 <= $t1 << 5 srl: przesunięcie logiczne w prawo Przykład: srl $t0, $t1, 5 # $t0 <= $t1 >> 5 sra: przesunięcie arytmetyczne w prawo Przykład: sra $t0, $t1, 5 # $t0 <= $t1 >>> 5

52 Instrukcje zmiennego przesunięcia
sllv: zmienne przesunięcie logiczne w lewo Przykład: sllv $t0, $t1, $t2 # $t0 <= $t1 << $t2 srlv: zmienne przesunięcie logiczne w prawo Przykład: srlv $t0, $t1, $t2 # $t0 <= $t1 >> $t2 srav: zmienne przesunięcie arytmetyczne w prawo Przykład: srav $t0, $t1, $t2 # $t0 <= $t1 >>> $t2

53 Instrukcja przesunięcia

54 Generowanie stałych 16-bitowe stałe wykorzystując addi:
32-bitowe stałe wykorzystując ładowanie stałej na 32 górnych bitach (lui) i ori: C Code // int jest 32-bitowym słowem //ze znakiem int a = 0x4f3c; MIPS assembly code # $s0 = a addi $s0, $0, 0x4f3c C Code int a = 0xFEDC8765; MIPS assembly code # $s0 = a lui $s0, 0xFEDC ori $s0, $s0, 0x8765

55 Mnożenie, Dzielenie Specialne rejestry: lo, hi
32 × 32 mnożenie, 64 bitowy wynik mult $s0, $s1 Wynik w {hi, lo} 32-bitowe dzielenie, 32-bitowy iloraz, reszta div $s0, $s1 Mnożnik w lo Reszta w hi Przesuwa z lo/hi do specjalnych rejestrów mflo $s2 mfhi $s3

56 Rozgałęziania Wykonywanie instrukcji nie w sposób sekwencyjny
Rodzaje rozgałęzień: Warunkowy Rozgałęzij jeśli jest równe (beq) Rozgałęzij jeśli nie jest równe (bne) Bezwarunkowy skok (j) skok rejestrowy (jr) skok i link (jal)

57 Podsumowanie: Zapisany program

58 Warunkowe rozgałęzienie (beq)
# MIPS assembly addi $s0, $0, # $s0 = = 4 addi $s1, $0, # $s1 = = 1 sll $s1, $s1, 2 # $s1 = 1 << 2 = 4 beq $s0, $s1, target # rozgałęzienie jest wykonane addi $s1, $s1, # nie wykonana sub $s1, $s1, $s0 # nie wykonana target: # Etykieta add $s1, $s1, $s0 # $s1 = = 8 Etykieta wskazuje lokalizacje instrukcji. Nie mogą być użyte słowa zastrzeżone i musi zakończyć się dwukropkiem (:) .

59 Rozgałęzienie nie wykonane (bne)
# MIPS assembly addi $s0, $0, # $s0 = = 4 addi $s1, $0, # $s1 = = 1 sll $s1, $s1, # $s1 = 1 << 2 = 4 bne $s0, $s1, target # brak wykonania rozgałęzienia addi $s1, $s1, # $s1 = = 5 sub $s1, $s1, $s0 # $s1 = 5 – 4 = 1 target: add $s1, $s1, $s0 # $s1 = = 5

60 Bezwarunkowy skok (j) # MIPS assembly addi $s0, $0, 4 # $s0 = 4
j target # skok do target sra $s1, $s1, 2 # nie wykona się addi $s1, $s1, 1 # nie wykona się sub $s1, $s1, $s0 # nie wykona się target: add $s1, $s1, $s0 # $s1 = = 5

61 Bezwarunkowy skok (jr)
# MIPS assembly 0x addi $s0, $0, 0x2010 0x jr $s0 0x addi $s1, $0, 1 0x C sra $s1, $s1, 2 0x lw $s3, 44($s1) jr jest instrukcją typu R.

62 Konstrukcje kodu wysokiego poziomu
Instrukcje if Instrukcje if/else Pętle while Pętle for

63 Instrukcja If C Code MIPS assembly code # $s0 = f, $s1 = g, $s2 = h
if (i == j) f = g + h; f = f – i; MIPS assembly code # $s0 = f, $s1 = g, $s2 = h # $s3 = i, $s4 = j

64 Instrukcja If C Code MIPS assembly code
if (i == j) f = g + h; f = f – i; MIPS assembly code # $s0 = f, $s1 = g, $s2 = h # $s3 = i, $s4 = j bne $s3, $s4, L1 add $s0, $s1, $s2 L1: sub $s0, $s0, $s3 W asemblerze mamy przeciwny przypadek (i != j) niż w kodzie wysokiego poziomu (i == j)

65 Instrukcja If/Else C Code MIPS assembly code if (i == j) f = g + h;
f = f – i; MIPS assembly code

66 Instrukcja If/Else C Code MIPS assembly code if (i == j) f = g + h;
f = f – i; MIPS assembly code # $s0 = f, $s1 = g, $s2 = h # $s3 = i, $s4 = j bne $s3, $s4, L1 add $s0, $s1, $s2 j done L1: sub $s0, $s0, $s3 done:

67 Pętle While C Code MIPS assembly code
// oblicza potęgę // x takiego wyrażenia 2x = 128 int pow = 1; int x = 0; while (pow != 128) { pow = pow * 2; x = x + 1; } MIPS assembly code W asemblerze mamy przeciwny przypadek (pow == 128) niż w kodzie wysokiego poziomu (pow != 128).

68 Pętle While C Code MIPS assembly code
// oblicza potęgę // x takiego wyrażenia 2x = 128 int pow = 1; int x = 0; while (pow != 128) { pow = pow * 2; x = x + 1; } MIPS assembly code # $s0 = pow, $s1 = x addi $s0, $0, 1 add $s1, $0, $0 addi $t0, $0, 128 while: beq $s0, $t0, done sll $s0, $s0, 1 addi $s1, $s1, 1 j while done: W asemblerze mamy przeciwny przypadek (pow == 128) niż w kodzie wysokiego poziomu (pow != 128).

69 Pętle For for (inicjalizacja; warunek; operacja pętli)
instrukcja initialization: wykonuje się przed rozpoczęciem pętli condition: jest sprawdzany na początku każdej iteracji operacja pętli: wykonuje się na końcu każdej iteracji instrukcja: wykonuje się każdorazowo jeśli warunek jest spełniony

70 Pętle For Kod wysokiego poziomu MIPS assembly code
// dodawanie liczb od 0 do 9 int sum = 0; int i; for (i=0; i!=10; i = i+1) { sum = sum + i; } MIPS assembly code # $s0 = i, $s1 = sum

71 Pętle For C Code MIPS assembly code // dodawanie liczb od 0 do 9
int sum = 0; int i; for (i=0; i!=10; i = i+1) { sum = sum + i; } MIPS assembly code # $s0 = i, $s1 = sum addi $s1, $0, 0 add $s0, $0, $0 addi $t0, $0, 10 for: beq $s0, $t0, done add $s1, $s1, $s0 addi $s0, $s0, 1 j for done:

72 Porównanie mniejsze niż
C Code // dodawanie potegi 2 od 1 do 100 int sum = 0; int i; for (i=1; i < 101; i = i*2) { sum = sum + i; } MIPS assembly code

73 Porównanie mniejsze niż
MIPS assembly code # $s0 = i, $s1 = sum addi $s1, $0, 0 addi $s0, $0, 1 addi $t0, $0, 101 loop: slt $t1, $s0, $t0 beq $t1, $0, done add $s1, $s1, $s0 sll $s0, $s0, 1 j loop done: C Code // dodawanie potegi 2 od 1 do 100 int sum = 0; int i; for (i=1; i < 101; i = i*2) { sum = sum + i; } $t1 = 1 if i < 101

74 Tablice Dostęp do dużej liczby podobnych danych
Index: dostęp do każdego elementu Size: liczba elementów

75 Tablice 5-elementowa tablica
Adres bazowy = 0x (adres pierwszego elementu, array[0]) Pierwszy krok dostępu do tablicy: załadować adres bazowy do rejestru

76 Dostęp do tablic // C Code int array[5]; array[0] = array[0] * 2; array[1] = array[1] * 2;

77 Dostęp do tablicy // C Code int array[5]; array[0] = array[0] * 2; array[1] = array[1] * 2; # MIPS assembly code # $s0 = adres bazowy tablicy lui $s0, 0x1234 # 0x1234 w wyższej połowie $s0 ori $s0, $s0, 0x8000 # 0x8000 w niższej połowie $s0 lw $t1, 0($s0) # $t1 = array[0] sll $t1, $t1, 1 # $t1 = $t1 * 2 sw $t1, 0($s0) # array[0] = $t1 lw $t1, 4($s0) # $t1 = array[1] sw $t1, 4($s0) # array[1] = $t1

78 Tablice wykorzystujące pętle
// C Code int array[1000]; int i; for (i=0; i < 1000; i = i + 1) array[i] = array[i] * 8; # MIPS assembly code # $s0 = adres bazowy tablicy, $s1 = i

79 Tablice wykorzystujące tablice
# MIPS assembly code # $s0 = array base address, $s1 = i # initialization code lui $s0, 0x23B8 # $s0 = 0x23B80000 ori $s0, $s0, 0xF000 # $s0 = 0x23B8F000 addi $s1, $0, 0 # i = 0 addi $t2, $0, 1000 # $t2 = 1000 loop: slt $t0, $s1, $t2 # i < 1000? beq $t0, $0, done jeśli nie to wtedy sll $t0, $s1, 2 # $t0 = i * 4 (byte offset) add $t0, $t0, $s0 # adres array[i] lw $t1, 0($t0) # $t1 = array[i] sll $t1, $t1, 3 # $t1 = array[i] * 8 sw $t1, 0($t0) # array[i] = array[i] * 8 addi $s1, $s1, 1 # i = i + 1 j loop # repeat done:

80 Kody ASCII Każdy znak ma unikalną wartość
American Standard Code for Information Interchange Każdy znak ma unikalną wartość Np., S = 0x53, a = 0x61, A = 0x41 Małe litery i duże różnią się o 0x20 (32)

81 Lista znaków ASCII

82 Wywołanie funkcji Caller: wywołująca funkcja(w tym przypadku, main)
Callee: wywoływana funkcja (w tym przypadku , sum) C Code void main() { int y; y = sum(42, 7); ... } int sum(int a, int b) return (a + b);

83 Konwencja Funkcji Caller: Callee: przekazuje argumenty do callee
wykonuje skok do callee Callee: wykonuje funkcje zwraca wynik do caller Wraca do punktu wywołania nie może nadpisywać rejestrów albo pamięci wykorzystywanych przez caller

84 MIPS konwencje funkcji Conventions
Wywołanie funkcji: skok i link (jal) Powrót z funkcji: skok pod adres rejestru (jr) Argumenty: $a0 - $a3 Zwracana wartość: $v0

85 Wywołanie funkcji C Code MIPS assembly code
int main() { simple(); a = b + c; } void simple() { return; MIPS assembly code 0x main: jal simple 0x add $s0, $s1, $s2 ... 0x simple: jr $ra void znaczy że nie jest zwracana wartość

86 Wywołanie funkcji C Code MIPS assembly code jal: skok do simple
int main() { simple(); a = b + c; } void simple() { return; MIPS assembly code 0x main: jal simple 0x add $s0, $s1, $s2 ... 0x simple: jr $ra jal: skok do simple $ra = PC + 4 = 0x jr $ra: skok pod adres $ra (0x )

87 Argumenty wejściowe & Zwracanie wartości
MIPS konwencja: Wartości argumentów: $a0 - $a3 Zwracana wartość: $v0

88 Argumenty wejściowe & Zwracanie wartości
C Code int main() { int y; ... y = diffofsums(2, 3, 4, 5); // 4 argumenty } int diffofsums(int f, int g, int h, int i) int result; result = (f + g) - (h + i); return result; // zwracana wartość

89 Argumenty wejściowe & Zwracanie wartości
MIPS assembly code # $s0 = y main: ... addi $a0, $0, 2 # argument 0 = 2 addi $a1, $0, 3 # argument 1 = 3 addi $a2, $0, 4 # argument 2 = 4 addi $a3, $0, 5 # argument 3 = 5 jal diffofsums # call Function add $s0, $v0, $0 # y = returned value # $s0 = result diffofsums: add $t0, $a0, $a1 # $t0 = f + g add $t1, $a2, $a3 # $t1 = h + i sub $s0, $t0, $t1 # result = (f + g) - (h + i) add $v0, $s0, $0 # put return value in $v0 jr $ra # return to caller

90 Argumenty wejściowe & Zwracanie wartości
MIPS assembly code # $s0 = result diffofsums: add $t0, $a0, $a1 # $t0 = f + g add $t1, $a2, $a3 # $t1 = h + i sub $s0, $t0, $t1 # result = (f + g) - (h + i) add $v0, $s0, $0 # put return value in $v0 jr $ra # return to caller diffofsums nadpisuje 3 registery: $t0, $t1, $s0 diffofsums może używać stosu do tymczasowego przechowywania stanu rejestru

91 Stos Pamięć wykorzystywana do tymczasowego przechowywania zmiennych
Jak stos talerzy, kolejka last-in-first-out (LIFO) Rozwija się: wykorzystuje więcej pamięci, kiedy potrzeba zajmuje więcej miejsca Zakontraktowanie: wykorzystuje mniej pamięci kiedy nie jest potrzebna

92 Stos Rośnie w dół (od większych do mniejszych adresów pamięci)
Wskaźnik stosu: $sp wskazuje na szczyt stosu

93 W jaki sposób funkcje wykorzystują stos
Wywoływane funkcje nie mogą powodować zamazywania rejestrów Ale diffofsums nadpisuje 3 rejestry: $t0, $t1, $s0 # MIPS assembly # $s0 = result diffofsums: add $t0, $a0, $a1 # $t0 = f + g add $t1, $a2, $a3 # $t1 = h + i sub $s0, $t0, $t1 # result = (f + g) - (h + i) add $v0, $s0, $0 # put return value in $v0 jr $ra # return to caller

94 Przechowywanie stanu rejestru na stosie
# $s0 = result diffofsums: addi $sp, $sp, -12 # make space on stack # to store 3 registers sw $s0, 8($sp) # save $s0 on stack sw $t0, 4($sp) # save $t0 on stack sw $t1, 0($sp) # save $t1 on stack add $t0, $a0, $a1 # $t0 = f + g add $t1, $a2, $a3 # $t1 = h + i sub $s0, $t0, $t1 # result = (f + g) - (h + i) add $v0, $s0, $0 # put return value in $v0 lw $t1, 0($sp) # restore $t1 from stack lw $t0, 4($sp) # restore $t0 from stack lw $s0, 8($sp) # restore $s0 from stack addi $sp, $sp, 12 # deallocate stack space jr $ra # return to caller

95 Stos podczas wywołania funkcji diffofsums

96 Rejestry Preserved Nonpreserved Callee-zabezpieczone
Caller-zabezpieczone $s0-$s7 $t0-$t9 $ra $a0-$a3 $sp $v0-$v1 stos powyżej $sp stos poniżej $sp

97 Zagnieżdżone wywołania funkcji
proc1: addi $sp, $sp, -4 # make space on stack sw $ra, 0($sp) # save $ra on stack jal proc2 ... lw $ra, 0($sp) # restore $ra from stack addi $sp, $sp, 4 # deallocate stack space jr $ra # return to caller

98 Przechowywanie zapisanych rejestrów na stosie
# $s0 = result diffofsums: addi $sp, $sp, -4 # make space on stack to # store one register sw $s0, 0($sp) # save $s0 on stack # no need to save $t0 or $t1 add $t0, $a0, $a1 # $t0 = f + g add $t1, $a2, $a3 # $t1 = h + i sub $s0, $t0, $t1 # result = (f + g) - (h + i) add $v0, $s0, $0 # put return value in $v0 lw $s0, 0($sp) # restore $s0 from stack addi $sp, $sp, 4 # deallocate stack space jr $ra # return to caller

99 Wywołanie rekursywne funkcji
High-level code int factorial(int n) { if (n <= 1) return 1; else return (n * factorial(n-1)); }

100 Wywołanie rekursywne funkcji
MIPS assembly code

101 Wywołanie rekursywne funkcji
MIPS assembly code 0x90 factorial: addi $sp, $sp, -8 # make room 0x sw $a0, 4($sp) # store $a0 0x sw $ra, 0($sp) # store $ra 0x9C addi $t0, $0, 2 0xA slt $t0, $a0, $t0 # a <= 1 ? 0xA beq $t0, $0, else # no: go to else 0xA addi $v0, $0, 1 # yes: return 1 0xAC addi $sp, $sp, 8 # restore $sp 0xB jr $ra # return 0xB else: addi $a0, $a0, -1 # n = n - 1 0xB jal factorial # recursive call 0xBC lw $ra, 0($sp) # restore $ra 0xC lw $a0, 4($sp) # restore $a0 0xC addi $sp, $sp, 8 # restore $sp 0xC mul $v0, $a0, $v0 # n * factorial(n-1) 0xCC jr $ra # return

102 Stos podczas rekursywnego wywołania funkcji

103 Wywołanie funkcji-podsumowanie
Caller wstawia argumenty do $a0-$a3 zapisuje stan potrzebnych rejestrów ($ra, może $t0-t9) jal callee Przywraca stan rejestrów Wynik zapisany w rejestrze $v0 Callee Zapisuje rejestry które mogą być nadpisane ($s0-$s7) Wykonuje działanie funkcji Wstawia wynik do$v0 jr $ra

104 Tryby adresowania W jaki sposób przekazujemy operandy adresów?
Tylko przez rejestry Bezpośrednio Adresowanie bazowe PC-relatywne Pseudo bezpośrednie

105 Tryby adresowania Tylko przez rejestry Bezpośrednie
Operandy znajdują się w rejestrach Przykład: add $s0, $t2, $t3 Przykład: sub $t8, $s1, $0 Bezpośrednie 16-bitowa wartość użyta jako operand Przykład: addi $s4, $t5, -73 Przykład: ori $t3, $t7, 0xFF

106 Tryby adresowania Bazowe adresowanie Opreand adresu jest tworzony:
basowy adres + stała ze znakiem Przykład: lw $s4, 72($0) adres = $0 + 72 Przykład: sw $t2, -25($t1) adres = $t1 - 25

107 Tryby adresowania PC-relatywne adresowanie 0x10 beq $t0, $0, else
0x addi $v0, $0, 1 0x addi $sp, $sp, i 0x1C jr $ra 0x else: addi $a0, $a0, -1 0x jal factorial

108 Tryby adresowania Pseudo-bezpośrednie adresowanie 0x0040005C jal sum
... 0x004000A0 sum: add $v0, $a0, $a1

109 Jak kompilować&uruchomić program

110 Co jest przechowywane w pamięci?
Instrukcje (zwane textem) Dane Globalne/statyczne: ulokowane przed programem Dynamczne: ulokowane razem z programem Jak wielka jest pamięć? Maksymalnie 232 = 4 gigabytes (4 GB) Od adresu 0x do 0xFFFFFFFF

111 MIPS Mapa Pamięci

112 Przykład programu: C Code
int f, g, y; // global variables int main(void) { f = 2; g = 3; y = sum(f, g); return y; } int sum(int a, int b) { return (a + b);

113 Przykład programu: MIPS Assembly
.data f: g: y: .text main: addi $sp, $sp, -4 # stack frame sw $ra, 0($sp) # store $ra addi $a0, $0, # $a0 = 2 sw $a0, f # f = 2 addi $a1, $0, # $a1 = 3 sw $a1, g # g = 3 jal sum # call sum sw $v0, y # y = sum() lw $ra, 0($sp) # restore $ra addi $sp, $sp, 4 # restore $sp jr $ra # return to OS sum: add $v0, $a0, $a1 # $v0 = a + b jr $ra # return int f, g, y; // global int main(void) { f = 2; g = 3; y = sum(f, g); return y; } int sum(int a, int b) { return (a + b);

114 Przykład Programu: Tabela Symboli
Adres

115 Przykład Programu: Tabela Symboli
Adres f 0x g 0x y 0x main 0x sum 0x C

116 Przykład programu: Wykonanie

117 Przykład programu: W pamięci

118 Odds & Ends Pseudoinstrukcje Wyjątki Signed and unsigned instrukcje
Instrukcje zmienno-przecinkowe

119 Pseudoinstrukcje Pseudoinstrukcja MIPS Instrukcje li $s0, 0x1234AA77
lui $s0, 0x1234 ori $s0, 0xAA77 clear $t0 add $t0, $0, $0 move $s1, $s2 add $s2, $s1, $0 nop sll $0, $0, 0

120 Wyjątki Niezaplanowana funkcja wywołuje obsługę wyjątków
Spowodowana przez: Sprzęt, zwane przerwaniem np. klawiatura Oprogramowanie, zwane pułapką np. niezdefiniowaną instrukcją Kiedy występuje wyjątek, procesor: Zapamiętuje powód wyjątku Wykonuje skok do obsługi wyjątków (na adres instrukcji 0x ) Powrót do programu

121 Rejestry wyjątków Nie jest częścią rejestru pliku
Przyczyna: Zapamiętuje przyczynę wyjątku EPC (wyjątek PC): Zapamiętuje PC gdzie wystąpił wyjątek EPC i Przyczyna: część koprocesora 0 Przenieś z Koprocesora 0 mfc0 $k0, EPC Przeniesienie kontekstu EPC do $k0

122 Przyczyny wyjątków Wyjątek Przyczyna Przerwanie sprzętowe 0x00000000
Wywołanie systemowe 0x Punkt przerwania / Dzielenie przez 0 0x Niezdefiniowana instrukcja 0x Arytmetyczne przepełnienie 0x

123 Obsługa wyjątku Procesor zapisuje przyczynę wyjątku i PC wyjątku w przyczynie i EPC Procesor wykonuje skok do obsługi wyjątku (0x ) Obsługa wyjątku: Zapisuje stan rejestrów na stosie Odczytuje rejestr przyczyny (cause) mfc0 $k0, Cause Obsługuje wyjątek Przywraca stan rejestrów Powrót do programu mfc0 $k0, EPC jr $k0

124 Instrukcje ze znakiem&bez znaku
Dodawanie i odejmowanie Mnożenie i dzielenie Set less than (ustaw 1 jeśli jest a<b)

125 Dodawanie & Odejmowanie
Ze znakiem: add, addi, sub Niektóre operacje w wersji bez znaku Procesor obsługuje wyjątek dotyczący przepełnienia Bez znaku: addu, addiu, subu Nie obsługuje wyjątku przepełnienia Uwaga: addiu rozszerzenie znaku stałej //sign-extends the immediate

126 Mnożenie & Dzielenie Ze znakiem: mult, div Bez znaku: multu, divu

127 Set Less Than Ze znakiem: slt, slti Bez znaku: sltu, sltiu
///////////////////////// Note: sltiu sign-extends the immediate before comparing it to the register

128 Ładowanie Ze znakiem: Bez znaku:
Rozszerzenie znaku do stworzenia 32-bitowej wartości załadowywanej do rejestru Załaduj pół słowa: lh Załaduj bajt: lb Bez znaku: Uzupełnienie zerami dla stworzenia 32-bitowej wartości Załaduj pół słowa bez znaku: lhu Załaduj bajt: lbu

129 Instrukcje zmienno-przecinkowe
Koprocesor zmienno-przecinkowy (Koprocesor 1) 32 32-bitowe zmienno-przecinkowe rejestry ($f0-$f31) Podwójnej-precyzji wartości przechowywane w dwóch zmienno przecinkowych rejestrach np., $f0 i $f1, $f2 i $f3, itd. Rejestry podwójnej precyzji zmienno-przecinkowe: $f0, $f2, $f4, itp.

130 Instrukcje zmienno-przecinkowe
Nazwa Numer rejestru Wykorzystanie $fv0 - $fv1 0, 2 Zwraca wartości $ft0 - $ft3 4, 6, 8, 10 Tymczasowe zmienne $fa0 - $fa1 12, 14 Argumenty funkcji $ft4 - $ft8 16, 18 $fs0 - $fs5 20, 22, 24, 26, 28, 30 Zapisane zmienne

131 Format instrukcji typu F Instruction Format
Opcode = 17 ( ) Pojedynczej precyzji: cop = 16 ( ) add.s, sub.s, div.s, neg.s, abs.s, etc. Podwójnej precyzji: cop = 17 ( ) add.d, sub.d, div.d, neg.d, abs.d, etc. 3 operandy rejestrów: fs, ft: operandy źródłowe fd: operand docelowy

132 Zmienno-przecinkowe rozgałęzienia
Ustaw/wyczyść flaga warunku: fpcond Equality: c.seq.s, c.seq.d Less than: c.lt.s, c.lt.d Less than or equal: c.le.s, c.le.d Warunek rozgałęzienia bclf: rozgałęzienie jeśli fpcond jest FALSE bclt: rozgałęzienie jeśli fpcond jest TRUE Ładowanie i przechowywanie lwc1: lwc1 $ft1, 42($s1) swc1: swc1 $fs2, 17($sp)

133 Zagadnienia w wykładu 1. Co to jest kod maszynowy?
2. Instrukcje typu R, I, J 3. Kod ASCII. 4. Pojęcie stosu. Zasada pobierania i odczytu. Do czego jest wykorzystywany. 5. Co to są pseudoinstrukcje. Podaj przykłady. 6. Przerwania. Co to jest, rodzaje przerwań. Zasada obsługi przerwań.