Dagens tema. Flyt-tall. Koding. 64-bits kode. Hvordan lagres de? Hvordan regner man med dem? Koding av instruksjoner Kodefiler Linking

Transkript

1 Dagens tema Flyt-tall Hvordan lagres de? Hvordan regner man med dem? Koding Koding av instruksjoner Kodefiler Linking 64-bits kode

2 Hva er flyt-tall? Flyt-tall [REB&DRO H 2.4] Tall med desimalkomma kan skrives på mange måter: ,0 8, , De to siste ±M G E er såkalte flyt-tall og består av Mantisse («significand») (M). Grunntall («radix») (G). Eksponent (E). Fortegn. Her lagrer man selve tallet og størrelsen hver for seg. Fordelen er at man alltid har like mange tellende sifre.

3 Hva er flyt-tall? Representasjon av mantissen En desimalbrøk: 3, har desimaler. En binærbrøk: 11, har binærer. Brøken tolkes slik: 2 1 Resultatet er , = ,1406

4 Normalisering En normalisert mantisse er en binærbrøk med følgende egenskap: 1 M < G For binær representasjon innebærer dette at 1 M < 2 Det er altså alltid ett binært siffer foran binær-kommaet og det vil alltid være 1 (med mindre hele tallet er 0).

5 Elementene i et flyt-tall Eksponenten Eksponenten lagres normalt med et fast tillegg slik at vi alltid får et positivt tall. (Da kan vi bruke heltallssammenligning av positive flyt-tall.) Grunntallet Grunntallet er nesten alltid 2. Blir ikke lagret.

6 32-bits flyt-tall Standarden IEEE 754 for 32-bits flyt-tall S Eksponent Mantisse Grunntallet er 2. S er fortegnet; 0 for positivt, 1 for negativt. Eksponenten er på 8 bit og lagres med fast tillegg 127. Mantissen er helst normalisert og på 24 bit, men kun de 23 etter binærkommaet lagres.

7 Eksempler Hvorledes lagres 1,0? 1,0 10 = 1,0 2 som er normalisert. Eksponent er 0+127=127= Fortegnet er

8 Eksempler Hvordan lagres 0? Som spesialkonvensjon er 0 representert av kun 0-bit:

9 Eksempler Hvorledes lagres 12,8125? 12, = 1100, = 1, Eksponent er 3+127=130= Fortegnet er

10 Egenskaper Største tall er omtrent , (Eksponenten 0 er reservert for unormaliserte tall og tallet 0, eksponenten 255 for og NAN «not a number».)

11 Egenskaper Minste normaliserte positive tall er omtrent ,

12 Egenskaper Nøyaktighet Mantissen er på 24 bit, og , Dette gir 7 desimale sifre.

13 64-bits flyt-tall Standarden IEEE 754 for 64-bits flyt-tall S Eksponent Mantisse Endringer: Eksponenten er økt fra 8 til 11 bit. Lagres med fast tillegg Mantissen er økt fra 24 til 53 bit. Øverste bit lagres stadig ikke.

14 Egenskaper Største tall Det største tallet som kan lagres, finner vi utfra formelen 2 (211 2) = , Minste positive normaliserte tall = , Nøyaktighet Mantissen er på 53 bit, og , Dette gir nesten 16 desimale sifre.

15 Tap av presisjon Flyt-tall er alltid en tilnærming a n + b n = c n I følge Fermats siste teorem er det ingen heltallsløsninger for n > 2, men hva med #include <stdio.h> #include <math.h> = int main () { double a = 3987, an = pow(a,12), b = 4365, bn = pow(b,12), c = 4472, res = pow(an+bn,1.0/12); printf("12v(an+bn) = %g\n", res); printf("12v(an+bn) = %.14g\n", res); 12v(an+bn) = v(an+bn) = c = 4472 printf(" } c = %g\n", c);

