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

6 Pentium IA-32 software hardware IA-32

7 Maskinkode-niveauet Registre Lagermodellen Datatyper Maskininstruktioner Instruktionsformater Addresseringsformer

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

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

10 Registre

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

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.

13 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

14 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 X X

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

16 Instruktioner

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

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.

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

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: register Based indexedRegister indirekteIndexed

21 IA-32 Symbolsk Maskinsprog

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

27 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

28 Oversættelse og sammenkædning asld

29 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

30 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

31 Funktionskald

32 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 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 Stakafsnit esp ebp parametre old eip old ebp lokale variable esp ebp ebp + 4 ebp + 8 ebp bit

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

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

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

38 Initielt stakafsnit

39 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

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

41 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

42 Input/Output

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

44 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]) …

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

46 Returnering

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

48 Udvalgte systemkald

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

50 Kort opsummering

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

52 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

53 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