1 / 53

Pentium IA-32 Maskinarkitekturen

Pentium IA-32 Maskinarkitekturen. Historie (1). Starter i 1970 med udviklingen af Intel 4004:. Historie (2). Bagl æns kompatibilitet tilbage til 8086. Intel 4004 and Pentium 4. http://www.intel.com/museum/archives/index.htm. Dokumentation. Officiel dokumentation fra Intel (Pentium 4):

helki
Download Presentation

Pentium IA-32 Maskinarkitekturen

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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 http://www.intel.com/museum/archives/index.htm

  5. Dokumentation • Officiel dokumentation fra Intel (Pentium 4): • Software Developer’sManual: • 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

  6. Pentium IA-32 software IA-32 hardware

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

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

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

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

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

  20. register Based indexed Register indirekte Indexed 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)

  21. IA-32Symbolsk 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 intmain (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 sectiona: .long 42 # the variable ab: .long 53 # the variable bm: .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 <=0 and # set eflags jle if # if (a >= b) jmp else if: movl %eax,m # m = ajmp 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 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,0x80000001e <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,0x80490a808048092 <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 • Læg parametre på stak i omvendt rækkefølge (caller). • Kald funktion via callinstruktionen (caller). • Etabler stakafsnit (manipulering af ebp og esp) (callee). • Gør plads til eventuelle lokale variable (callee). • Udfør kroppen af funktionen (callee). • Læg returværdi i eax registret (callee). • Nedlæg stakafsnit (manipulation af ebp og esp) (callee). • Returner fra kald via ret instruktionen (callee). • Fjern parametre fra stak (caller).

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

  35. C Funktioner intmain (void){long x = 42;long y = 53;long z = 0; z = max(x,y);exit(z);} intmax (long a,long b){long m = 0;if (a >= b) m = a;else m = b;return m;}

  36. 1-2 IA-32 Funktionskald (1) .section .datax: .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) 9

  37. 3-4 .type max, @functionmax: # 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 <=0, set eflags jle if # if (a >= b) jmp elseif: 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 6-8

  38. Initielt stakafsnit

  39. C Eksempel intmain (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

  40. Initielt stakafsnit Etableres af operativsystemet jvf. kommandolinie argumenter: 0x00000000 argN arg1 program navn esp #argumenter %>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 intmain (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);} Standard biblioteker kan også bruges til input/output:

  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

More Related