Pentium IA-32 Maskinarkitekturen

Transkript

1 Pentium IA-32 Maskinarkitekturen 1

2 Historie (1) Starter i 1970 med udviklingen af Intel 4004: 2

3 Historie (2) Baglæns kompatibilitet tilbage til

4 Intel 4004 and Pentium Today several families/architectures (performance, power, cost) 4

5 Dokumentation Officiel dokumentation fra Intel (Pentium 4): Software Developer s Manual: Volume 1: Basic Architecture (450 pp). Volume 2A: Instruction Set Reference (A-M) (596 pp). Volume 2B: Instruction Set Reference (N-Z) (428 pp). Volume 3: System Programming Guide (836 pp). se endvidere: 5

6 Pentium IA-32 software IA-32 hardware 6

7 Maskinkode-niveauet Registre Lagermodellen Datatyper Maskininstruktioner Instruktionsformater Addresseringsformer 7

8 Registre 6 general-purpose 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 special purpose 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). Derudover et antal registre ifm. segmenter, MMX, FPU, 8

9 Registre 6 general-purpose 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. IJVM4 special purpose 32-bit registre: LV ebp Pointer register der udpeger aktuelt stakafsnit. SP esp Pointer register der udpeger staktoppen. PC eip programtælleren (instruction pointer). eflags status register (Program Status Word PSW). Derudover et antal registre ifm. segmenter, MMX, FPU, 9

10 Registre 10

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

12 Lagermodel Fysisk addresserum med bit (byte) celler (64Gbytes). Tre lagermodeller understøttes: Flad lagermodel: 4Gb lineært lager, byte addresserbart Program, data og stak i samme addresserum. Segmenteret lagermodel: 16,384 segmenter op til 4Gb/segment. Program, data og stak kan være i forskellige segmenter. Real-address mode: kompatibilitet med Unix/Linux udnytter ikke muligheder for segmentering. Derudover understøttes virtuel hukommelse og paging. 12

13 Linux IA-32 Lagermodellen Et 4Gb lineært, byte addresserbart lager opdelt i sektioner: stack 0xFFFFFFFF esp dynamisk lager (uallokeret) eip heap bss data text dynamisk lager (allokeret) uinitialiseret data (buffere) initialiseret data program 0x

14 Numeriske datatyper: Datatyper X X Pointer datatyper: Near pointer: 32 bit offset i segment. Far pointer: 48 bit segment selector (16) og offset (32). Bit fields: op til 32 bits Strenge: sekvens af bit/bytes/ord. 14

15 Heltals datatyper Standard fortolkning: W 2-komplement fortolkning: W 2 15

16 Instruktioner 16

17 Nogle af de mere end 500 instruktioner i Intel Syntax 17

18 Instruktionsformat Ved instruktioner med to operander er mindst en i register (REG). Lokation af operander bestemmes ud fra: SIB (Scale,Index,Base) og Displacement samt registre. Immediate bruges til konstanter. 18

19 Addresseringsformer MOD (2 bit) og R/M (3 bit) specificerer formen: Displacement specificerer offset i 8 bit (MOD=01) / 32 bit (MOD=10). SIB: Scale * Index + Base (+Displacement) 19

20 Addresseringsformer MOD (2 bit) og R/M (3 bit) specificerer formen: Register indirekte register Based indexed Indexed Displacement specificerer offset i 8 bit (MOD=01) / 32 bit (MOD=10). SIB: Scale * Index + Base (+Displacement) 20

21 Sidemandsopgave Pseudo (symbolsk) maskinsprog: Antag EAX 100 Hvad udføres? Mov 5 EAX?? Mov 5 M[EAX]?? Mov EAX M[EAX]?? Mov M[EAX+100] EAX?? 21

22 IA-32 Symbolsk Maskinsprog 22

23 IA-32 Symbolsk Maskinsprog Programmering i praksis i symbolsk maskinsprog. Der findes mange assemblers til IA-32 maskinkode: GAS as86 NASM, Anvender forskellig syntax: Intel Syntax AT&T Syntax GAS (GNU assembler, AT&T syntax) under Linux OS. 23

