Compiling C Programs Into x86-64 Assembly Programs

Size: px

Start display at page:

Download "Compiling C Programs Into x86-64 Assembly Programs"

Anis Wells
5 years ago
Views:

1 CSE 2421: Systems I Low-Level Programming and Computer Organization Compiling C Programs Into x86-64 Assembly Programs Part A: Function Calling Read/Study: Bryant Presentation K Gojko Babić Linux & Windows X86-64 Register Usage %rax Return value %rax urn value, and if needed caller %rdi also has to save it, since can %rsi be modified by called function %rdx %rdi, %rsi, %rdx, %rcx, Arguments %r8, %r9 %rcx arguments (1 st,2 nd, 3 rd,, 6 th ) also caller-saved (if needed), since can be modified by called function %r10, %r11 caller-saved (if needed), since can be modified by called function Caller saved temporaries %r8 %r9 %r10 %r11 Carnegie Mellon Presentation K 2 1

2 Linux & Windows X86-64 Register Usage (cont.) Carnegie Mellon %rbx, %r12, %r13, %r14, %rbp If using them, called function must save & restore, since caller expect them to be unchanged Special form of called function save. Should be restored to original value upon exit from called function Callee saved temporaries Special %rbx %r12 %r13 %r14 %rbp Presentation K 3 Function sum() long sum(long int x, long int y) long t = x+y; urn t; Note: This is the complete file sum.c, i.e. without the function main. Compilation command: gcc -O1 -S sum.c generates this x86-64 assembly code in the file sum.s: sum: leaq (%rsi,%rdi), %rax Note, x has to be in %rdi and y in %rsi, set by calling function Presentation K 4 2

3 Function arith() long arith(long int x,long int y,long int z) urn (x+y+z)*(x+4+48*y); Compilation command: gcc -O1 -S arith.c generates this x86-64 assembly code in the file arith.s: arith: leaq (%rsi,%rsi,2), %rax salq $4, %rax leaq 4(%rdi,%rax), %rax addq %rdi, %rsi addq %rdx, %rsi imulq %rsi, %rax Note, x has to be in %rdi, y in %rsi and z in %rdx, set by calling function. Presentation K 5 long arith(long, long, long); long main() long x,y,z,w; x=25; y=12345; z=98765; w=arith(x,y,z); w++; urn w; Function main Calling arith() Instruction subq enlargers the stack for 8 bytes (why??), and second instruction addq shrinks stack back 8 bytes Compilation command: gcc -O1 S main.arith.c generated this x86-64 assembly code (with minor changes in red): subq call addq addq $8, $98765, %rdx $12345, %rsi $25, %rdi arith $1, %rax $8, Presentation K 6 3

4 Function swap() void swap (long *xp, long *yp) long t0 = *xp; long t1 = *yp; *xp = t1; *yp = t0; Compilation command: gcc O1 -S swap.c produces file swap.s Presentation K Note, xp has to be in %rdi and yp in %rsi set by calling function. swap: (%rdi), %rax (%rsi), %rdx %rdx, (%rdi) %rax, (%rsi) 7 Understanding swap() a. void swap (long *xp, long *yp) long t0 = *xp; long t1 = *yp; *xp = t1; *yp = t0; Registers %rdi %rsi %rax %rdx Memory Register %rdi %rsi %rax %rdx Value xp yp t0 t1 swap: (%rdi), %rax # t0 = *xp (%rsi), %rdx # t1 = *yp %rdx, (%rdi) # *xp = t1 %rax, (%rsi) # *yp = t0 Presentation K 8 4

5 Understanding swap() b. Registers %rdi 0x120 %rsi 0x100 %rax %rdx Memory Address 0x120 0x118 0x110 0x108 0x100 swap: (%rdi), %rax # t0 = *xp (%rsi), %rdx # t1 = *yp %rdx, (%rdi) # *xp = t1 %rax, (%rsi) # *yp = t0 Presentation K 9 Understanding swap() c. Registers %rdi 0x120 %rsi 0x100 %rax 123 %rdx Memory Address 0x120 0x118 0x110 0x108 0x100 swap: (%rdi), %rax # t0 = *xp (%rsi), %rdx # t1 = *yp %rdx, (%rdi) # *xp = t1 %rax, (%rsi) # *yp = t0 Presentation K 10 5

