ARCHITEKTURA SYSTEMÓW KOMPUTEROWYCH. Babbage i jego komputer mechaniczny. Ada programuje maszynę Babbage a. architektura. c Dr inż.

Transkrypt

1 Wstęp 1 Wstęp ARCHITETURA SYSTEMÓW OMPUTEROWYCH architektura c Dr inż. Ignacy Pardyka UNIWERSYTET JANA OCHANOWSIEGO w ielcach 1 Rok akad. 215/216 2 Tryby adresowania 3 onstrukcja modelu programowego komputera Architektura ARM Architektury 64-bitowe 4 Literatura 1 Instytut Fizyki, Zakład Informatyki, ignacy.pardyka@ujk.edu.pl c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 1 / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 2 / 11 Wstęp Babbage i jego komputer mechaniczny Wstęp Ada programuje maszynę Babbage a Charles Babbage, Attended Cambridge University and married Georgiana Whitmore in Invented the Analytical Engine, the world s first mechanical computer. Also invented the cowcatcher and the universal postage rate. Interested in lock-picking, but abhorred street musicians (image courtesy of Fourmilab Switzerland, Ada Lovelace, Wrote the first computer program. It calculated the Bernoulli numbers using Charles Babbage s Analytical Engine. She was the only legitimate child of the poet Lord Byron. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 3 / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 4 / 11

2 Wstęp Poziomy abstrakcji cyfrowego systemu komputerowego Architektura komputera Wstęp Application Software Operating Systems Architecture Microarchitecture Logic Digital Circuits Analog Circuits Devices Physics > hello world! + + komputer postrzegany okiem programisty zestaw instrukcji (język) i miejsce do przechowywania danych (rejestry i pamięć) typowe architektury: x86, MIPS, SPARC, PowerPC, IA-64 aby zrozumieć architekturę, należy poznać jej język: słowa, tj. instrukcje (instructions) słownik, tj. zestaw instrukcji (instruction set) instrukcje wskazują operację jaką ma wykonać komputer, i na jakich danych (operandach) operandy mogą być w rejestrach, w pamięci, w słowie instrukcji fizyczny komputer (hardware) rozumie jedynie język zakodowany binarnie (ciągi zer i jedynek), tj. rozumie język maszynowy (natywny danego procesora) program zapisany w języku wyższego poziomu jest tłumaczony (translation) na język maszynowy. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 5 / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 6 / 11 Wstęp Algebra Boole a - aksjomaty Wstęp oncepcja programu pamiętanego Machine Code Stored Program George Boole, Born to working-class parents and unable to afford a formal education, Boole taught himself mathematics and joined the faculty of Queen s College in Ireland. He wrote An Investigation of the Laws of Thought (1854), which introduced binary variables and the three fundamental logic operations: AND, OR, and NOT (image courtesy of the American Institute of Physics). Axiom Dual Name A1 B = ifb 1 A1 B = 1ifB Binary field A2 = 1 A2 1 = NOT A3 = A = 1 AND/OR A4 1 1 = 1 A4 + = AND/OR A5 1 = 1 = A5 1 + = + 1 = 1 AND/OR lw $t2, 32($) add $s, $s1, $s2 addi $t, $s3, 12 sub $t, $t3, $t5 x8ca2 x23282 x2268fff4 x16d422 Address Instructions 4C 1 6 D F F F C A 2 Main Memory PC c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 7 / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 8 / 11

3 Wstęp Budowanie programu binarnego Języki wysokiego poziomu Wstęp Grace Hopper, Graduated from Yale University with a Ph.D. in mathematics. Developed the first compiler while working for the Remington Rand Corporation and was instrumental in developing the COBOL programming language. As a naval officer, she received many awards, including a World War II Victory Medal and the National Defense Service Medal. High-Level Code Compiler Assembler Object File Linker Executable Loader Memory Object Files Library Files lata 6. XX w.: Algol, Fortran lata 8. XX w.: rozwój języków proceduralnych: Pascal, C obecnie: języki obiektowe: C++, C#, Java, Eiffel,... struktura komputera zaprojektowana, by łatwo i wydajnie wykonywać programy tłumaczone z języka wysokiego pozimu na język natywny procesora poziomy abstrakcji języków Language Matlab Perl Python Java C Assembly Language Machine Language Description Designed to facilitate heavy use of math functions Designed for scripting Designed to emphasize code readability Designed to run securely on any computer Designed for flexibility and overall system access, including device drivers Human-readable machine language Binary representation of a program c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 9 / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 1 / 11 Wstęp Program w języku C 1 Wstęp int x, y; // zmienne globalne char * p; int myadd(int a, int b){ int r; // zmienna lokalna r = a + b; return r;} void cleanup(void){ free(p);} // dealokacja zmiennej dynamicznej int main (void){ p = malloc(1); x = myadd(2,3); cleanup();} // alokacja // dealokacja Dennis Ritchie, Brian ernighan, Tryby adresowania 3 onstrukcja modelu programowego komputera Architektura ARM Architektury 64-bitowe 4 Literatura c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

4 1 Wstęp 2 Tryby adresowania 3 onstrukcja modelu programowego komputera Architektura ARM Architektury 64-bitowe 4 Literatura Asembler język asemblera: reprezentacja języka maszynowego w formie czytelnej dla człowieka instrukcje: specyfikują operację i operandy operandy: reprezentowane binarnie, zgodnie z przyjętym standardem reprezentacji architektura MIPS: prosta regularna popularna łatwa do nauki. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Instrukcje Instrukcje dodawanie język C: a = b + c; asembler: add a, b, c odejmowanie język C: a = b - c; asembler: sub a, b, c składnia instrukcji asemlera: mnemonic i operandy mnemonic określa operację, np. add operandy źródłowe (ang. source): b, c operand wynikowy (docelowy, ang. destination): a. instrukcja w C może, oczywiście, zawierać więcej prostych operacji, np. język C: a = b + c - d; reprezentacja w asemblerze: dwie instrukcje sub t, c, d add a, b, t MIPS jest architekturą typu RISC: stosunkowo mały zestaw instrukcji instrukcje proste proste tryby adresowania operandów łatwa implementacja (mikroarchitektura). c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

5 Operandy Operandy Operandy reprezentowane binarnie standardy reprezentacji danych, zależnie od typu, np. naturalny kod dwójkowy (NBC) uzupełnienie dwójkowe (U2) zmiennoprzecinkowy (IEEE754) znakowy (ASCII, UNICODE) przechowywane w rejestrach w pamięci albo w słowie instrukcji programu czas dostępu do operandów w pamięci jest najdłuższy procesor jest nazywany 32-bitowym, gdy operandy reprezentowane są na 32 bitach. operacje są wykonywane szybciej, gdy operandy są umieszczone w rejestrach (lub w słowie instrukcji) w asemblerze MIPS rejestry służące do przechowywania zmiennych (ang. saved registers): s, s1,..., s7 mają nazwy: $s, $s1,... np. instrukcja języka C: a = b + c; w asemblerze MIPS: add $s, $s1, $s2 przy założeniu, że wcześniej zmienne a, b, c umieszczono, odpowiednio, w rejestrach: $s, $s1, $s2 do przechowywania rezultatów tymczasowych przewidziano rejestry $t, $t1,..., $t9 (ang. temporary registers), np. instrukcja C: a = b + c - d; jeśli: $s = a, $s1 = b, $s2 = c, $s3 = d w asemblerze MIPS zostanie wyrażona następująco: sub $t, $s2, $s3 # t = c -d add $s, $s1, $t # a = b + t c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Rejestry MIPS Przykład Name Number Use $ the constant value $at 1 assembler temporary $v $v1 2 3 function return value $a $a3 4 7 function arguments $t $t temporary variables $s $s saved variables $t8 $t temporary variables $k $k operating system (OS) temporaries $gp 28 global pointer $sp 29 stack pointer $fp 3 frame pointer $ra 31 function return address zakładając, że zmienne są przechowywane w rejestrach przetłumaczyć na język asemblera fragment programu: a = b - c; f = (g + h) - (i + j); przykładowe rozwiązanie: # MIPS assembly code # $s = a, $s1 = b, $s2 = c, $s3 = f, $s4 = g, $s5 = h # $s6 = i, $s7 = j sub $s, $s1, $s2 # a = b - c add $t, $s4, $s5 # $t = g + h add $t1, $s6, $s7 # $t1 = i + j sub $s3, $t, $t1 # f = (g + h) - (i + j) c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 2 / 11

6 Pamięć adresowanie pamięci Pamięć dostęp do danych w pamięci z adresowaniem słów pamięć z adresowaniem słów Word Address Data 3 4 F pamięć z adresowaniem bajtów Word Address C E E F2F 1AC7 ABCDEF 78 Data 4 F E E F2F1 AC7 ABCDEF 78 width = 4 bytes Word 3 Word 2 Word 1 Word Word 3 Word 2 Word 1 Word odczyt z pamięci: jeśli adresowane są słowa pamięci, to lw $s3, 1($) # słowo spod adresu 1 zapisz do $s3 efektywny adres słowa pamięci (ang. effective address): suma adresu bazowego (ang. base address) zapisanego w nawiasie i przesunięcia (ang. offset) zapisanego przed nawiasem czyli, efektywny adres słowa w powyższej instrukcji lw jest równy 1 pod adresem słowa: x1 w pamięci była wartość: xf2f1ac7 zapis do pamięci: instrukcja sw sw $s7, 5($) # zapisz zawartość $s7 pod adres 5 adres bazowy może być w dowolnym rejestrze MIPS. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Pamięć dostęp do danych w pamięci z adresowaniem bajtów Pamięć Big-Endian, Little-Endian MIPS: adresowanie bajtów, nie słów adres 32-bitowej danej jest wielokrotnością 4, np. instrukcja lw, np. lw $s3, 4($) # wczytaj słowo spod adresu 4 do $s3 są odrębne instrukcje dostępu do danych 1-bajtowych lb, sb. pamięć z adresowaniem bajtów: bajty w słowie mogą być różnie ułożone adres słowa: najbardziej znaczący bajt (Big-Endian) adres słowa: najmniej znaczący bajt (Little-Endian) big-endian, little-endian Big-Endian Byte Address C D E F 8 9 A B MSB LSB Word Address C 8 4 Little-Endian Byte Address F E D C B A MSB LSB c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

7 Przykład załóżmy, że rejestr $s zawiera początkowo x jaka będzie zawartość $s po wykonaniu fragmentu programu na komputerze z system a) big-endian, b) little-endian sw $s, ($) lb $s, 1($) rozwiązanie: po instrukcji sw $s, ($) zawartość pamięci: Big-Endian Little-Endian Byte Address Word Address Byte Address Data Value Data Value MSB LSB MSB LSB po instrukcji lb $s, 1($) zawartość $s: x45, gdy big-endian x67, gdy little-endian. Adresowanie natychmiastowe stałe przechowywane w słowie instrukcji w słowie instrukcji można przechowywać wartości stałe, przydatne, np. do tworzenia adresu efektywnego, albo wręcz operandy adresowanie natychmiastowe (ang. immediate) stała jest w pobranej już instrukcji, więc nie trzeba sięgać po tę stałą ani do rejestru, ani do pamięci np. w słowie instrukcji lw przechowywany jest offset instrukcje arytmetyczne z adresowaniem natychmiastowym, np. addi High-Level Code a = a+4; b = a 12; MIPS # $s = a, $s1 = b addi $s, $s, 4 # a = a+4 addi $s1, $s, 12 # b = a 12 stała jest często przechowywana w instrukcji, w polu 16-bitowym, w reprezentacji uzupełnienia dwójkowego (U2, ang. 2 complement), czyli jako wartość z zakresu [-32768, 32767]. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Język maszynowy Instrukcje typu rejestrowego, R-type język asemblera jest dość wygodny do czytania przez człowieka jednak układy cyfrowe rozumieją tylko zera i jedynki dlatego niezbędne jest tłumaczenie (ang. translation) instrukcji z języka asemblera na język maszyny (ang. machine language) w rezultacie instrukcje zostają zakodowane binarnie MIPS: instrukcje w formatach 32-bitowych typu rejestrowego (ang. R-type): operandy w trzech rejestrach natychmiastowego (ang. I-type): operandy w dwóch rejestrach i stała 16-bitowa w słowie instrukcji skoku (ang. J-type): jeden operand w postaci stałej 26-bitowej w słowie instrukcji opcjonalnie, instrukcje zmiennoprzecinkowe (ang. F-type): operandy w rejestrach zmiennoprzecinkowych f..f31. wszystkie trzy operandy w rejestrach: dwa operandy źródłowe (ang. source): rs, rt jeden operand docelowy (ang. destination): rd słowo instrukcji: pola: R-type op rs rt rd shamt funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits op: kod operacji (ang. opcode) funct (ang. function): rozszerzenie kodu operacji, np. R-type: opcode = 2 dla operacji add: funct = 1 2 dla operacji sub: funct = 11 2 pola rs, rt, rd zawierają 5-bitowe numery rejestrów. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

