Intel Core i7. Niels Olof Bouvin Institut for Datalogi Aarhus Universitet

Transkript

1 Intel Core i7 Niels Olof Bouvin Institut for Datalogi Aarhus Universitet 1

2 Oversigt Historie Maskinsprogsniveauet Symbolsk maskinsprog Funktionskald Argumentoverførsel & biblioteksfunktioner 2

3 Udviklingen af Intels processorer 3

4 Udviklingen af Intels processorer Moore s Curve 4

6 Core i7 Level 5 Problem-oriented language level Translation (compiler) Level 4 Assembly language level Translation (assembler) Level 3 Operating system machine level Partial interpretation (operating system) Level 2 Instruction set architecture level Interpretation (microprogram) or direct execution Level 1 Micro-architecture level Hardware Level 0 Digital logic level 6

7 Core i7 / AMD64 / x86-64 Level 5 Problem-oriented language level Translation (compiler) Software Level 4 Level 3 Assembly language level Translation (assembler) Operating system machine level Level 2 Instruction set architecture level Partial interpretation (operating system) x86-64 Hardware Level 1 Micro-architecture level Interpretation (microprogram) or direct execution Hardware Level 0 Digital logic level 7

8 Vigtige elementer på maskinkodeniveauet Central Processing Unit (CPU) Registre Control Unit Lagermodellen Datatyper Maskininstruktioner Arithmetic Logic Unit (ALU) Registers Input/Output devices Instruktionsformater Main Memory Disk Printer Addresseringsformer Bus 8

9 Register, bus og lager evolution 8080 A B C D H L 8-bit Address Bus 8-bit Data Bus Memory AX AH AL BX BH BL CX CH CL DX DH DL SP BP SI DI 20-bit Address Bus 16-bit Data Bus Memory segment ,535 EAX EBX ECX EDX ESP EBP ESI EDI AX AH AL BX BH BL CX CH CL DX DH DL SP BP SI DI 32-bit Address Bus 32-bit Data Bus Memory

10 IA-32 registre 6 generelle 32-bit registre EAX akkumulator for operander og resultater. EBX bruges oftest til pointere (lager adresser). ECX bruges specielt ifm. løkker. EDX bruges specielt ifm. multiplikation/division. ESI/EDI bruges specielt ifm. manipulation af strenge. 4 specielle 32-bit registre EBP Pointer register der udpeger aktuelt stakafsnit. ESP Pointer register der udpeger staktoppen. EIP programtælleren (instruction pointer). EFLAGS status register (Program Status Word PSW). Herudover diverse andre registre til FP, MMX, 10

11 Eksempel: EFLAGS register Fungerer som Program Status Word (PSW) CF OF overflow på ikke-negative heltals operationer overflow på heltals operationer 11

12 AMD64, aka x86-64: 64 bits brede registre R8 R9 R10 R11 R12 R13 R14 R15 Core i7 AX RAX EAX AH AL BX RBX EBX BH BL CX RCX ECX CH CL DX RDX EDX DH DL RSP ESP SP RBP EBP BP RSI ESI SI RDI EDI DI 48-bit Address Bus 64-bit Data Bus Memory TiB 12

13 Linux x86-64 lagermodel Et 256TB lineært, byte adressérbart lager opdelt i sektioner text svarer til method area på IJVM data til constant pool stack er som IJVMs stak RSP bss er afsat, endnu ikke brugt plads heap er tilgængeligt lager som kan benyttes efter behov heap er dét, som allokeres v.hj.a. malloc Uinitialiseret? har som udgangspunkt ikke nogen værdi behøver derfor ikke ligge i den udførbare fil RIP stack heap bss data text 0x00007FFF'FFFFFFFF dynamisk lager (uallokeret) dynamisk lager (allokeret) uinitialiseret data (buffere) initialiseret data program 0x '

14 Numeriske datatyper på x86-64 Type 8 bits 16 bits 32 bits 64 bits Signed Integer Unsigned integer Binary coded decimal integer Floating point Hertil kommer vektortyper, mv. 14