6 Understanding swap() d. Registers %rdi 0x120 %rsi 0x100 %rax 123 %rdx 456 Memory Address 0x120 0x118 0x110 0x108 0x100 swap: (%rdi), %rax # t0 = *xp (%rsi), %rdx # t1 = *yp %rdx, (%rdi) # *xp = t1 %rax, (%rsi) # *yp = t0 Presentation K 11 Understanding swap() e. Registers %rdi 0x120 %rsi 0x100 %rax 123 %rdx 456 Memory Address 0x120 0x118 0x110 0x108 0x100 swap: (%rdi), %rax # t0 = *xp (%rsi), %rdx # t1 = *yp %rdx, (%rdi) # *xp = t1 %rax, (%rsi) # *yp = t0 Presentation K 12 6

7 Understanding swap() f. Registers %rdi 0x120 %rsi 0x100 %rax 123 %rdx 456 Memory Address 0x120 0x118 0x110 0x108 0x100 swap: (%rdi), %rax # t0 = *xp (%rsi), %rdx # t1 = *yp %rdx, (%rdi) # *xp = t1 %rax, (%rsi) # *yp = t0 Presentation K 13 Function Calling swap() void swap(long *,long *); long main() long x= 123; long y= 456; swap(&x, &y); urn 1; Instruction subq $24, enlargers stack for 24 bytes, for local variables x and y, plus additional 8 bytes (why??). Before urn, addq adjusts stack for instruction. Compilation command: gcc O1 -S main.swap.c generated this x86-64 assembly code (with minor changes in red): subq leaq call addq $24, $123, 8() $456, (), %rsi 8(), %rdi swap $1, %rax $24, Presentation K 14 7

8 Understanding Calling swap() a. urn adr 1000 after main is called urn adr subq $24, $123, 8() $456, (), %rsi leaq 8(), %rdi call swap $1, %rax addq $24, 976 Presentation K 15 Understanding Calling swap() b. 976 Address 0 urn adr x y subq leaq call addq $24, $123, 8() $456, (), %rsi 8(), %rdi swap $1, %rax $24, Presentation K 16 8

9 Understanding Calling swap() c. 976 Register %rdi %rsi Value &x &y 456 Address urn adr 1000 x y subq leaq call addq %rdi %rsi $24, $123, 8() $456, (), %rsi 8(), %rdi swap $1, %rax $24, Presentation K 17 Understanding Calling swap() d. Address urn adr urn adr 968 subq leaq call addq $24, $123, 8() $456, (), %rsi 8(), %rdi swap $1, %rax $24, Address of this instruction PC set to the address of swap() Presentation K 18 9

10 Function main with Global Variables void swap(long*,long*); long x= 123; long y= 456; void main() swap(&x, &y); urn 1; Function swap is unchanged. Compilation command: gcc O1 -S main.g.swap.c generated this x86-64 assembly code (with minor changes in red): subq $8, $y, %rsi $x, %rdi call swap $1, %rax addq $8,.align 8 x:.quad 123 y:.quad 456 Presentation K 19 Procedure Data Flow Carnegie Mellon Registers First 6 arguments %rdi %rsi %rdx %rcx %r8 %r9 Return value %rax Arg n Arg 8 Arg 7 Only allocate stack space when needed Presentation K 20 10

11 Function Calling arithex() long arithex(long, long, long, long, long, long, long, long); long main() Compilation command: gcc -O1 S main.arithex.c generated this x86-64 assembly code (with minor changes in red): long a,b,c,d,e,f,g,h,w; subq $24, a=100; $31, 8() b=12345; $29, () c=98765; $27, %r9 d=23; $25, %r8 e=25; $23, %rcx f=27; $98765, %rdx g=29; $12345, %rsi h=31; $100, %rdi w=arithex(a,b,c,d,e,f,g,h); call arithex w++; addq $1, %rax urn w; addq $24, Presentation K 21 Understanding Calling arithex() and registers after main is called urn adr 1000 and registers before call arithex urn adr subq $24, $31, 8() $29, () $27, %r9 $25, %r8 $23, %rcx $98765, %rdx $12345, %rsi $100, %rdi call arithex 976 %rdi= 100 %rsi= %rdx= %rcx= 23 %r8= 25 %r9=