8 Rejestry MIPS: numery rejestrów Instrukcje typu rejestrowego, R-type Name Number Use $ the constant value $at 1 assembler temporary $v $v1 2 3 function return value $a $a3 4 7 function arguments $t $t temporary variables $s $s saved variables $t8 $t temporary variables $k $k operating system (OS) temporaries $gp 28 global pointer $sp 29 stack pointer przykład: add $s, $s1, $s2 sub $t, $t3, $t5 Field Values Machine Code op rs rt rd shamt funct op rs rt rd shamt funct ( x 23282) ( x 16D422) 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits ćwiczenie: zakodować instrukcję add $t, $s4, $s5 odnajdujemy numery rejestrów z tabeli i umieszczamy w polach: add $t, $s4, $s5 Field Values Machine Code op rs rt rd shamt funct op rs rt rd shamt funct bits 5 bits 5 bits 5 bits 5 bits 6 bits ( x 29542) $fp 3 frame pointer $ra 31 function return address c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 3 / 11 Instrukcje typu natychmiastowego, I-type słowo instrukcji: I-type op rs rt imm 6 bits 5 bits 5 bits 16 bits dwa operandy w rejestrach, jeden w polu instrukcji operandy źródłowe (ang. source): rs, imm pole rt wskazuje na operand docelowy (ang. destination), np. dla instrukcji addi, lw, albo na operand źródłowy, np. dla instrukcji sw przykład kodowania: addi $s, $s1, 5 Field Values Machine Code op rs rt imm op rs rt imm ( x 2235) Instrukcje typu natychmiastowego, I-type ćwiczenie zakodować instrukcję: lw $s3, -24($s4) rozwiązanie: z tabeli nazw rejestrów bierzemy numery rejestrów i zapisujemy: pole rs: 2 (numer rejestru $s4) pole rt: 19 (numer rejestru $s3) kod operacji wpisujemy do pola op w polu imm zapisujemy reprezentację wartości -24 w kodzie U2 lw $s3, 24($s4) Field Values op rs rt imm bits 5 bits 5 bits 16 bits Machine Code op rs rt imm (x8e93ffe8) 8 E 9 3 F F E 8 addi $t, $s3, 12 lw $t2, 32($) sw $s1, 4($t1) bits 5 bits 5 bits 16 bits 6 bits 5 bits 5 bits 16 bits ( x 2268FFF4) ( x 8CA2) ( x AD314) rejestr bazowy $s4 jest 32-bitowy, więc stała 16-bitowa imm musi być rozszerzona (ze znakiem) do 32 bitów (ang. sign extension). c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