15 Intel IA-32 & x86-64/amd64 dokumentation Intels egen referencemanual 3020 sider AMD64 ABI referencemanual System V Application Binary Interface AMD64 Architecture Processor Supplement 128 sider omkring kaldkonventionerne til Linux 15

16 Nogle af de mere end 500 instruktioner 16

18 Programmering i x86 symbolsk maskinsprog Der findes mange assemblers til x86 maskinkode: GAS as86 NASM Anvender forskellig syntax: Intel Syntax AT&T Syntax GAS (GNU assembler, AT&T syntax) under Linux OS 18

19 AT&T vs Intel syntaks.l2: movl $6, %eax ; start k = 6 - i - j subl 12(%ebp), %eax ; eax = 6 - i subl 16(%ebp), %eax ; eax = 6 - i - j movl %eax, -12(%ebp); k = eax movl 8(%ebp), %eax ; start towers(n-1, i, k) decl %eax ; eax = n-1 subl $4, %esp pushl -12(%ebp) ; k pushl 12(%ebp) ; i pushl %eax ; n-1.l2: mov eax, 6 ; start k = 6 - i - j sub eax, DWORD PTR [ebp+12] ; eax = 6 - i sub eax, DWORD PTR [ebp+16] ; eax = 6 - i - j mov DWORD PTR [ebp-12], eax ; k = eax mov eax, DWORD PTR [ebp+8] ; start towers(n-1, i, k) dec eax ; eax = n-1 sub esp, 4 push DWORD PTR [ebp-12] ; k push DWORD PTR [ebp+12] ; i push eax ; n-1 Hvad er pænest? Smag og behag AT&T Intel 19

20 GAS syntaks % bruges til at referere til registre %ebp, %esp, %eax, %ebx,... $ bruges til konstanter (immediate addressing) $42, $53, $0xff,... Suffix på symbolske instruktioner giver størrelsen på operander b - byte (8 bit) w - word (16 bit) l - long word (32 bit) q-quad word (64 bit) (hvis man bruger 8-, 16- eller 32-bit operander, skal man bruge de matchende registre) 20

21 GAS syntaks Immediate, register addressing: movq $42,%rax # rax = 42 // flyt (kopiér, faktisk) 42 til rax Direct addressing: pushq %rax # push indholdet af rax på stakken Register indirect addressing, register addressing: movq (%rbp),%rax # rax = m[rbp] Indexed addressing, register addressing: movq 8(%rbp),%rax # rax = m[rbp+8] / husk 8 bytes alignment 21

22 find_max.c /* find_max.c */ #include <stdio.h> int main(int argc, char *argv[]) { long a = 53; long b = 42; long m = 0; if (a >= b) { m = a; } else { m = b; } > gcc find_max.c -o find_max >./find_max > echo $? 53 > indeholder returnkoden fra det netop afsluttede program } return m; 22

23 find_max.s.section.data a:.quad 53 b:.quad 42 m:.quad 0.section.text.global _start # start of data section # start of text section # make _start symbol visible > as find_max.s -o find_max.o > ld find_max.o -o find_max >./find_max > echo $? 53 > _start: pushq %rbp # save old rbp to stack movq %rsp,%rbp # set new value for rbp movq a,%rax # a to rax movq b,%rbx # b to rbx cmpq %rax,%rbx # compute b-a <=0 and set eflags jle if # if (a >= b) { jmp else if: movq %rax,m # m = a jmp endif # } else { else: movq %rbx,m # m = b # } endif: movq m,%rdi # put m in rdi movq $60,%rax # system call 60 is exit leave # clean up syscall # exit(m) 23

24 Oversættelse og sammenlinking as ld På Unix (herunder Linux) (og mange andre steder, f.eks. Wii og Playstation 3) anvendes formatet ELF (Executable and Linkable Format) til objektfiler og udførbare filer 24

