Pentium IA-32 Maskinarkitekturen

Pentium IA-32 Maskinarkitekturen 1

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

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

Intel 4004 and Pentium 4 http://www.intel.com/museum/archives/index.htm http://download.intel.com/products/roadmap/roadmap.pdf Today several families/architectures (performance, power, cost) 4

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

Pentium IA-32 software IA-32 hardware 6

Maskinkode-niveauet Registre Lagermodellen Datatyper Maskininstruktioner Instruktionsformater Addresseringsformer 7

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

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

Registre 10

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

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 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 8086. Unix/Linux udnytter ikke muligheder for segmentering. Derudover understøttes virtuel hukommelse og paging. 12

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 0x00000000 13

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

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

Instruktioner 16

Nogle af de mere end 500 instruktioner i Intel Syntax 17

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

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

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

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

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.globl _start # start of text section # _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 <=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

Oversættelse og sammenkædning as ld 29

Oversættelse til maskinkode %>as o ex2.o ex2.s %>objdump D ex2.o 00000000 <_start>: 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 <if> f: eb 07 jmp 18 <else> 00000011 <if>: 11: a3 08 00 00 00 mov %eax,0x8 16: eb 06 jmp 1e <endif> 00000018 <else>: 18: 89 1d 08 00 00 00 mov %ebx,0x8 0000001e <endif>: 1e: 8b 1d 08 00 00 00 mov 0x8,%ebx 24: b8 01 00 00 00 mov $0x1,%eax 29: cd 80 int $0x80 30

Sammenkædning (Linkning) %>ld o ex2 ex2.o %>objdump d ex2 Disassembly of section.text: 08048074 <_start>: 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 <if> 8048083: eb 07 jmp 804808c <else> 08048085 <if>: 8048085: a3 a8 90 04 08 mov %eax,0x80490a8 804808a: eb 06 jmp 8048092 <endif> 0804808c <else>: 804808c: 89 1d a8 90 04 08 mov %ebx,0x80490a8 08048092 <endif>: 8048092: 8b 1d a8 90 04 08 mov 0x80490a8,%ebx 8048098: b8 01 00 00 00 mov $0x1,%eax 804809d: 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 32 bit 32 bit ebp 1-4 esp 6-9 ebp esp parametre old eip old ebp lokale variable ebp + 8 ebp + 4 ebp - 4 35

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

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

.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

.type max, @function 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

Initielt stakafsnit 40

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); %>./ex5 42 53 41

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

.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

Input/Output 44

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

.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

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

Returnering 48

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

Udvalgte systemkald 50

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

Kort opsummering 52

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

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 0x00000000 54

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