9 Instrukcje skoku, J-type Instrukcje zmiennoprzecinkowe: F-type jeden operand 26-bitowy: adres skoku słowo instrukcji: op J-type addr 6 bits 26 bits instrukcje typu J zostaną szczegółowo omówione w dalszej kolejności, jako instrukcje rozgałęzień pole kodu operacji: op = 17 pojedynczej precyzji: cop = 16 podwójnej precyzji: cop = 17 fs, ft, fd: n-ry rejestrów source, target, destination rejestry zmiennoprzecinkowe: Name Number Use op F-type cop ft fs fd funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits $fv $fv1, 2 function return value $ft $ft3 4, 6, 8, 1 temporary variables $fa $fa1 12, 14 function arguments $ft4 $ft5 16, 18 temporary variables $fs $fs5 2, 22, 24, 26, 28, 3 saved variables c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Interpretacja kodu maszynowego oncepcja programu pamiętanego aby zinterpretować instrukcję, trzeba najpierw rozkodować poszczególne pola jeśli pole op =, to instrukcja typu rejestrowego w przeciwnym razie jest to instrukcja typu natychmiastowego, instrukcja skoku, albo instrukcja zmiennoprzecinkowa rozkodujmy następujące dwie instrukcje MIPS: x2237fff1 x2f3422 rozwiązanie: zapisujemy słowa binarnie i odczytujemy pola Machine Code op rs rt imm (x2237fff1) F F F 1 op rs rt rd shamt funct (x2f3422) F Field Values op rs rt imm op rs rt rd shamt funct addi $s7, $s1, 15 sub $t, $s7, $s3 program zapisany w języku maszynowym MIPS może być postrzegany jako ciąg liczb 32-bitowych binarną reprezentację programu należy umieścić w pamięci programu powyższa idea nosi nazwę koncepcji programu pamiętanego i stanowi o uniwersalności komputerów lw $t2, 32($) add $s, $s1, $s2 addi $t, $s3, 12 sub $t, $t3, $t5 Machine Code x8ca2 x23282 x2268fff4 x16d422 Address Instructions 4C 1 6 D Stored Program F F F C A 2 Main Memory wymieniając program zmieniamy działanie urządzenia kolejna instrukcja jest pobierana z pamięci, interpretowana, a następnie wykonywana jest operacja wskazana w instrukcji. PC c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