25 > as find_max.s -o find_max.o > objdump -dxs find_max.o > find_max.elf Oversættelse til objektkode find_max_as.o: file format elf64-x86-64 find_max_as.o architecture: i386:x86-64, flags 0x : HAS_RELOC, HAS_SYMS start address 0x Sections: Idx Name Size VMA LMA File off Algn 0.text f **2 CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE 1.data **2 CONTENTS, ALLOC, LOAD, DATA 2.bss **2 ALLOC SYMBOL TABLE: l d.text text l d.data data l d.bss bss l.data a l.data b l.data m b l.text if l.text else d l.text endif g.text _start Contents of section.text: e5 488b b1c25 UH..H..%...H..% c37e 02eb0a H9.~...H..% eb c b3c...H..%...H.< c7c0 3c c90f05 %...H..<... Contents of section.data: a * A s adresse B s adresse Disassembly of section.text: <_start>: 0: 55 push %rbp 1: e5 mov %rsp,%rbp 4: 48 8b mov 0x0,%rax b: 00 8: R_X86_64_32S.data c: 48 8b 1c mov 0x0,%rbx 13: 00 10: R_X86_64_32S.data+0x8 14: c3 cmp %rax,%rbx 17: 7e 02 jle 1b <if> 19: eb 0a jmp 25 <else> b <if>: 1b: mov %rax,0x0 22: 00 1f: R_X86_64_32S.data+0x10 23: eb 08 jmp 2d <endif> <else>: 25: c mov %rbx,0x0 2c: 00 29: R_X86_64_32S.data+0x d <endif>: 2d: 48 8b 3c mov 0x0,%rdi 34: 00 31: R_X86_64_32S.data+0x10 35: 48 c7 c0 3c mov $0x3c,%rax 3c: c9 leaveq 3d: 0f 05 syscall 25

26 Indskudt sætning: Little- og Big-Endian Man kan arrangere bytes i words på to måder, little- og big-endian: Big-endian: De mest betydende bytes kommer først ₁₆ = 53₁₀ 03 e8₁₆ = 1000₁₀ Little-endian: De mindst betydende bytes kommer først ₁₆ = 53₁₀ e8 03₁₆ = 1000₁₀ Intel er little-endian, så derfor skrives bs værdi (42 10 ) som 2a Så længe man holder sig til én maskinearkitektur, er der ingen problemer men det er noget, som man skal være opmærksom på, når man udveksler data mellem forskellige maskinarkitekturer 26