16 Tap av presisjon Siden flyt-tall oftest bare er en tilnærmet verdi, kan dette lett gi uventede feil, spesielt ved subtraksjon. #include <stdio.h> int main (void) { int i; } for (i = 1; i <= ; i *= 10) { float v1 = (1.0/i); printf("%f\n", (v1-1.1)*i); } return 0; ( i 1.1) i

17 Intels FDVI-feil Et annet eksempel I 1994 kom Intel Pentium. Den hadde en ny algoritme med tabelloppslag som skulle forbedre ytelsen til det 3-dobbelte for flyt-tallsdivisjon. Dessverre ble 5 av 1066 verdier i tabellen uteglemt, og dette ga av og til en feil i 6. desimal: Q: How many Pentium designers does it take to screw in a light bulb? A:

18 Generelt om x87 Å regne med flyt-tall X86 har en egen flyt-tallsprosessor x87: Den har egne registre ST(0) ST(7) som brukes som en stakk; de inneholder double-verdier. 1 ST(0) (ofte bare kalt ST) er toppen. Den har egne instruksjoner. Den har egne flagg C0 C5. Parametre overføres på stakken (som vanlig). Returverdi fra funksjon legges i ST(0). 1 Egentlig lagrer de 80-bits flyt-tall på et eget format.

19 Diverse operasjoner Konstanter fldz fld1 # Dytter 0.0 på stakken. # Dytter 1.0 på stakken. Lese fra minnet/stakken flds var # Dytter float var på stakken fldl var # Dytter double var på stakken fld %st(1) # Dytter kopi av ST(x) på stakken Skrive til minnet/stakken fsts var # Skriver ST(0) til var som float fstl var # Skriver ST(0) til var som double fst %st(4) # Kopierer ST(0) til ST(x) fstps var # Som instruksjonene over, fstpl var # men popper stakken etterpå. fstp %st(5) #

20 Diverse operasjoner Konvertering X87 kan konvertere mellom heltall og flyt-tall: filds ivar # Dytter short var på stakken. fildl ivar # Dytter long var på stakken. fildq ivar # Dytter long long var på stakken. fists ivar # Skriver ST(0) til var som short fistl ivar # Skriver ST(0) til var som long fistps ivar # Popper stakken til var som short fistpl ivar # Popper stakken til var som long fistpq ivar # Popper stakken til var som long long Fortegnsoperasjoner fabs fchs # Gjør ST(0) positivt # Snu fortegnet på ST(0)

21 Diverse operasjoner Aritmetiske operasjoner fadds var # ST(0) += float var faddl var # ST(0) += double var fadd %st(4) # ST(0) += ST(x) faddp # ST(1) = ST(0)+ST(1); popp fiadds ivar # ST(0) += short ivar fiaddl ivar # ST(0) += long ivar Tilsvarende operasjoner finnes for subtraksjon, multiplikasjon og divisjon: fsubs var # ST(0) -= float var fmuls var # ST(0) *= float var fdivs var # ST(0) /= float var

22 Diverse operasjoner Sammenligninger ftst # Sammenlign ST(0) med 0.0 fcoms ivar # Sammenlign ST(0) med short var fcoml ivar # Sammenlign ST(0) med long var fcom %st(7) # Sammenlign ST(0) med ST(x) fcom fcomps ivar # Som de over, fcompl ivar # men popper etterpå. fcomp %st(7) # # Sammenlign ST(0) med ST(1) fcomp # fcompp # Som fcom men popper to ganger Resultatet havner i flaggene: C3 = 1 om ST(0) = op C0 = 1 om ST(0) < op

23 Diverse operasjoner Dessverre finnes ingen hopp som sjekker disse flaggene, men vi kan flytte dem over til x86 og teste der. Da havner C3 i Z-flagget og C0 i C-flagget..globl fnotzero # Navn: fnotzero. # Synopsis: Returnerer x, eller 1.0 om x er null. # C-signatur: float fnotzero (float x). fnotzero: pushl %ebp # Standard movl %esp,%ebp # funksjonsstart. flds 8(%ebp) # Dytt x på x87-stakken. ftst # Test mot 0.0. fstsw %eax # Overfør x87-flaggene til EAX sahf # og derfra til x86-flaggene. jnz fn_xit # Om x er null, fstp %st # popp x og fld1 # dytt 1.0 på x87-stakken. fn_xit: popl %ebp # ret # return SP(0).