10 oncepcja programu pamiętanego w celu wykonania programu (ang. run, execute program) procesor sekwencyjnie pobiera instrukcje z pamięci (ang. instruction fetch) po pobraniu każdej instrukcji 1 instrukcja jest dekodowana sprzętowo (ang. hardware decoding) 2 sprzętowo jest wykonywana operacja wskazana w instrukcji adres instrukcji, która ma być pobrana jest przechowywany w rejestrze PC (ang. program counter, pol. licznik rozkazów, wskaźnik instrukcji) autorka koncepcji programu pamiętanego (córka poety Lorda Byrona): MIPS: lista instrukcji pełna lista instrukcji MIPS w dokumentacji oznaczenia na liście instrukcji: [reg]: zawartość rejestru reg imm: pole 16-bitowe w instrukcji I-type addr: adres 26-bitowy w instrukcji J-type SignImm: rozszerzenie 32-bit ze znakiem = {{16{imm[15]}}, imm} ZeroImm: rozszerzenie 32-bit zerami = {16 b, imm} Address: [rs] + SignImm [Address]: zawartość pamięci spod Address BTA: branch target address1 = PC (SignImm << 2) JTA: jump target address = {(PC + 4)[31:28], addr, 2 b} label: etykieta instrukcji Ada Lovelace, c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 MIPS: lista instrukcji MIPS: lista instrukcji Opcode Name Description Operation () R-type all R-type instructions see Table B.2 1 (1) (rt = /1) bltz rs, label / bgez rs, label branch less than zero/branch greater than or equal to zero 1 (2) j label jump PC = JTA if ([rs] < ) PC = BTA/ if ([rs] ) PC = BTA 11 (3) jal label jump and link $ra = PC + 4, PC = JTA 1 (4) beq rs, rt, label branch if equal if ([rs] == [rt]) PC = BTA 11 (5) bne rs, rt, label branch if not equal if ([rs]!= [rt]) PC = BTA 11 (6) blez rs, label branch if less than or equal to zero if ([rs] ) PC = BTA 111 (7) bgtz rs, label branch if greater than zero if ([rs] > ) PC = BTA 1 (8) addi rt, rs, imm add immediate [rt] = [rs] + SignImm 11 (9) addiu rt, rs, imm add immediate unsigned [rt] = [rs] + SignImm 11 (1) slti rt, rs, imm set less than immediate [rs] < SignImm? [rt] = l : [rt] = 111 (11) sltiu rt, rs, imm set less than immediate unsigned [rs] < SignImm? [rt] = l : [rt] = 11 (12) andi rt, rs, imm and immediate [rt] = [rs] & ZeroImm 111 (13) ori rt, rs, imm or immediate [rt] = [rs] ZeroImm 1111 (15) lui rt, imm load upper immediate [rt] = {imm, 16'b} 1 (16) (rs = /4) mfc rt, rd / mtc rt, rd move from/to coprocessor 11 (17) F-type fop = 16/17: F-type instructions see Table B.3 11 (17) (rt = /1) 111 (28) (func = 2) bc1f label/ bc1t label fop = 8: branch if fpcond is FALSE/TRUE [rt] = [rd]/[rd] = [rt] (rd is in coprocessor ) if (fpcond == ) PC = BTA/ if (fpcond == 1) PC = BTA mul rd, rs, rt multiply (32-bit result) [rd] = [rs] x [rt] 1 (32) lb rt, imm(rs) load byte [rt] = SignExt ([Address] 7:) 11 (33) lh rt, imm(rs) load halfword [rt] = SignExt ([Address]15:) 111 (35) lw rt, imm(rs) load word [rt] = [Address] 11 (36) lbu rt, imm(rs) load byte unsigned [rt] = ZeroExt ([Address]7:) 111 (37) lhu rt, imm(rs) load halfword unsigned [rt] = ZeroExt ([Address]15:) 111 (14) xori rt, rs, imm xor immediate [rt] = [rs] ^ ZeroImm c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 4 / 11

11 MIPS: lista instrukcji MIPS: lista instrukcji typu R Funct Name Description Operation () sll rd, rt, shamt shift left logical [rd] = [rt] << shamt 1 (2) srl rd, rt, shamt shift right logical [rd] = [rt] >> shamt 11 (3) sra rd, rt, shamt shift right arithmetic [rd] = [rt] >>> shamt 1 (4) sllv rd, rt, rs shift left logical variable [rd] = [rt] << [rs]4: 11 (6) srlv rd, rt, rs shift right logical variable [rd] = [rt] >> [rs]4: 111 (7) srav rd, rt, rs shift right arithmetic variable [rd] = [rt] >>> [rs]4: 1 (8) jr rs jump register PC = [rs] Opcode Name Description Operation 11 (4) sb rt, imm(rs) store byte [Address] 7: = [rt] 7: 111 (41) sh rt, imm(rs) store halfword [Address] 15: = [rt] 15: 1111 (43) sw rt, imm(rs) store word [Address] = [rt] 111 (49) lwc1 ft, imm(rs) load word to FP coprocessor 1 [ft] = [Address] 1111 (56) swc1 ft, imm(rs) store word to FP coprocessor 1 [Address] = [ft] 11 (9) jalr rs jump and link register $ra = PC + 4, PC = [rs] 11 (12) syscall system call system call exception 111 (13) break break break exception 1 (16) mfhi rd move from hi [rd] = [hi] 11 (17) mthi rs move to hi [hi] = [rs] 11 (18) mflo rd move from lo [rd] = [lo] 111 (19) mtlo rs move to lo [lo] = [rs] 11 (24) mult rs, rt multiply {[hi], [lo]} = [rs] [rt] 111 (25) multu rs, rt multiply unsigned {[hi], [lo]} = [rs] [rt] 111 (26) div rs, rt divide [lo] = [rs]/[rt], [hi] = [rs]%[rt] 1111 (27) divu rs, rt divide unsigned [lo] = [rs]/[rt], [hi] = [rs]%[rt] c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 MIPS: lista instrukcji typu R MIPS: lista instrukcji zmiennoprzecinkowych Funct Name Description Operation 1 (32) add rd, rs, rt add [rd] = [rs] + [rt] 11 (33) addu rd, rs, rt add unsigned [rd] = [rs] + [rt] 11 (34) sub rd, rs, rt subtract [rd] = [rs] [rt] 111 (35) subu rd, rs, rt subtract unsigned [rd] = [rs] [rt] 11 (36) and rd, rs, rt and [rd] = [rs] & [rt] 111 (37) or rd, rs, rt or [rd] = [rs] [rt] 111 (38) xor rd, rs, rt xor [rd] = [rs] ^ [rt] 1111 (39) nor rd, rs, rt nor [rd] = ~([rs] [rt]) 111 (42) slt rd, rs, rt set less than [rs] < [rt]? [rd] = 1 : [rd] = 1111 (43) sltu rd, rs, rt set less than unsigned [rs] < [rt]? [rd] = 1 : [rd] = Funct Name Description Operation () add.s fd, fs, ft / add.d fd, fs, ft 1 (1) sub.s fd, fs, ft / sub.d fd, fs, ft 1 (2) mul.s fd, fs, ft / mul.d fd, fs, ft 11 (3) div.s fd, fs, ft / div.d fd, fs, ft 11 (5) abs.s fd, fs / abs.d fd, fs 111 (7) neg.s fd, fs / neg.d fd, fs 1111 (58) c.seq.s fs, ft / c.seq.d fs, ft 1111 (6) c.lt.s fs, ft / c.lt.d fs, ft (62) c.le.s fs, ft / c.le.d fs, ft FP add FP subtract FP multiply FP divide FP absolute value FP negation FP equality comparison FP less than comparison FP less than or equal comparison [fd] = [fs] + [ft] [fd] = [fs] [ft] [fd] = [fs] [ft] [fd] = [fs]/[ft] [fd] = ([fs] < )? [ fs] : [fs] [fd] = [ fs] fpcond = ([fs] == [ft]) fpcond = ([fs] < [ft]) fpcond = ([fs] [ft]) c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

12 onstrukcje programistyczne Instrukcje logiczne języki wysokiego poziomu (np. C, Java) stosują konstrukcje bardziej abstrakcyjne niż język asembler typowe konstrukcje programistyczne języków wysokiego poziomu: wyrażenia arytmetyczne i logiczne instrukcje warunkowe (typu if/else) instrukcje pętli (typu for, while) indeksowanie tablic wywoływanie funkcji omówimy sposoby implementacji wysokopoziomowych konstrukcji programistycznych w asemblerze architektury MIPS. instrukcje logiczne MIPS: operacje logiczne and, or, xor, nor na dwóch rejestrach, albo na rejestrze i stałej instrukcje typu rejestrowego (R-type), albo natychmiastowego (I-type) operacje wykonywane są na poszczególnych bitach dwóch argumentów źródłowych wynik zapisywany jest do rejestru docelowego przeanalizować działanie fragmentu programu, przy założeniu że jeden z rejestrów źródłowych zawiera wartość xffff, a drugi x46a1fb7 and $s3, $s1, $s2 or $s4, $s1, $s2 xor $s5, $s1, $s2 nor $s6, $s1, $s2 Source Registers $s $s Result $s $s $s $s c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Instrukcje logiczne Instrukcje przesunięć instrukcje logiczne MIPS typu natychmiastowego: andi, ori, xori operacje na rejestrze i stałej (uwaga: nie ma nori) stała 16-bitowa jest rozszerzana zerami do reprezentacji 32-bitowej przykład: Source Values $s imm zero-extended Result andi $s2, $s1, xfa34 $s ori $s3, $s1, xfa34 $s xori $s4, $s1, xfa34 $s instrukcje przesunięć zawartości rejestru o zadaną liczbę bitów (logicznie albo arytmetycznie) w lewo (ang. left), albo w prawo (ang. right): sll (shift left logical) srl (shift right logical) sra (shift right arithmetical) wynik zapisywany jest do rejestru docelowego (rd, ang. destination) kod maszynowy instrukcji przesunięć format rejestrowy (R-type): sll $t, $s1, 4 srl $s2, $s1, 4 sra $s3, $s1, 4 Field Values op rs rt rd shamt funct bits 5 bits 5 bits 5 bits 5 bits 6 bits Machine Code op rs rt rd shamt funct (x1141) (x11912) (x11993) 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

13 Instrukcje przesunięć Instrukcje przesunięć analiza operacji: Source Values $s shamt 1 Result sll $t, $s1, 4 $t srl $s2, $s1, 4 $s sra $s3, $s1, 4 $s kod maszynowy instrukcji przesunięć format rejestrowy (R-type): Field Values Machine Code op rs rt rd shamt funct op rs rt rd shamt funct sll $t, $s1, (x1141) MIPS oferuje analogiczne instrukcje przesunięć zawartości rejestru o liczbę bitów określoną w innym rejestrze, reprezentującym zmienną (ang. variable-shift): sllv (shift left logical variable) srlv (shift right logical variable) srav (shift right arithmetical variable) wynik zapisywany jest do rejestru docelowego (rd, ang. destination) kod maszynowy instrukcji przesunięć o zmienną liczbę pozycji format rejestrowy (R-type): sllv $s3, $s1, $s2 srlv $s4, $s1, $s2 Field Values op rs rt rd shamt funct Machine Code op rs rt rd shamt funct (x251984) (x251a6) srl $s2, $s1, (x11912) srav $s5, $s1, $s (x251a87) sra $s3, $s1, (x11993) 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 5 / 11 Instrukcje przesunięć Generowanie stałych analiza operacji (zmienna zapisana w $s2 przechowuje liczbę przesunięć): sllv $s3, $s1, $s2 srlv $s4, $s1, $s2 srav $s5, $s1, $s2 Source Values $s $s2 1 Result $s $s $s kod maszynowy instrukcji przesunięć o zmienną liczbę pozycji format rejestrowy (R-type): sllv $s3, $s1, $s2 Field Values op rs rt rd shamt funct Machine Code op rs rt rd shamt funct (x251984) stałe wartości 16-bitowe można w asemblerze architektury MIPS przypisywać zmiennym za pomocą instrukcji addi, np. High-Level Code int a = x4f3c; MIPS # $s = a addi $s, $, x4f3c # a = x4f3c a stałe 32-bitowe za pomocą lui (load upper immediate), po której użyjemy ori, np. High-Level Code int a = x6d5e4f3c; MIPS # $s = a lui $s, x6d5e ori $s, $s, x4f3c # a = x6d5e # a = x6d5e4f3c srlv $s4, $s1, $s (x251a6) srav $s5, $s1, $s (x251a87) 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

14 Instrukcje mnożenia i dzielenia Instrukcje rozgałęzień mnożenie dwóch 32-bitowych liczb daje wartość 64-bitową dzielenie dwóch 32-bitowych liczb daje całkowitą wartość 32-bitową i resztę, również 32-bitową MIPS: dodatkowe dwa rejestry 32-bitowe [hi lo] przechowują wynik mnożenia (albo dzielenia) hi: reszta z dzielenia lo: wynik dzielenia całkowitego dostęp do rejestrów [hi lo] za pomocą dedykowanych instrukcji mfhi (move from hi), mflo (move from lo), np. mflo $s3 mnożenie: mult $s, $s1 wynik w [hi lo] jest też instrukcja 3-argumentowa mult $s3, $s, $s1 wynik 32-bitowy w $s3 dzielenie: div $s, $s1 wynik ($s/$s1) w [hi lo]. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 rozgałęzianie (ang. branching): zmiana domyślnego przepływu sterowania (domyślnie rejestr PC jest zwiększany o 4) w celu opuszczenia pewnych instrukcji w celu powtórnego wykonania instrukcji rozgałęzienie polega na modyfikacji rejestru PC instrukcja rozgałęzienia warunkowego (ang. conditional branch) poleca wykonać test: rozgałęzienie ma zostać zrealizowane tylko wtedy, gdy test ma wartość TRUE instrukcja rozgałęzienia bezwarunkowego (ang. unconditional branch) nakazuje modyfikację PC bezwarunkowo: nazywana jest skokiem (ang. jump) stosowne konstrukcje z języka wysokiego poziomu: if/else, switch/case, while, for są implementowane w języku asemblera architektury MIPS za pomocą instrukcji rozgałęzień warunkowych. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Instrukcje rozgałęzień warunkowych Instrukcje rozgałęzień bezwarunkowych MIPS: dwie instrukcje rozgałęzień warunkowych: beq (branch if equal): beq rs, rt, imm bne (branch if not equal): bne rs, rt, imm przykład: addi $s, $, 4 # $s = +4= 4 addi $s1, $, 1 # $s1 = +1= 1 sll $s1, $s1, 2 # $s1 = 1<<2= 4 beq $s, $s1, target # $s == $s1, so branch is taken addi $s1, $s1, 1 # not executed sub $s1, $s1, $s # not executed target: add $s1, $s1, $s # $s1 = 4+4= 8 etykiety tłumaczone są na adresy. MIPS: trzy instrukcje rozgałęzień bezwarunkowych: j (jump): j target jal (jump and link): do wywoływania funkcji jr (jump register): jr rs (adres w rejestrze rs) przykład: addi $s, $, 4 # $s = 4 addi $s1, $, 1 # $s1 = 1 j target # jump to target addi $s1, $s1, 1 # not executed sub $s1, $s1, $s # not executed target: add $s1, $s1, $s # $s1 = 1+4= 5 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

15 Translacja instrukcji warunkowych Translacja instrukcji warunkowych switch/case instrukcja języka wysokiego poziomu: if może być tak tłumaczona na język asemblera MIPS: High-Level Code if (i == j) f = g+h; f = f i; a instrukcja if/else if (i == j) f = g+h; else f = f i; MIPS # $s = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j bne $s3, $s4, L1 # if i!= j, skip if block add $s, $s1, $s2 # if block: f = g+h L1: sub $s, $s, $s3 # f = f i # $s = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j bne $s3, $s4, else # if i!= j, branch to else add $s, $s1, $s2 # if block: f = g+h j L2 # skip past the else block else: sub $s, $s, $s3 # else block: f = f i L2: switch (amount) { case 2: fee = 2; break; case 5: fee = 3; break; case 1: fee = 5; break; default: fee = ; } // equivalent function using if/else statements if (amount = = 2) fee = 2; else if (amount == 5) fee = 3; else if (amount == 1) fee = 5; else fee = ; # $s = amount, $s1 = fee case2: addi $t, $, 2 # $t = 2 bne $s, $t, case5 # amount == 2? if not, # skip to case5 addi $s1, $, 2 # if so, fee = 2 j done # and break out of case case5: addi $t, $, 5 # $t = 5 bne $s, $t, case1 # amount == 5? if not, # skip to case1 addi $s1, $, 3 # if so, fee = 3 j done # and break out of case case1: addi $t, $, 1 # $t = 1 bne $s, $t, default # amount == 1? if not, # skip to default addi $s1, $, 5 # if so, fee = 5 j done # and break out of case default: add $s1, $, $ # fee = done: c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Translacja instrukcji pętli pętla while Translacja instrukcji pętli pętla for High-Level Code MIPS High-Level Code int pow = 1; int x = ; while (pow!= 128) { pow = pow * 2; x = x+1; } MIPS # $s = pow, $s1 = x addi $s, $, 1 # pow = 1 addi $s1, $, # x = addi $t, $, 128 # t = 128 for comparison while: beq $s, $t, done # if pow == 128, exit while loop sll $s, $s, 1 # pow = pow * 2 addi $s1, $s1, 1 # x = x+1 j while done: int sum = ; for (i = ; i!= 1; i = i + 1) { sum = sum + i ; } // equivalent to the following while loop int sum = ; int i = ; while (i!= 1) { sum = sum + i; i = i+1; } # $s = i, $s1 = sum add $s1, $, $ # sum = addi $s, $, # i = addi $t, $, 1 # $t = 1 for: beq $s, $t, done # if i == 1, branch to done add $s1, $s1, $s # sum = sum + i addi $s, $s, 1 # increment i j for done: c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 6 / 11

16 Tablice tablica (ang. array) grupuje w pamięci dane tego samego typu adres bazowy (ang. base address): adres początkowego elementu tablicy indeks: numer elementu względem adresu bazowego rozmiar talicy (ang. size): liczba elementów tablicy przykład Address x171 x17c x178 x174 x17 Data array[4] array[3] array[2] array[1] array[] Tablice dostęp do elementów tablicy przykład program mnoży dwa elementy tablicy przez 8 rezultat zapisuje w tablicy przykład High-Level Code int array[5]; array[] = array[] * 8; array[1] = array[1] * 8; MIPS # $s = base address of array lui $s, x1 # $s = x1 ori $s, $s, x7 # $s = x17 lw $t1, ($s) # $t1 = array[] sll $t1, $t1, 3 # $t1 = $t1 << 3 = $t1 * 8 sw $t1, ($s) # array[] = $t1 Iw $t1, 4($s) # $t1 = array[1] sll $t1, $t1, 3 # $t1 = $t1 << 3 = $t1 * 8 sw $t1, 4($s) # array[1] = $t1 Main Memory c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Tryby adresowania Tablice dostęp do elementów tablicy 1 Wstęp pętla ułatwia dostęp do wszystkich elementów tablicy przykład: tablica 1-elementowa o adresie bazowym x23b8f High-Level Code int i; int array[1]; for (i = ; i < 1; i = i+1) array[i] = array[i] * 8; MIPS # $s = array base address, $s1 = i # initialization code lui $s, x23b8 # $s = x23b8 ori $s, $s, xf # $s = x23b8f addi $s1, $, # i = addi $t2, $, 1 # $t2 = 1 loop: slt $t, $s1, $t2 # i < 1? beq $t, $, done # if not, then done sll $t, $s1, 2 # $t = i*4 (byte offset) add $t, $t, $s # address of array[i] lw $t1, ($t) # $t1 = array[i] sll $t1, $t1, 3 # $t1 = array[i] * 8 sw $t1, ($t) # array[i] = array[i] * 8 addi $s1, $s1, 1 # i = i+1 j loop # repeat done: 2 Tryby adresowania 3 onstrukcja modelu programowego komputera Architektura ARM Architektury 64-bitowe 4 Literatura c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

17 Tryby adresowania Tryby adresowania Tryby adresowania Adresowanie względem PC MIPS: 5 trybów adresowania (ang. addressing modes) 3 tryby adresowania operandów: rejestrowe (ang. register-only addressing) natychmiastowe (ang. immediate addressing) bazowe (ang. base addressing) 2 tryby modyfikacji rejestru PC: względem PC (ang. PC-relative addressing) pseudo-bezpośrednie (ang. pseudo-direct addressing) wszystkie instrukcje typu R: tryb rejestrowy niektóre instrukcje typu I: tryb natychmiastowy instrukcje dostępu do pamięci: tryb bazowy adres efektywny jest sumą adresu bazowego i 16-bitowej stałej (offset) z pola imm rozkazu. adresowanie względem PC jest stosowane w instrukcjach rozgałęzień warunkowych, np. xa4 beq $t, $, else xa8 addi $v, $, 1 xac addi $sp, $sp, 8 xbo jr $ra xb4 else: addi $a, $a, 1 xb8 jal factorial w polu instrukcji jest 16-bitowa stała z znakiem, która po pomnożeniu przez 4, i po dodaniu do PC+4 jest adresem następnej instrukcji, gdy warunek rozgałęzienia jest spełniony (BTA ang. branch target address) beq $t, $, else Field Values op rs rt imm Machine Code op rs rt imm (x113) 6 bits 5 bits 5 bits 16 bits 6 bits 5 bits 5 bits 16 bits c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Tryby adresowania Adresowanie pseudo-bezpośrednie adresowanie bezpośrednie: adres powinien być w słowie instrukcji, ale jeśli adres jest 32-bitowy, a instrukcja 32-bitowa też, to brak miejsca adresowanie pseudo-bezpośrednie: w słowie instrukcji część adresu instrukcje skoku: j, jal reprezentacja instrukcji jal jal sum op x45c jal sum... x4a sum: add $v, $a, $a1 op Machine Code addr 3 x (xc128) 6 bits Field Values addr 26 bits 6 bits 26 bits adres docelowy (ang. jump target address) jest wyznaczany następująco: dwa najmłodsze bity zerowe (instrukcje na granicy słowa 4-bitowego) 26 bitów pobierane jest z pola addr najstarsze 4 bity to najstarsze bity wartości PC+4. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 1 Wstęp 2 Tryby adresowania 3 onstrukcja modelu programowego komputera Architektura ARM Architektury 64-bitowe 4 Literatura c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

18 Wywoływanie funkcji Argumenty funkcji i rezultat MIPS: do wywołania funkcji (ang. function call) używa się instrukcji jal (ang. jump and link), a do powrotu (ang. return) instrukcji jr (ang. jump register) instrukcja jal faddr nakazuje wykonanie dwóch operacji: zapamiętanie adresu następnej instrukcji w rejestrze $ra (numer rejestru: 31), (tj. adresu instrukcji położonej w pamięci tuż za jal) zapisanie w rejestrze PC adresu wywoływanej funkcji (faddr) przykład High-Level Code int main() { simple();... } // void means the function returns no value void simple() { return; } MIPS x42 main: jal simple # call function x x412 simple: jr $ra # return MIPS: do przekazywania argumentów do funkcji można użyć rejestrów $a-$a3 (do czterech argumentów) MIPS: wartość funkcji można zwracać poprzez rejestry $v-$v1 przykład (z uwagi na efekt uboczny wymaga poprawy) High-Level Code int main() { int y;... y = diffofsums(2, 3, 4, 5);... } int diffofsums(int f, int g, int h, int i) { int result; result = (f + g) (h + i); return result; } MIPS # $s = y main:... addi $a, $, 2 # argument = 2 addi $a1, $, 3 # argument 1 = 3 addi $a2, $, 4 # argument 2 = 4 addi $a3, $, 5 # argument 3 = 5 jal diffofsums # call function add $s, $v, $ # y = returned value... # $s = result diffofsums: add $t, $a, $a1 # $t = f+g add $t1, $a2, $a3 # $t1 = h+i sub $s, $t, $t1 # result = (f + g) (h + i) add $v, $s, $ # put return value in $v jr $ra # return to caller c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 7 / 11 Stos Organizacja funkcji stos: struktura danych w pamięci zorganizowana na zasadzie LIFO (ang. last-in-first-out) służy m.in. do przechowywania zmiennych lokalnych funkcji rejestr $sp: wskaźnik wierzchołka stosu (ang. stack pointer) stos Address Data 7FFFFFFC FFFFFF8 7FFFFFF4 7FFFFFF $sp funkcja może jedynie zwracać wartość wywołującemu, nie może powodować żadnych, niezamierzonych innych efektów ubocznych prawidłowa organizacja funkcji: 1 prolog funkcji: utworzenie miejsca na stosie do przechowania kopii rejestrów 2 prolog funkcji: zapisanie zawartości rejestrów na stosie 3 ciało funkcji: swobodnie korzysta z rejestrów procesora 4 epilog funkcji: przywracanie wartości rejestrów procesora korzystając z ich kopii przechowywanej na stosie 5 epilog: zwolnienie obszaru stosu wykorzystywanego przez funkcję. MIPS: przed odłożeniem danej na stos rejestr $sp jest dekrementowany (stos rośnie w kierunku adresów malejących). c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

19 Ramka stosu Przykładowa funkcja ramka stosu (ang. stack frame): przestrzeń na stosie zorganizowana przez funkcję (dla niej i tylko dla niej) tworzenie kopii rejestrów w ramce stosu stos a) przed wywołaniem funkcji b) w trakcie działania funkcji c) po wykonaniu epilogu funkcji Address Data Address Data Address Data (a) FC F8 F4 F? $sp stack frame (b) FC F8 F4 F? $s $t $t1 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 $sp (c) FC F8 F4 F? $sp MIPS # $s = result diffofsums: addi $sp, $sp, 12 # make space on stack to store three registers sw $s, 8($sp) # save $s on stack sw $t, 4($sp) # save $t on stack sw $t1, ($sp) # save $t1 on stack add $t, $a, $a1 # $t = f+g add $t1, $a2, $a3 # $t1 = h+i sub $s, $t, $t1 # result = (f + g) (h + i) add $v, $s, $ # put return value in $v lw $t1, ($sp) # restore $t1 from stack lw $t, 4($sp) # restore $t from stack lw $s, 8($sp) # restore $s from stack addi $sp, $sp, 12 # deallocate stack space jr $ra # return to caller c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Rejestry chronione Przykładowa funkcja (zgodna z konwencją ochrony MIPS) konwencja MIPS: rejestry chronione (ang. preserved): rejestry $s-$s7 wywołana funkcja (ang. callee) musi utworzyć lokalną kopię, a przed powrotem do programu wywołującego ją (ang. caller), ma przywrócić ich poprzednią zawartość rejestry niechronione (ang. nonpreserved): $t-$t9 wywołana funkcja nie tworzy ich kopii lokalnej Preserved Saved registers: $s $s7 Return address: $ra Stack pointer: $sp Stack above the stack pointer Nonpreserved Temporary registers: $t $t9 Argument registers: $a $a3 Return value registers: $v $v1 Stack below the stack pointer jeśli wywołujący funkcję przechowuje istotne dane w rejestrach niechronionych, to na niego spada obowiązek utworzenia ich kopii przed wywołaniem, a potem przywrócenia stanu. c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 MIPS # $s = result diffofsums addi $sp, $sp, 4 # make space on stack to store one register sw $s, ($sp) # save $s on stack add $t, $a, $a1 # $t = f+g add $t1, $a2, $a3 # $t1 = h+i sub $s, $t, $t1 # result = (f + g) (h + i) add $v, $s, $ # put return value in $v lw $s, ($sp) # restore $s from stack addi $sp, $sp, 4 # deallocate stack space jr $ra # return to caller c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