24 GAS AT&T Syntax (1) % 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 - double word (32 bit) 24

25 GAS AT&T Syntax (2) Immediate, register addressing: movl $42,%eax # eax = 42 Direct addressing: pushl ADDR # ADDR er en addresse Register indirect addressing, register addressing: movl (%ebp),%eax # eax = m[ebp] Indexed addressing, register addressing: movl 4(%ebp),%eax # eax = m[ebp+4] 25

26 C Program int main (void) { long a = 42; long b = 53; long m = 0; } if (a >= b) m = a; else m = b; exit(m); %>gcc o ex1 ex1.c %>./ex1 %>echo $? 53 26

27 IA-32 Symbolsk Maskinsprog (1).section.data # start of data section a:.long 42 # the variable a b:.long 53 # the variable b m:.long 0 # the variable m.section.text.globl _start # start of text section # _start is a global symbol # specifies start of program 27

28 IA-32 Symbolsk Maskinsprog (2) _start: # int main (void) movl a,%eax # movl b,%ebx # cmpl %eax,%ebx # compute b-a <=0 and # set eflags jle if # if (a >= b) jmp else if: Else: movl %eax,m # m = a jmp endif movl %ebx,m # m = b endif: movl m,%ebx # put return value in %ebx movl $1,%eax # opcode for exit system call int $0x80 # exit(m) (%ebx) via exit 28

29 Oversættelse og sammenkædning as ld 29

30 Oversættelse til maskinkode %>as o ex2.o ex2.s %>objdump D ex2.o <_start>: 0: a mov 0x0,%eax 5: 8b 1d mov 0x4,%ebx b: 39 c3 cmp %eax,%ebx d: 7e 02 jle 11 <if> f: eb 07 jmp 18 <else> <if>: 11: a mov %eax,0x8 16: eb 06 jmp 1e <endif> <else>: 18: 89 1d mov %ebx,0x e <endif>: 1e: 8b 1d mov 0x8,%ebx 24: b mov $0x1,%eax 29: cd 80 int $0x80 30

31 Sammenkædning (Linkning) %>ld o ex2 ex2.o %>objdump d ex2 Disassembly of section.text: <_start>: : a1 a mov 0x80490a0,%eax : 8b 1d a mov 0x80490a4,%ebx f: 39 c3 cmp %eax,%ebx : 7e 02 jle <if> : eb 07 jmp c <else> <if>: : a3 a mov %eax,0x80490a a: eb 06 jmp <endif> c <else>: c: 89 1d a mov %ebx,0x80490a <endif>: : 8b 1d a mov 0x80490a8,%ebx : b mov $0x1,%eax d: cd 80 int $0x80 31

32 Funktionskald 32

33 Funktionskald Stakken bruges til at implementere funktionskald. Maskininstruktionerne call og ret bruges: call A - læg næste eip på stakken og sæt eip = A. ret - sæt eip = top af stak og fjern øverste element. I visse tilfælde bruges maskininstruktionerne enter og leave. Konventionen fra C bruges: Application Binary Interface. 33

34 C kaldkonventionen 1. 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). 34

35 Stakafsnit 32 bit 32 bit ebp 1-4 esp 6-9 ebp esp parametre old eip old ebp lokale variable ebp + 8 ebp + 4 ebp

36 Pseudo (symbolsk) maskinsprog Antag: Sidemandsopgave MaxFunc (Par1, Par2, Par3) ESP = 100, EBP =120, EIP = 20 lige før der gøres klar til call MaxFunc call MaxFunc # (spm1) MaxFunc:... ret # (spm2). Spm1: Hvad er ESP, EBP, og EIP lige efter call MaxFunc dvs. efter pkt 2 men før pkt 3*? Spm2: Hvad er ESP, EBP, og EIP lige efter ret dvs. efter pkt 8 men før pkt 9? * Punkt 2 & 8 mht C-kaldkonventionen 36

37 C Funktioner int main (void) { long x = 42; long y = 53; long z = 0; } z = max(x,y); exit(z); int max (long a,long b) { long m = 0; } if (a >= b) m = a; else m = b; return m; 37