12 Function arithex() long arithex(long x, long y, long z, long w, long m, long n, long o, long p) urn (x+y+z+w+m+n+o+p); Compilation command: gcc -O1 -S arithex.c arithex: leaq (%rsi,%rdi),%rdi ;%rdi y+x leaq (%rdi,%rdx),%rdx ;%rdx y+x+z addq %rcx, %rdx ;%rdx y+x+z+w addq %r8, %rdx ;%rdx y+x+z+w+m addq %r9, %rdx ;%rdx y+x+z+w+m+n %rdx, %rax ;%rax y+x+z+w+m+n addq 8(), %rax ;%rax y+x+z+w+m+n+o addq 16(), %rax ;%rax y+x+z+w+m+n+o+p Presentation K 23 X86-64/Linux Frame Structure Current Frame ( Top to Bottom) Argument build: parameters for function about to call Local variables, if can t keep in registers Saved register context, if needed Caller Frame Return address, pushed by call instruction Arguments 7, 8 for this call Increasing addresses Argument n Argument 7 Return address Saved registers, local variables, and temporary space (if need) bottom Earlier frames Caller s frame Current (callee) frame pointer Argument build area top 24 12

13 Observations About Function Calling is the right data structure for function call / urn pattern (Last-In, First-Out): if P calls Q, then Q urns before P. allow that each function has private storage for: urn address, local variables (if needed), function arguments (if needed), saved registers (if needed). Register saving conventions prevent one function from corrupting another s data. Return value (result) in %rax. Recursion is handled without special consideration. Also works for mutual recursion, i.e. P calls Q; Q calls P. Presentation K 25 Call Chain Example ( ) (); ( ) (); (); ( ) (); Example Call Chain Procedure () is recursive Presentation K 26 13

14 Call Chain Example (cont.) ( ) (); Presentation K 27 Call Chain Example (cont.) ( ) ( ) (); (); (); Presentation K 28 14

15 Call Chain Example (cont.) ( ) ( ) ( ) (); (); (); (); Presentation K 29 Call Chain Example (cont.) ( ) ( ) ( ) (); (); ( ) (); (); (); Presentation K 30 15

16 Call Chain Example (cont.) ( ) ( ) ( ) (); (); ( ) (); (); ( ) (); (); Presentation K 31 Call Chain Example (cont.) ( ) ( ) ( ) (); (); ( ) (); (); (); Presentation K 32 16

17 Call Chain Example (cont.) ( ) ( ) ( ) (); (); (); (); Presentation K 33 Call Chain Example (cont.) ( ) ( ) (); (); (); Presentation K 34 17

18 Call Chain Example (cont.) ( ) ( ) ( ) (); (); (); (); Presentation K 35 Call Chain Example (cont.) ( ) ( ) (); (); (); Presentation K 36 18

19 Call Chain Example (end) ( ) (); Presentation K 37 main() & swap() Y86-64 Assembly Code # Execution has to begin at address 0.pos 0 init: ir $, # Set up stack pointer call main # call main program halt # Terminate program swap: mr (%rdi), %rax # (%rdi), %rax mr (%rsi), %rdx # (%rsi), %rdx rm %rdx, (%rdi) # %rdx, (%rdi) rm %rax, (%rsi) # %rax, (%rsi) Presentation K 38 19

20 main() & swap() Y86-64 Assembly Code (cont) ir $24, %rax # subq $24, subq %rax, ir $0x123, %rax # $123, 8() rm %rax, 8() ir $0x456, %rax # $456, () rm %rax, () rr, %rsi #, %rsi ir $8, %rdi # leaq 8(), %rdi addq, %rdi call swap ir $1, %rax # $1, %rax ir $24, %r10 # addq $24, addq %r10,.pos 0x200 #The stack starts here and grows to lower addresses :.quad 0 Presentation K 39 main() & swap() Y86-64 Machine Code # Execution has to begin at address 0 0x000:.pos 0 init: 0x000: 30f ir $, # set up stack pointer 0x00a: 803d call main # call main program 0x013: 00 halt # terminate program swap: 0x014: mr (%rdi), %rax 0x01e: mr (%rsi), %rdx 0x028: rm %rdx, (%rdi) 0x032: rm %rax, (%rsi) 0x03c: 90 Presentation K 40 20