20 Rekursywne wywoływanie funkcji Stos podczas rekursji funkcja może wywoływać inną funkcję, w szczególności samą siebie (ang. recursive function call) wywołujący przed wywołaniem funkcji tworzy kopię rejestrów niechronionych ($t-$t9 oraz $a-$a3), których zawartość jest potrzebna do kontynuacji po powrocie z funkcji wywoływana funkcja tworzy lokalną kopię rejestrów chronionych ($s-$s7 oraz $ra), których zawartość zamierza zmieniać przykład: silnia High-Level Code int factorial(int n) { if (n <= 1) return 1; else return (n * factorial(n 1)); } MIPS x9 factorial: addi $sp, $sp, 8 # make room on stack x94 sw $a, 4($sp) # store $a x98 sw $ra, ($sp) # store $ra x9c addi $t, $, 2 # $t = 2 OxAO slt $t, $a, $t # n <= 1? xa4 beq $t, $, else # no: goto else xa8 addi $v, $, 1 # yes: return 1 OxAC addi $sp, $sp, 8 # restore $sp OxBO jr $ra # return xb4 addi $a, # n = n else: $a, 1 1 xb8 jal factorial # recursive call OxBC Iw $ra, ($sp) # restore $ra OxCO Iw $a, 4($sp) # restore $a xc4 addi $sp, $sp, 8 # restore $sp xc8 mul $v, $a, $v # n * factorial(n 1) OxCC jr $ra # return a) przed wywołaniem funkcji, b) po ostatnim wywołaniu (n = 3), c) po kolejnych powrotach Address Data (a) FC F8 F4 F EC E8 E4 E DC $sp Address Data (b) FC F8 $a (x3) F4 $ra F $a (x2) EC $ra (xbc) E8 $a (x1) E4 $ra (xbc) E DC $sp $sp $sp $sp Address Data FC F8 $a (x3) F4 $ra F $a (x2) EC $ra (xbc) E8 $a (x1) E4 $ra (xbc) E DC (c) $sp $v = 6 $a = 3 $sp $v = 3 x 2 $a = 2 $sp $v = 2 x 1 $a = 1 $sp $v = 1 x 1 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Dodatkowe argumenty i zmienne lokalne funkcji jeśli funkcja ma więcej niż 4 argumenty, to kolejne przekazywane są poprzez stos wywołujący, przed wywołaniem funkcji, na swoim stosie umieszcza dodatkowe argumenty dla funkcji (we własnej ramce) wywoływana funkcja umieszcza swoje zmienne lokalne w rejestrach chronionych $s-$s7, a kolejne na stosie stos a) przed wywołaniem funkcji b) po wywołaniu additional arguments $sp stack frame additional arguments $a $a3 (if needed) $ra (if needed) $s $s7 (if needed) local variables or arrays $sp 1 Wstęp 2 Tryby adresowania 3 onstrukcja modelu programowego komputera Architektura ARM Architektury 64-bitowe 4 Literatura (a) (b) c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/216 8 / 11