24 Diverse operasjoner Andre Det finnes dusinvis av andre instruksjoner, som fsqrt # ST(0) = sqrt(st(0)) fyl2xp1 # ST(1) = ST(1)*log2(ST(0)+1.0) ; popp

25 Instruksjoner Koding [REB&DRO H 3.1 2].globl add, res.extern n add: pushl %ebp movl %esp,%ebp movl 8(%ebp),%eax a_x: addl n,%eax jz a_x movl %eax,res popl ret.data res:.long 0 %ebp #include <stdio.h> extern int add (int v); extern int res; int n = 17; int main (void) { printf("add(1) = %d", add(1)); printf(" res = %d\n", res); return 0; }

26 Instruksjoner Vi lager kode av add.s: $ gcc -m32 -Wa,-a -c add.s >add.list GAS LISTING add.s page 1 1.globl add, res 2.extern n add: pushl %ebp E5 movl %esp,%ebp 6 8(%ebp),%eax n,%eax B a_x: movl addl c 74F8 jz a_x e A movl %eax,res D popl %ebp C3 ret data res:.long 0 DEFINED SYMBOLS add.s:4 add.s:16 add.s:8.text: add.data: res.text: a_x UNDEFINED SYMBOLS n

27 Instruksjoner Hver x86-instruksjon lagres i 1 15 byte. pushl %ebp = 55 pushl = 50+reg %ebp = 5 addl n,%eax = addl = 3 %eax / minne = = = addr(n)

28 Instruksjoner Ellers kan vi legge merke til: Et navn angir en adresse som kan være enten kode eller data. Navnet a_x er lokalt. Navnene add og res er lokalt definert men globalt kjent. Navnet n antas å være globalt kjent og definert i en annen kodefil. Adressen er foreløbig ukjent. Siden avstanden fra jz til a_x er kjent, er den angitt med relativ adresse (F8 16 = 8).

29 .o-filer Kompilering/assemblering [REB&DRO H 7] En oversetter lager maskinkode i en.o-fil. En linker lager ferdig eksekverbar kode. Source files Relocatable object files main2.c vector.h Translators (cpp, cc1, as) main2.o libvector.a Linker (ld) p2 addvec.o libc.a Fully linked executable object file Static libraries printf.o and any other modules called by printf.o

30 .o-filer Kodefilen Kan.o-filen rett og slett være de genererte kode-bytene? Nei, av (minst) to grunner: 1 Eksterne referanser må kobles sammen. 1 add.o må fortelle at den trenger en n fra en annen.o-fil. 2 Den må også fortelle at den tilbyr add og res (om noen skulle være interessert). 2 Adressene (til både kode og data) må endres («relokeres»). Derfor må.o-filen opplyse om 1 Hvilke instruksjoner inneholder adresser som skal endres.

31 .o-filer ELF På Unix-maskiner lagres programkoden i formatet ELF («Executable and Linkable Format»). $ file add.s add.s: ASCII text $ file add.o add.o: ELF 32-bit LSB relocatable, Intel 80386, version 1 (SYSV), not stripped

32 .o-filer objdump forteller oss om hva filen inneholder: $ objdump -d add.o add.o: file format elf32-i386 Disassembly of section.text: <add>: 0: 55 push %ebp 1: 89 e5 mov %esp,%ebp 3: 8b mov 0x8(%ebp),%eax <a_x>: 6: add 0x0,%eax c: 74 f8 je 6 <a_x> e: a mov %eax,0x0 13: 5d pop %ebp 14: c3 ret $ objdump -r add.o add.o: file format elf32-i386 RELOCATION RECORDS FOR [.text]: OFFSET TYPE VALUE R_386_32 n f R_386_32 res

