Data Representa/ons: IA32 + x86-64

Transcription

1 X86-64 Instruc/on Set Architecture Instructor: Sanjeev Se(a 1 Data Representa/ons: IA32 + x86-64 Sizes of C Objects (in Bytes) C Data Type Typical 32- bit Intel IA32 x86-64 unsigned int long int char short float double long double 8 10/12 16 char * Or any other pointer 2 1

2 x86-64 Integer Registers %rax %eax %r8 %r8d %rbx %ebx %r9 %r9d %rcx %ecx %r10 %r10d %rdx %edx %r11 %r11d %rsi %esi %r12 %r12d %rdi %edi %r13 %r13d %rsp %esp %r14 %r14d %rbp %ebp %r15 %r15d Extend exis(ng registers. Add 8 new ones. Make %ebp/%rbp general purpose 3 Instruc/ons Long word l (4 Bytes) Quad word q (8 Bytes) New instruc/ons: movl movq addl addq sall salq etc. 32- bit instruc/ons that generate 32- bit results Set higher order bits of des(na(on register to 0 Example: addl 4 2

3 Swap in 32- bit Mode void swap(int *xp, int *yp) int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; swap: pushl %ebp movl %esp,%ebp pushl %ebx movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp Setup Body Finish 5 Swap in 64- bit Mode void swap(int *xp, int *yp) int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; swap: movl (%rdi), %edx movl (%rsi), %eax movl %eax, (%rdi) movl %edx, (%rsi) q Operands passed in registers (why useful?) First (xp) in %rdi, second (yp) in %rsi 64- bit pointers No stack opera/ons required 32- bit data Data held in registers %eax and %edx movl opera(on 6 3

4 Swap Long Ints in 64- bit Mode void swap_l (long int *xp, long int *yp) long int t0 = *xp; long int t1 = *yp; *xp = t1; *yp = t0; swap_l: movq (%rdi), %rdx movq (%rsi), %rax movq %rax, (%rdi) movq %rdx, (%rsi) q 64- bit data Data held in registers %rax and %rdx movq opera(on q stands for quad- word 7 Reading Condi/on Codes: x86-64 SetX Instruc/ons: Set single byte based on combina(on of condi(on codes Does not alter remaining 3 bytes int gt (long x, long y) urn x > y; long lgt (long x, long y) urn x > y; Body (same for both) xorl %eax, %eax # eax = 0 cmpq %rsi, %rdi # Compare x and y setg %al # al = x > y 8 4

5 Reading Condi/on Codes: x86-64 SetX Instruc/ons: Set single byte based on combina(on of condi(on codes Does not alter remaining 3 bytes int gt (long x, long y) urn x > y; long lgt (long x, long y) urn x > y; Body (same for both) xorl %eax, %eax # eax = 0 cmpq %rsi, %rdi # Compare x and y setg %al # al = x > y Is %rax zero? Yes: 32- bit instruc(ons set high order 32 bits to 0! 9 Condi/onals: x86-64 int absdiff( int x, int y) int result; if (x > y) result = x-y; else result = y-x; urn result; absdiff: # x in %edi, y in %esi movl %edi, %eax # eax = x movl %esi, %edx # edx = y subl %esi, %eax # eax = x-y subl %edi, %edx # edx = y-x cmpl %esi, %edi # x:y cmovle %edx, %eax # eax=edx if <= 10 5

6 Condi/onals: x86-64 int absdiff( int x, int y) int result; if (x > y) result = x-y; else result = y-x; urn result; absdiff: # x in %edi, y in %esi movl %edi, %eax # eax = x movl %esi, %edx # edx = y subl %esi, %eax # eax = x-y subl %edi, %edx # edx = y-x cmpl %esi, %edi # x:y cmovle %edx, %eax # eax=edx if <= Condi/onal move instruc/on cmovc src, dest Move value from src to dest if condi(on C holds More efficient than condi(onal branching (simple control flow) But overhead: both branches are evaluated 11 General Form with Condi/onal Move C Code val = Test? Then- Expr : Else- Expr; Condi/onal Move Version val1 = Then- Expr; val2 = Else- Expr; val1 = val2 if!test; Both values get computed Overwrite then- value with else- value if condi/on doesn t hold Don t use when: Then or else expression have side effects Then and else expression are too expensive 12 6

7 New Style While Loop Transla/on C Code int fact_while(int x) int result = 1; while (x > 1) result *= x; x = x-1; ; urn result; Recent technique for GCC Both IA32 & x86-64 First itera/on jumps over body computa/on within loop Goto Version int fact_while_goto3(int x) int result = 1; goto middle; loop: result *= x; x = x-1; middle: if (x > 1) goto loop; urn result; 13 Jump- to- Middle While Transla/on C Code while (Test) Body Avoids duplica/ng test code Uncondi/onal goto incurs no performance penalty for loops compiled in similar fashion Goto Version goto middle; loop: Body middle: if (Test) goto loop; Goto (Previous) Version if (!Test) goto done; loop: Body if (Test) goto loop; done: 14 7

8 Jump- to- Middle Example int fact_while(int x) int result = 1; while (x > 1) result *= x; x--; ; urn result; # x in %edx, result in %eax jmp.l34 # goto Middle.L35: # Loop: imull %edx, %eax # result *= x decl %edx # x--.l34: # Middle: cmpl $1, %edx # x:1 jg.l35 # if >, goto Loop 15 Implemen/ng Loops IA32 All loops translated into form based on do- while x86-64 Also make use of jump to middle Why the difference IA32 compiler developed for machine where all opera(ons costly x86-64 compiler developed for machine where uncondi(onal branches incur (almost) no overhead 16 8

9 x86-64 Integer Registers %rax %eax %r8 %r8d %rbx %ebx %r9 %r9d %rcx %ecx %r10 %r10d %rdx %edx %r11 %r11d %rsi %esi %r12 %r12d %rdi %edi %r13 %r13d %rsp %esp %r14 %r14d %rbp %ebp %r15 %r15d Twice the number of registers Accessible as 8, 16, 32, 64 bits 17 x86-64 Integer Registers %rax Return value %r8 Argument #5 %rbx Callee saved %r9 Argument #6 %rcx Argument #4 %r10 Caller saved %rdx Argument #3 %r11 Caller saved %rsi Argument #2 %r12 Callee saved %rdi Argument #1 %r13 Callee saved %rsp Stack pointer %r14 Callee saved %rbp Callee saved %r15 Callee saved 18 9

10 x86-64 Registers Arguments passed to func/ons via registers If more than 6 integral parameters, then pass rest on stack These registers can be used as caller- saved as well All references to stack frame via stack pointer Eliminates need to update %ebp/%rbp Other Registers 6 callee saved 2 or 3 have special uses 19 x86-64 Long Swap void swap(long *xp, long *yp) long t0 = *xp; long t1 = *yp; *xp = t1; *yp = t0; swap: movq (%rdi), %rdx movq (%rsi), %rax movq %rax, (%rdi) movq %rdx, (%rsi) Operands passed in registers First (xp) in %rdi, second (yp) in %rsi 64- bit pointers No stack opera/ons required (except ) Avoiding stack Can hold all local informa(on in registers 20 10

11 x86-64 Locals in the Red Zone /* Swap, using local array */ void swap_a(long *xp, long *yp) volatile long loc[2]; loc[0] = *xp; loc[1] = *yp; *xp = loc[1]; *yp = loc[0]; swap_a: movq (%rdi), %rax movq %rax, -24(%rsp) movq (%rsi), %rax movq %rax, -16(%rsp) movq -16(%rsp), %rax movq %rax, (%rdi) movq -24(%rsp), %rax movq %rax, (%rsi) Avoiding Stack Pointer Change Can hold all informa(on within small window beyond stack pointer rtn Ptr unused loc[1] loc[0] %rsp 21 x86-64 NonLeaf without Stack Frame long scount = 0; /* Swap a[i] & a[i+1] */ void swap_ele_se (long a[], int i) swap(&a[i], &a[i+1]); scount++; No values held while swap being invoked No callee save registers needed swap_ele_se: movslq %esi,%rsi # Sign extend i leaq (%rdi,%rsi,8), %rdi # &a[i] leaq 8(%rdi), %rsi # &a[i+1] call swap # swap() incq scount(%rip) # scount++; 22 11

12 x86-64 Call using Jump long scount = 0; /* Swap a[i] & a[i+1] */ void swap_ele(long a[], int i) swap(&a[i], &a[i+1]); swap_ele: movslq %esi,%rsi # Sign extend i leaq (%rdi,%rsi,8), %rdi # &a[i] leaq 8(%rdi), %rsi # &a[i+1] jmp swap # swap() 23 x86-64 Call using Jump long scount = 0; /* Swap a[i] & a[i+1] */ void swap_ele(long a[], int i) swap(&a[i], &a[i+1]); When swap executes, it will urn from swap_ele Possible since swap is a tail call (no instruc/ons alerwards) swap_ele: movslq %esi,%rsi # Sign extend i leaq (%rdi,%rsi,8), %rdi # &a[i] leaq 8(%rdi), %rsi # &a[i+1] jmp swap # swap() 24 12

13 x86-64 Stack Frame Example long sum = 0; /* Swap a[i] & a[i+1] */ void swap_ele_su (long a[], int i) swap(&a[i], &a[i+1]); sum += a[i]; Keeps values of a and i in callee save registers Must set up stack frame to save these registers swap_ele_su: movq %rbx, -16(%rsp) movslq %esi,%rbx movq %r12, -8(%rsp) movq %rdi, %r12 leaq (%rdi,%rbx,8), %rdi subq $16, %rsp leaq 8(%rdi), %rsi call swap movq (%r12,%rbx,8), %rax addq %rax, sum(%rip) movq (%rsp), %rbx movq 8(%rsp), %r12 addq $16, %rsp 25 Understanding x86-64 Stack Frame swap_ele_su: movq %rbx, -16(%rsp) # Save %rbx movslq %esi,%rbx # Extend & save i movq %r12, -8(%rsp) # Save %r12 movq %rdi, %r12 # Save a leaq (%rdi,%rbx,8), %rdi # &a[i] subq $16, %rsp # Allocate stack frame leaq 8(%rdi), %rsi # &a[i+1] call swap # swap() movq (%r12,%rbx,8), %rax # a[i] addq %rax, sum(%rip) # sum += a[i] movq (%rsp), %rbx # Restore %rbx movq 8(%rsp), %r12 # Restore %r12 addq $16, %rsp # Deallocate stack frame 26 13

14 Understanding x86-64 Stack Frame swap_ele_su: movq %rbx, -16(%rsp) # Save %rbx %rsp rtn addr movslq %esi,%rbx # Extend & save i 8 %r12 movq %r12, -8(%rsp) # Save %r12 movq %rdi, %r12 # Save a 16 %rbx leaq (%rdi,%rbx,8), %rdi # &a[i] subq $16, %rsp # Allocate stack frame leaq 8(%rdi), %rsi # &a[i+1] call swap # swap() rtn addr movq (%r12,%rbx,8), %rax # a[i] +8 %r12 addq %rax, sum(%rip) # sum += a[i] %rsp %rbx movq (%rsp), %rbx # Restore %rbx movq 8(%rsp), %r12 # Restore %r12 addq $16, %rsp # Deallocate stack frame 27 Interes/ng Features of Stack Frame Allocate en/re frame at once All stack accesses can be rela(ve to %rsp Do by decremen(ng stack pointer Can delay alloca(on, since safe to temporarily use red zone Simple dealloca/on Increment stack pointer No base/frame pointer needed 28 14

15 x86-64 Procedure Summary Heavy use of registers Parameter passing More temporaries since more registers Minimal use of stack Some(mes none Allocate/deallocate en(re block Many tricky op/miza/ons What kind of stack frame to use Calling with jump Various alloca(on techniques 29 Specific Cases of Alignment (x86-64) 1 byte: char, no restric(ons on address 2 bytes: short, lowest 1 bit of address must be bytes: int, float, lowest 2 bits of address must be bytes: double, char *, Windows & Linux: lowest 3 bits of address must be bytes: long double Linux: lowest 3 bits of address must be i.e., treated the same as a 8- byte primi(ve data type 30 15