1 Pentium IA-32 Maskinarkitekturen

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

3 Historie (2) Baglæns kompatibilitet tilbage til 8086.

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

Latest - Intel® Core™ i7-3930K Processor (12M Cache, 3.20 GHz, 6 Cores) 5 Essentials StatusLaunched Launch DateQ4'11 Processor Numberi7-3930K # of Cores6 # of Threads12 Clock Speed3.2 GHz Max Turbo Frequency3.8 GHz Intel® Smart Cache12 MB Bus/Core Ratio32 DMI5 GT/s Instruction Set64-bit Embedded Options AvailableNo Max TDP130 W Recommended Customer Price$583 - $594 Over two billion transistors, and "offer the processing power equivalent of approximately 365,000 Intel 4004 processors."

6 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:

7 Pentium IA-32 software hardware IA-32

8 Maskinkode-niveauet Registre Lagermodellen Datatyper Maskininstruktioner Instruktionsformater Addresseringsformer

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. 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,…

10 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,… IJVM LV SP PC

11 Registre

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

13 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.

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

15 Datatyper 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. Numeriske datatyper: X X

16 Heltals datatyper 2-komplement fortolkning: |W| 2 Standard fortolkning: |W|

17 Instruktioner

18 Nogle af de mere end 500 instruktioner i “Intel Syntax”

19 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.

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

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

Sidekvindeopgave 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 ?? 22

23 IA-32 Symbolsk Maskinsprog

24 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.

25 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)

26 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]

27 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

28 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 # start of text section.globl _start # _start is a global symbol # specifies start of program

29 IA-32 Symbolsk Maskinsprog (2) _start: # int main (void) movl a,%eax # movl b,%ebx # cmpl %eax,%ebx # compute b-a = b) jmp else if: movl %eax,m # m = a jmp endif Else: 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

30 Oversættelse og sammenkædning asld

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

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

33 Funktionskald

34 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.

35 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).

36 Stakafsnit esp ebp parametre old eip old ebp lokale variable esp ebp ebp + 4 ebp + 8 ebp bit

Sidekvindeopgave Pseudo (symbolsk) maskinsprog – Antag: 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 37

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

39.section.data x:.long 42 y:.long 53 z:.long 0.section.text.globl _start _start: # int main (void) pushl y # push y on stack pushl x # push x on stack call max # invoke max 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) IA-32 Funktionskald (1) 1-2 9

40.type max: # int max (long a,long b) pushl %ebp # push prev base pointer 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 = 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 locals) popl %ebp # restore ebp ret # return m

41 Initielt stakafsnit

42 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

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

44 Eksempel IA-32.section.data a:.long 0 b:.long 0 m:.long 0.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

45 Input/Output

46 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); }

47 Eksempel IA-32.section.data a:.long 0 b:.long 0 m:.long 0 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]) …

48 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)

49 Returnering

50 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)

51 Udvalgte systemkald

52 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.

53 Kort opsummering

54 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).

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

56 Funktionskald og stakafsnit Caller: 1.Læg parametre på stak. 2.Udfør call instruktionen. 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. old eip param n param 1 param 2 old ebp local 1 local 2 ebp esp ebp+8 ebp+12 ebp-4 ebp-8