27 Assembly, sammenlinking og disassembly > ld find_max.o -o find_max > objdump -dxs find_max > find_max.elf find_max_as: file format elf64-x86-64 find_max_as architecture: i386:x86-64, flags 0x : EXEC_P, HAS_SYMS, D_PAGED start address 0x b0 Program Header: LOAD off 0x vaddr 0x paddr 0x align 2**21 filesz 0x ef memsz 0x ef flags r-x LOAD off 0x f0 vaddr 0x f0 paddr 0x f0 align 2**21 filesz 0x memsz 0x flags rw- Sections: Idx Name Size VMA LMA File off Algn 0.text f b b b0 2**2 CONTENTS, ALLOC, LOAD, READONLY, CODE 1.data f f f0 2**2 CONTENTS, ALLOC, LOAD, DATA SYMBOL TABLE: b0 l d.text text f0 l d.data data f0 l.data a f8 l.data b l.data m cb l.text if d5 l.text else dd l.text endif b0 g.text _start g *ABS* bss_start g *ABS* _edata g *ABS* _end Contents of section.text: 4000b e5 488b0425 f b1c25 UH..H..%..`.H..% A s adresse 4000c0 f c37e 02eb0a `.H9.~...H..%. 4000d eb c b3c.`...H..%..`.H.< 4000e c7c0 3c c90f05 %..`.H..<... Contents of section.data: 6000f a * Disassembly of section.text: b0 <_start>: 4000b0: 55 push %rbp 4000b1: e5 mov %rsp,%rbp 4000b4: 48 8b f mov 0x6000f0,%rax 4000bb: bc: 48 8b 1c 25 f mov 0x6000f8,%rbx 4000c3: c4: c3 cmp %rax,%rbx 4000c7: 7e 02 jle 4000cb <if> 4000c9: eb 0a jmp 4000d5 <else> cb <if>: 4000cb: mov %rax,0x d2: d3: eb 08 jmp 4000dd <endif> d5 <else>: 4000d5: c mov %rbx,0x dc: dd <endif>: 4000dd: 48 8b 3c mov 0x600100,%rdi 4000e4: e5: 48 c7 c0 3c mov $0x3c,%rax 4000ec: c9 leaveq 4000ed: 0f 05 syscall B s adresse 27

28 find_max.s: Take Two.section.data a:.quad 53 b:.quad 42 m:.quad 0.section.text.global main # start of data section # start of text section # make main symbol visible > gcc find_max.s -o find_max >./find_max > echo $? 53 > main: pushq %rbp # save old rbp to stack movq %rsp,%rbp # setup new base pointer movq a,%rax # a to rax movq b,%rbx # b to rbx cmpq %rax,%rbx # compute b-a <=0 and set eflags jle if # if (a >= b) { jmp else if: movq %rax,m # m = a jmp endif # } else { else: movq %rbx,m # m = b # } endif: movq m, %rax # put m in rax leave # clean up ret # return m (rax) Typisk anvender man ikke as og ld seperat, da gcc kan håndtere det hele Da er konventionerne en smule anderledes hovedfunktionen hedder main, og man bruger blot ret med exit koden i rax 28

30 Standarder for funktionskald For en given platform (en kombination af CPU og operativsystem) eksisterer konventioner for, hvorledes funktioner/procedurer/metoder kaldes vi ser i denne sammenhæng på Linux og på x86 processorer Kaldkonventionen har ændret sig fra IA-32 til x86-64 processoren har nu mange registre, hvilket ikke var tilfældet før 30

31 IA-32 Funktionskald Stakken bruges til funktionskald med IA-32 s lange historie og mange forskellige operativsystemer, så er der faktisk en del forskellige måder at kalde funktioner på, men vi vil prøve at holde os til stakken og Unix/Linux Ikke ulig invokevirtual og return, så har IA-32 instruktionerne call og ret call A læg næste eip på stakken, og sæt eip=a ret sæt eip=staktop og fjern det øverste element Dette er konventionen for C, og da Unix (og dermed Linux) er skrevet i C, er det den rigtige måde at gøre det på i Linux 31

32 C kaldkonventionen: IA-32 ebp Læg parametre på stak i omvendt rækkefølge (caller) 2. Kald funktion via call instruktionen (caller) 3. Etabler stakafsnit (manipulering af ebp og esp) (callee) 4. Gør plads til eventuelle lokale variable (callee) 5. Udfør kroppen af funktionen (callee) 6. Læg returværdi i eax registret (callee) 7. Nedlæg stakafsnit (manipulation af ebp og esp) (callee) 8. Returner fra kald via ret instruktionen (callee) 9. Fjern parametre fra stak (caller) esp ebp esp 6-9 parametre ebp+8 gammel eip ebp+4 gammel ebp lokale variabler ebp-4 32

33 find_max2.c nu med funktion! /* find_max2.c */ #include <stdio.h> long find_max(long a, long b) { long m = 0; int main(int argc, char *argv[]) { long a = 42; long b = 53; long r = 0; r = find_max(a, b); if (a >= b) { m = a; } else { m = b; } } return r; } return m; 33

34 find_max2.s - IA-32.section.data x:.long 42 y:.long 53 r:.long 0.section.text.global _start _start: pushl y pushl x call max addl $8,%esp movl %eax,r movl r,%ebx movl $1, %eax int $0x80 # int main (void) # push y on stack # push x on stack # invoke max # pop parameters from stack # r = max(x,y) (%eax) # return value in ebx register # opcode for exit system call # return r (%ebx).type max: # int max (long a,long b) pushl %ebp # push prev base pointer 3-4 movl %esp,%ebp # setup new base pointer subl $4,%esp # local variable m movl $0,-4(%ebp) # m = 0 movl 8(%ebp),%eax # load a into eax movl 12(%ebp),%ebx # load b into ebx cmpl %eax,%ebx # compute b-a <=0, # set eflags jle if # if (a >= b) jmp else if: movl %eax,-4(%ebp) # m = a jmp endif else: movl %ebx,-4(%ebp) # m = y endif: movl -4(%ebp),%eax # return value in %eax movl %ebp,%esp # restore esp (remove 6-8 # locals) popl %ebp # restore ebp ret # return m 34

35 Funktionskald: x86-64 Platform Return Value Parameter Registers Seks registre afsættes til argumenter, ni registre kan frit benyttes registre er ~100 gange hurtigere end RAM Yderligere argumenter puttes på stakken Da der kún er de samme registre, skal man være disciplineret om anvendelse hvis man bruger Preserved Registers (også kaldet Callee Save ), skal man genskabe dem, inden man returnerer Stakken holdes 16-bytes aligned Returnværdier i rax og rdx Additional Parameters Stack Alignment Scratch Registers Preserved Registers System V i386 eax, edx none stack (right to left) eax, ecx, edx ebx, esi, edi, ebp, esp System V X86_64 rax, rdx rdi, rsi, rdx, rcx, r8, r9 stack (right to left) 16-byte at call rax, rdi, rsi, rdx, rcx, r8, r9, r10, r11 rbx, rsp, rbp, r12, r13, r14, r15 ARM r0, r1 r0, r1, r2, r3 stack 8 byte r0, r1, r2, r3, r12 r4, r5, r6, r7, r8, r9, r10, r11, r13, r14 35

36 C kaldkonventionen: x Gem registre på stakken, om nødvendigt (caller) 2. Fyld parametre i registrene rdi,rsi,rdx,rcx,r8,r9 (caller) rbp 3. Læg overskydende parametre på stak i omvendt rækkefølge (caller) Kald funktion via call instruktionen (caller) Etabler stakafsnit (manipulering af rbp og rsp) (callee) rsp 6. Gør plads til eventuelle lokale variable (callee) (husk 16-byte alignment) 7. Gem Callee-Save registre, om nødvendigt (callee) 8. Udfør kroppen af funktionen (callee) rdi 9. Læg returværdi i rax samt (evt.) rdx (callee) rsi 10. Genskab gemte registreværdier, om nogen (callee) rdx 11. Nedlæg stakafsnit via leave instruktionen (callee) rcx rbp 12. Returner fra kald via ret instruktionen (callee) r8 13. Læs returnværdi fra rax, samt (evt.) rdx (caller) r9 14. Genskab gemte registreværdier fra stakken, om nogen (caller) rsp ekstra parametre rbp+16 gammel rip rbp+8 gammel rbp lokale variabler rbp-8 36

37 find_max2.s - x86-64: (ineffektiv udgave).section.data a:.quad 53 b:.quad 42 m:.quad 0.section.text.global main # start of data section # start of text section # make main symbol visible main: pushq %rbp # save old rbp to stack movq %rsp,%rbp # set new value for rbp movq %rax,m movq a,%rdi # a to rdi (first argument) movq b,%rsi # b to rsi (2nd argument) call max leave ret # return m (rax) max: push %rbp # push prev. base pointer 5-7 movq %rsp,%rbp # setup new base pointer subq $32,%rsp # need 24, but 16-aligned movq %rdi,-8(%rbp) # save a movq %rsi,-16(%rbp) # save b movq $0,-24(%rbp) # init m movq -8(%rbp),%rax # a movq -16(%rbp),%rbx # b cmpq %rax,%rbx # if (a >= b) { jle if # jmp else if: movq %rax,-24(%rbp) # m = a jmp endif # } else { else: movq %rbx,-24(%rbp) # m = b endif: movq -24(%rbp),%rax # copy m to rax # } 9-12 leave # clean up ret # return m (rax) 37

38 find_max2.s - x86-64: (mindre ineffektiv udgave).section.data a:.quad 53 b:.quad 42.section.text.global main # start of data section # start of text section # make main symbol visible main: pushq %rbp # save old rbp to stack movq %rsp,%rbp # set new value for rbp movq a,%rdi # a to rdi (first argument) movq b,%rsi # b to rsi (second argument) call max leave ret # return m (rax) max: push %rbp # push previous base pointer movq %rsp,%rbp # setup new base pointer cmpq %rdi,%rsi # if (a >= b) { jle if # jmp else if: movq %rdi,%rax # m = a jmp endif # } else { else: movq %rsi,%rax # m = b # } endif: leave # clean up ret # return m (rax) Med masser af registre til rådighed, er der ingen grund til at unødigt bruge stakken 38

40 Programkald Som med IJVM kan man give kommandolinjeargumenter til sit program > find_max3 8 9 Hvordan overføres de af operativsystemet til vores program? i registrene og i hukommelsen 40

41 Biblioteksfunktioner og systemkald Et operativsystem kommer med standardbiblioteker og systemkald, der kan udføre mange funktioner for os Standardbiblioteket kræver, at man instruerer ld korrekt: ld find_max3.o -dynamic-linker /lib/ld-linux.so.2 -lc -o find_max3 I praksis er det langt det nemmeste at bruge gcc i stedet for as/ld Standardbiblioteksfunktioner kaldes v.hj.a. C call konventionen som almindelige funktioner (seks parametre i registerne, resten på stakken) Systemkald foregår via argumenter i registrene og instruktionen syscall Systemkaldets kode placeres (forvirrende nok) i rax, og argumenter i rdi,rsi,rdx,r10,r8,r9 0x60 er koden for systemkaldet exit, og argumentet placeres i rdi 41

42 Det initielle kald Fra kommandolinjen kaldes et program med en række argumenter Bemærk signaturen på et C programs main funktion: int main(int argc, char *argv[]) rdi indeholder argc og rsi indeholder argv Argumenterne peger på null-terminerede strenge dvs. almindelige C strenge 0x argument n argument 2 argument 1 programnavn rdi: #argumenter rsi: pointer array 42

43 find_max3.c /* find_max3.c */ #include <stdio.h> #include <stdlib.h> long long find_max(long long a, long long b) { long long m = 0; int main(int argc, char *argv[]) { long long a = 0; long long b = 0; long long r = 0; a = atol(argv[1]); b = atol(argv[2]); if (a >= b) { m = a; } else { m = b; } } r = find_max(a, b); return r; } return m; > gcc find_max3.c -o find_max3 >./find_max3 8 9 ; echo $? 9 43

44 find_max3.s.section.data argc:.quad 0 argv:.quad 0 a:.quad 0 b:.quad 0.section.text.global main # start of data section # start of text section # make main symbol visible main: pushq %rbp # save old rbp to stack movq %rsp,%rbp # set new value for rbp movq %rdi, argc # save argc movq %rsi, argv # save argv movq 8(%rsi), %rdi # first argument call atol movq %rax, a # save a's value movq argv, %rax # get argv back movq 16(%rax),%rdi # second argument call atol movq %rax, b # save b's value movq a,%rdi # get a back movq %rax,%rsi # b still in rax call max leave ret # return m (rax) max: push %rbp # push previous base pointer movq %rsp,%rbp # setup new base pointer cmpq %rdi,%rsi # if (a >= b) { jle if # jmp else if: movq %rdi,%rax # m = a jmp endif # } else { else: movq %rsi,%rax # m = b # } endif: leave # clean up ret # return m (rax) > gcc find_max3.s -o find_max3 >./find_max3 8 9 ; echo $? 9 44

45 Sammenblanding af C og symbolsk maskinkode I praksis har man sjældent lyst til at skrive hele sit program i symbolsk maskinkode C og andre højniveausprog er langt lettere at have med at gøre Heldigvis understøtter f.eks. C, at man har funktioner skrevet i symbolsk maskinkode nemt at gøre, fordi der er en kaldkonvention, og så længe den overholdes er alting godt 45

46 find_max.s og find_max4.c.section.text.global find_max find_max: push %rbp # push previous base pointr movq %rsp,%rbp # setup new base pointer cmpq %rdi,%rsi # if (a >= b) { jle if # jmp else if: movq %rdi,%rax # m = a jmp endif # } else { else: movq %rsi,%rax # m = b # } endif: leave # clean up ret # return m (rax) #include <stdio.h> #include <stdlib.h> extern long long find_max(long long a, long long b); int main(int argc, char *argv[]) { long long a, b, r; a = atol(argv[1]); b = atol(argv[2]); r = find_max(a, b); } return r; > gcc find_max4.c find_max.s -o find_max4 >./find_max4 8 9 ; echo $? 9 46

47 Systemkald i find_max.s.section.data a:.quad 53 b:.quad 42 m:.quad 0.section.text.global _start # start of data section # start of text section # make _start symbol visible > as find_max.s -o find_max.o > ld find_max.o -o find_max >./find_max > echo $? 53 > _start: pushq %rbp # save old rbp to stack movq %rsp,%rbp # set new value for rbp movq a,%rax # a to rax movq b,%rbx # b to rbx cmpq %rax,%rbx # compute b-a <=0 and set eflags jle if # if (a >= b) { jmp else if: movq %rax,m # m = a jmp endif # } else { else: movq %rbx,m # m = b # } endif: movq m,%rdi # put m in rdi movq $60,%rax # system call 60 is exit leave # clean up syscall # exit(m) 47

48 Forskellige systemkald Name rax rdi rsi rdx r10 r8 r9 Description sys_exit 60 int terminate the current process sys_read 0 uint ch* size_t read from file descriptor sys_write 1 uint ch* size_t write to file descriptor sys_open 2 ch* int int open / create file or device sys_close 3 uint close a file descriptor 48

49 find_max.s og find_max5.c med output!.section.text.global find_max find_max: push %rbp # push previous base pointr movq %rsp,%rbp # setup new base pointer cmpq %rdi,%rsi # if (a >= b) { jle if # jmp else if: movq %rdi,%rax # m = a jmp endif # } else { else: movq %rsi,%rax # m = b # } endif: leave # clean up ret # return m (rax) #include <stdio.h> #include <stdlib.h> extern long long find_max(long long a, long long b); int main(int argc, char *argv[]) { long long a, b, r; a = atol(argv[1]); b = atol(argv[2]); r = find_max(a, b); printf("max(%lld,%lld) = %lld\n",a,b,r); } return 0; > gcc find_max5.c find_max.s -o find_max5 >./find_max5 8 9 max(8,9) = 9 49

50 find_max2.s og find_max5.c: Conditional move.section.text.global find_max find_max: push %rbp # push previous base pointr movq %rsp,%rbp # setup new base pointer cmpq %rdi, %rsi # b-a? cmovge %rsi, %rdi # if 0: overwrite a with b movq %rdi, %rax # max rax leave # clean up ret # return max #include <stdio.h> #include <stdlib.h> extern long long find_max(long long a, long long b); int main(int argc, char *argv[]) { long long a, b, r; a = atol(argv[1]); b = atol(argv[2]); r = find_max(a, b); printf("max(%lld,%lld) = %lld\n",a,b,r); } return 0; > gcc find_max5.c find_max2.s -o find_max5 >./find_max5 8 9 max(8,9) = 9 50

51 Opsummering AMD64/x86-64 er en registermaskine man regner i registrene, og som regel får man argumenter/resultater i registre Linux på AMD64/x86-64 har konventioner for typiske funktionskald, herunder standardbiblioteket, samt for systemkald f.eks. hvilke registre, man må bruge, og 16-byte alignment af stakken Kald af funktioner kræver forberedelse, orden og oprydning overholder man ikke reglerne, går det galt Overgangen fra få registre til mange registre gør mange ting langt enklere en tiltrængt modernisering udført af Intels konkurrent! Det gør livet langt enklere, at man kan blande C og symbolsk maskinsprog 51

52 Ugeopgave 5 52