21 Podział przestrzeni adresowej pamięci program po translacji należy załadować do pamięci i wskazać pierwszą z instrukcji maszynowych (ang. start executing) adres pamięci 32-bitowy: przestrzeń 4 GB MIPS: 4 segmenty pamięci segment kodu programu (ang. text segment) segment danych globalnych (ang. global data segment) segment danych dynamicznych (ang. dynamic data segment) segment zarezerwowany (ang. reserved segment): system operacyjny. Address xfffffffc x8 x7ffffffc x11 x1fffc x1 xffffffc x4 x3ffffc x Segment Reserved Stack Dynamic Data Heap Global Data Text Reserved $sp = x7ffffffc $gp = x18 PC = x4 typowe etapy przygotowania programu 1 kompilacja: translacja z języka wysokiego poziomu na język asemblera 2 asemblacja: translacja z języka asembler na język maszynowy 3 konsolidacja: łączenie modułów 4 ładowanie: umieszczenie kodu w pamięci uruchomienie programu polega na wpisaniu do PC adresu pierwszej instrukcji programu. High-Level Code Compiler Assembler Object File Linker Executable Loader Memory Object Files Library Files c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Przykład kompilacji Asemblacja High-Level 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); } MIPS.data f: g: y:.text main: addi $sp, $sp, 4 # make stack frame sw $ra, ($sp) # store $ra on stack addi $a, $, 2 # $a = 2 sw $a, f # f = 2 addi $a1, $, 3 # $a1 = 3 sw $a1, g # g = 3 jal sum # call sum function sw $v, y # y = sum(f, g) Iw $ra, ($sp) # restore $ra from stack addi $sp, $sp, 4 # restore stack pointer jr $ra # return to operating system sum: add $v, $a, $a1 # $v = a+b jr $ra # return to caller etap I przypisanie adresów do instrukcji x4 main: addi $sp, $sp, 4 x44 sw $ra, ($sp) x48 addi $a, $, 2 x4c sw $a, f x41 addi $a1, $, 3 x414 sw $a1, g x418 jal sum x41c sw $v, y x42 lw $ra, ($sp) x424 addi $sp, $sp, 4 x428 jr $ra x42c sum: add $v, $a, $a1 x43 jr $ra utworzenie tabeli symboli: nazwy zmiennych globalnych, etykiety Symbol f g Address x1 x14 etap II tworzenie kodu maszynowego zastępowanie symboli adresami z tabeli kod maszynowy wraz z tabelą symboli zapisywany do pliku typu object. y x18 main x4 sum x42c c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11