38 .section.data x:.long 42 y:.long 53 z:.long 0 IA-32 Funktionskald (1).section.text.globl _start _start: # int main (void) pushl y # push y on stack 1-2 pushl x # push x on stack call max # invoke max 9 addl $8,%esp # pop parameters from stack movl %eax,z # z = max(x,y) (%eax) movl z,%ebx # return value in ebx register movl $1, %eax # opcode for exit system call int $0x80 # return z (%ebx) 38

39 .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 6-8 movl %ebp,%esp # restore esp (remove locals) popl %ebp # restore ebp ret # return m 39

40 Initielt stakafsnit 40

41 C Eksempel int main (int argc, char *argv[]) { long a=0,b=0,m=0; a = atol(argv[1]); b = atol(argv[2]); if (a >= b) m = a; else m = b; } exit(m); %>./ex

42 Initielt stakafsnit Etableres af operativsystemet jvf. kommandolinie argumenter: 0x argn esp arg1 program navn #argumenter %>foo arg1 argn 42

43 .section.data a:.long 0 b:.long 0 m:.long 0 Eksempel IA-32.section.text.globl _start _start: # int main (void) pushl 8(%esp) call atol addl $4, %esp movl %eax,a # a = atol(argv[1]) pushl 12(%esp) call atol addl $4, %esp movl %eax,b # b = atol(argv[2]) movl a,%eax movl b,%ebx 43

44 Input/Output 44

45 Input/Output Standard biblioteker kan også bruges til input/output: int main (int argc, char *argv[]) { long a=0,b=0,m=0; a = atol(argv[1]); b = atol(argv[2]); if (a >= b) m = a; else m = b; } printf("max(%ld,%ld) = %ld\n",a,b,m); exit(0); 45

46 .section.data a:.long 0 b:.long 0 m:.long 0 Eksempel IA-32 formatstr:.ascii "max(%ld,%ld) = %ld\n\0".section.text.globl _start _start: # int main (void) pushl 8(%esp) # call atol # addl $4, %esp # movl %eax,a # a = atol(argv[1]) 46

47 Eksempel IA-32 endif: pushl m # maximum in m pushl b pushl a pushl $formatstr # addr of formatstr call printf # printf("max(%ld,%ld) = %ld\n",a,b,m); addl $16, %esp movl $0,%ebx # movl $1,%eax # int $0x80 # exit(0) 47

48 Returnering 48

49 Returning Foregår via systemkald implementeret af operativsystemet: endif: pushl m # maximum in m pushl b pushl a pushl $formatstr # addr of formatstr call printf # printf("max(%ld,%ld) = %ld\n",a,b,m); addl $16, %esp movl $0,%ebx # put return value in %ebx movl $1,%eax # opcode for exit system int $0x80 # exit(0) 49

50 Udvalgte systemkald 50

51 Operativsystemets funktioner Adminstrere maskinens resourcer for programmer: Process administration (process begreb og schedulering). Lager administration (virtuel hukommelse og addresserum). Filsystem (filer og directories). Administration af ydre enheder (input/output abstraktion). Service stilles til rådighed via systemkald. 51

52 Kort opsummering 52

53 IA-32 Registre 6 general-purpose 32-bit registre: eax, ebx ecx, edx esi, edi 4 special purpose 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). 53

54 Linux IA-32 Lagermodellen Et 4Gb lineært, byte addresserbart lager opdelt i sektioner: ebp esp eip stack heap bss data text 0xFFFFFFFF dynamisk lager (uallokeret) dynamisk lager (allokeret) uinitialiseret data (buffere) initialiseret data program 0x

55 Funktionskald og stakafsnit Caller: 1. Læg parametre på stak. 2. Udfør call instruktionen. esp Callee: 3. Etabler nyt stakafsnit. 4. Gør plads til lokale variable. 5. Udfør kroppen af funktionen. 6. Læg returværdi i eax registret. 7. Nedlæg stakafsnit. 8. Udfør ret instruktionen. Caller: 9. Fjern parametre fra stak. local 2 local 1 old ebp old eip param 1 param 2 param n ebp-8 ebp-4 ebp ebp+8 ebp+12 55