21 main() & swap() Y86-64 Machine Code (cont) 0x03d: 30f ir $24, %rax # subq $24, 0x047: 6104 subq %rax, 0x049: 30f ir $0x123, %rax # $123, 8() 0x053: rm %rax, 8() 0x05d: 30f ir $0x456, %rax # $456, () 0x067: rm %rax, () 0x071: 2046 rr, %rsi #, %rsi 0x073: 30f ir $8, %rdi # leaq 8(), %rdi 0x07d: 6047 addq, %rdi 0x07f: call swap 0x088: 30f ir $1, %rax # $1, %rax 0x092: 30fa ir $24, %r10 # addq $24, 0x09c: 60a4 addq %r10, 0x09e: 90 0x200:.pos 0x200 # The stack starts here and # grows to lower addresses 0x200: :.quad x03d: 30f ir $8, %rax # subq $8, 0x047: 6104 subq %rax, 0x049: 30f ir $y, %rsi # $y, %rsi 0x053: 30f ir $x, %rdi # $x, %rdi 0x05d: call swap # call swap 0x066: 30f ir $1, %rax # $1, %rax 0x070: 30fa ir $8, %r10 # addq $8, 0x07a: 60a4 addq %r10, 0x07c: 90 0x080:.align 8 0x080: x:.quad 0x123 0x088: y:.quad 0x456 0x200:.pos 0x200 #The stack starts here 0x200: :.quad 0 main() & swap() with Global Variables Presentation K 42 21

22 Function with struct Argument (new slides) struct pair long a; long b; long c; long d; ; long xyz(struct pair p); long main() struct pair x; long y; x.a = 1; x.b = 2; x.c = 3; x.d = 4; y = xyz(x); y=y+1; urn y; Compilation command: gcc O1 -S strmain.c generated this x86-64 assembly code Presentation K subq call addq addq $72, $1, 32() $2, 40() $3, 48() $4, 56() $1, () $2, 8() $3, 16() $4, 24() xyz $1, %rax $72, 43 Function with struct Argument (cont.) struct pair long a; long b; long c; long d; ; long xyz(struct pair p) long a; a=p.a + p.b + p.c + p.d; urn a; Compilation command: gcc O1 -S structurer.c generated this x86-64 assembly code xyz: addq addq addq 16(), %rax 8(), %rax 24(), %rax 32(), %rax Presentation K 44 22

23 Function with struct Argument & Return struct pair long a; long b; long c; long d; ; struct pair xyz(struct pair p); long int main() struct pair x, y; x.a = 1; x.b = 2; x.c = 3; x.d = 4; y = xyz(x); urn 1; Compilation command: gcc O1 -S strmainnew.c generated this x86-64 assembly code subq $104, $1, 64() $2, 72() $3, 80() $4, 88() leaq 32(), %rdi $1, () $2, 8() $3, 16() $4, 24() call xyz $1, %rax addq $104, Presentation K 45 Function with struct Argument & Return (cont.) struct pair long a; long b; long c; long d; ; struct pair xyz(struct pair p) struct pair z; z.a=p.a ; z.b=p.b ; z.c=p.c ; z.d=p.d ; urn z; Compilation command: gcc O1 -S structurernew.c generated this x86-64 assembly code xyz: %rdi, %rax 32(), %rdx %rdx, 24(%rdi) 24(), %rdx %rdx, 16(%rdi) 16(), %rdx %rdx, 8(%rdi) 8(), %rdx %rdx, (%rdi) 46 23

Assembly III: Procedures. Jin-Soo Kim Computer Systems Laboratory Sungkyunkwan University

Assembly III: Procedures. Jin-Soo Kim Computer Systems Laboratory Sungkyunkwan University Assembly III: Procedures Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu Mechanisms in Procedures Passing control To beginning of procedure code