22 onsolidacja Plik wykonywalny konsolidacja (ang. linking): łączenie modułów typu object w pojedynczy plik, zawierający kod maszynowy gotowy do wykonania przez procesor (ang. executable) konsolidator ma za zadanie dokonać relokacji danych i kodu maszynowego zawartego w plikach object, tak by wyeliminować nakładanie się adresów w tym celu korzysta z tablic symboli obecnych w plikach object plik gotowy do wykonania ma trzy sekcje: nagłówek (ang. executable file header) kod maszynowy programu (ang. text segment) segment danych globalnych (ang. data segment) Executable file header Text Size Data Size x34 (52 bytes) xc (12 bytes) Text segment Address Instruction x4 x23bdfffc x44 xafbf x48 x242 x4c xaf848 x41 x253 x414 xaf8584 x418 xc1b x41c xaf8288 x42 x8fbf x424 x23bd4 x428 x3e8 x42c x8512 x43 x3e8 addi $sp, $sp, 4 sw $ra, ($sp) addi $a, $, 2 sw $a, x8($gp) addi $a1, $, 3 sw $a1, x84($gp) jal x42c sw $v, x88($gp) lw $ra, ($sp) addi $sp, $sp, 4 jr $ra add $v, $a, $a1 jr $ra w sekcji segmentu danych są adresy danych globalnych dostęp do danych globalnych za pomocą adresowania bazowego względem rejestru $gp zawierającego wartość x18. Data segment Address x1 x14 x18 Data f g y c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 Ładowanie i wykonanie programu 1 Wstęp system operacyjny ładuje program do pamięci i uruchamia go 1 kod maszynowy, z sekcji text pliku wykonywalnego, umieszcza w segmencie text pamięci 2 zapisuje do rejestru $gp wartość x18 3 zapisuje do rejestru $sp wartość x7ffffffc 4 wykonuje instrukcję wywołującą funkcję: jal x4 ostatnia instrukcja funkcji main, tj. jr $ra, o kodzie x3e8, zwraca sterowanie do systemu operacyjnego, czyli do segmentu reserved. Address x7ffffffc x11 x1 x4 Memory Reserved Stack Heap y g f x3e8 x8512 x3e8 x23bd4 x8fbf xaf8288 xc1b xaf8584 x253 xaf848 x242 xafbf x23bdfffc Reserved $sp = x7ffffffc $gp = x18 PC = x4 2 Tryby adresowania 3 onstrukcja modelu programowego komputera Architektura ARM Architektury 64-bitowe 4 Literatura c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11 c Dr inż. Ignacy Pardyka (Inf U J ) AS: architektura Rok akad. 215/ / 11