33 Kjørbar kode Kjørbar kode Til sist setter linkeren sammen alle kodefilene (*.o) og bibliotekene (*.a) til kjørbar kode. Eksterne referanser kobles sammen og adresser oppdateres. Source files main2.c vector.h Translators (cpp, cc1, as) libvector.a libc.a Static libraries Relocatable object files main2.o addvec.o printf.o and any other modules called by printf.o Linker (ld) p2 Fully linked executable object file

34 Kjørbar kode Det komplette bildet av minnet i Linux-prosesser ser slik ut: Kernel memory User stack (created at runtime) Memory invisible to user code %esp (stack pointer) Memory-mapped region for shared libraries Run-time heap (created by malloc) brk 0x Read/write segment (.data,.bss) Read-only segment (.init,.text,.rodata) Loaded from the executable file 0

35 Kjørbar kode Dynamiske biblioteker Mye kode er felles i mange prosesser: standardbiblioteker grafiske biblioteker Er det mulig å spare plass ved å la prosessene dele kode?

36 Kjørbar kode Om man bruker dynamiske biblioteker (.so-filer), vil det bare eksistere én kopi av hver enhet i minnet. main2.c Relocatable object file Translators (cpp, cc1, as) main2.o vector.h Linker (ld) libc.so libvector.so Relocation and symbol table info Partially linked executable object file p2 Loader (execve) libc.so libvector.so Fully linked executable in memory Dynamic linker (ld-linux.so) Code and data

37 Kjørbar kode For å få dette til å fungere, må koden i dynamiske biblioteker være reentrant slik at flere prosesser kan kjøre koden samtidig (dvs ingen variable i faste adresser) posisjonsuavhengig (= «PIC») slik at den kan plasseres hvor som helst i minnet (dvs kun relative adresser i hopp).

38 Hva er nytt? 64-bits kode [REB&DRO H 3.13] Omtrent alle pc-er i dag kjører en 64-bits kode x86-64 utviklet av AMD. Adresser er 64 bit. Flere registrene %R8 %R15, og alle registrene i 64-bits utgave. Operasjoner har også 64-bits varianter (som addq). Funksjonskall har en annen protokoll (AMD64 ABI for Linux og Mac, Microsoft x64 for Windows).

39 Hva er nytt? %EAX %AX %RAX %AH %AL %RBX %BH %BL %RCX %CH %CL %RDX %DH %DL %RBP %RSP %RDI %RSI %EBP %BP %BPL %SPL %DIL %SIL %R8D %R8W %R8 %R8B %R9 %R9B %R10 %R10B %R11 %R11B %R12 %R12B %R13 %R13B %R14 %R14B %R15 %R15B

40 Hva er nytt? Funksjonskall De seks første parametrene ligger i %RDI, %RSI, %RDX, %RCX, %R8, %R9 Øvrige parametre ligger på stakken. Parameterregistrene samt %R10 og %R11 er frie registre, de øvrige er bundne. Returverdien skal ligge i %RAX.

41 Hva er nytt? Et eksempel.globl sum64 #include <stdio.h> # Navn: sum64. # Synopsis: Summerer en array. extern long sum64 (long a[], long n); # C-signatur: long sum64 (long a[], long n). # Registre: %RDI a (1. parameter) long data[] = { 123, 10000, , , # %RSI n (2. parameter) , }; sum64: movq $0,%rax # Initier summen movq %rsi,%rcx # og telleren. s64_l: # Gå i løkke og addq -8(%rdi,%rcx,8),%rax loop s64_l # summer. ret # Ferdig. int main (void) { int size = sizeof(data)/sizeof(long); printf("svaret er %ld.\n", sum64(data,size)); } $ gcc -o test-sum64 test-sum64.c sum64.s $./test-sum64 Svaret er