DMasArk1 Pentium IA-32 Maskinarkitekturen. dMasArk2 Historie (1).. starter i 1970 med udviklingen af Intel 4004:

Præsentationer af emnet: "DMasArk1 Pentium IA-32 Maskinarkitekturen. dMasArk2 Historie (1).. starter i 1970 med udviklingen af Intel 4004:"— Præsentationens transcript:

1 dMasArk1 Pentium IA-32 Maskinarkitekturen

2 dMasArk2 Historie (1).. starter i 1970 med udviklingen af Intel 4004:

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

4 dMasArk4 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: http://www.intel.com/design/Pentium4/documentation.htm

5 dMasArk5 Pentium IA-32 software hardware IA-32

6 dMasArk6 Maskinkode niveauet Registre. Lagermodellen. Datatyper. Maskininstruktioner. Instruktionsformater. Addresseringsformer.

7 dMasArk7 Registre 6 generel-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 dMasArk8 Registre

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

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

11 dMasArk11 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

12 dMasArk12 Heltals datatyper 2-komplement fortolkning: |W| 2 Standard fortolkning: |W|

13 dMasArk13 Instruktioner

14 dMasArk14

15 dMasArk15 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.

16 dMasArk16 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

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

18 dMasArk18 IA-32 Symbolsk Maskinsprog

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

20 dMasArk20 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)

21 dMasArk21 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]

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

23 dMasArk23 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 _start: # int main (void)

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

25 dMasArk25 Oversættelse og sammenkædning asld

26 dMasArk26 Oversættelse til maskinkode %>as –o ex2.o ex2.s %>objdump –D ex2.o 00000000 : 0:a1 00 00 00 00 mov 0x0,%eax 5:8b 1d 04 00 00 00 mov 0x4,%ebx b:39 c3 cmp %eax,%ebx d:7e 02 jle 11 f:eb 07 jmp 18 00000011 : 11:a3 08 00 00 00 mov %eax,0x8 16:eb 06 jmp 1e 00000018 : 18:89 1d 08 00 00 00 mov %ebx,0x8 0000001e : 1e:8b 1d 08 00 00 00 mov 0x8,%ebx 24:b8 01 00 00 00 mov $0x1,%eax 29:cd 80 int $0x80

27 dMasArk27 Sammenkædning (Linkning) %>ld –o ex2 ex2.o %>objdump –d ex2 Disassembly of section.text: 08048074 : 8048074:a1 a0 90 04 08 mov 0x80490a0,%eax 8048079:8b 1d a4 90 04 08 mov 0x80490a4,%ebx 804807f:39 c3 cmp %eax,%ebx 8048081:7e 02 jle 8048085 8048083:eb 07 jmp 804808c 08048085 : 8048085:a3 a8 90 04 08 mov %eax,0x80490a8 804808a:eb 06 jmp 8048092 0804808c : 804808c:89 1d a8 90 04 08 mov %ebx,0x80490a8 08048092 : 8048092:8b 1d a8 90 04 08 mov 0x80490a8,%ebx 8048098:b8 01 00 00 00 mov $0x1,%eax 804809d:cd 80 int $0x80

28 dMasArk28 Funktionskald

29 dMasArk29 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.

30 dMasArk30 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).

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

32 dMasArk32 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); }

33 dMasArk33.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

34 dMasArk34.type max, @function 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 popl %ebp # restore ebp ret # return m 3-4 6-8