Machine- Level Representa2on: Procedure

Size: px

Start display at page:

Download "Machine- Level Representa2on: Procedure"

Lorraine Harvey
5 years ago
Views:

1 Machine- Level Representa2on: Procedure CSCI 2021: Machine Architecture and Organiza2on Pen- Chung Yew Department Computer Science and Engineering University of Minnesota With Slides from Bryant, O Hallaron and Antonia Zhai

2 Review: Assembly/Machine Code View CPU (Central Processing Unit) PC Registers Condi2on Codes Addresses Data Instruc2ons Memory Code Data Stack Programmer- Visible State PC: Program counter %rip Address of next instruc2on Called %rip in x86-64 Register file Heavily used program data Condi2on codes Store status informa2on about most recent arithme?c or logical opera?on Used for condi?onal branching Memory Byte addressable array Code and user data Stack to support procedures CF ZF SF OF Condi2on Flags 2

3 Review: Jump and Condi2onal Move jx Condi2on Descrip2on jmp 1 Uncondi2onal je ZF Equal / Zero jne ~ZF Not Equal / Not Zero js SF Nega2ve jns ~SF Nonnega2ve jg ~(SF^OF)&~ZF Greater (Signed) jge ~(SF^OF) Greater or Equal (Signed) jl (SF^OF) Less (Signed) jle (SF^OF) ZF Less or Equal (Signed) ja ~CF&~ZF Above (unsigned) jb CF Below (unsigned) Condi2onal Move val = Test? Then_Expr : Else_Expr; val = x>y? x-y : y-x; 3

4 Review: Loops Do- While Loop do Body While Loop while (Test) Body while(test); For Loop for (Init; Test; Update ) Body

$Review: Jump Table Structure Switch Form switch(x) { case val_0: Block 0 case val_1: Block 1 case val_n-1: Block n 1 Transla2on (Extended C) goto$

5 Review: Jump Table Structure Switch Form switch(x) { case val_0: Block 0 case val_1: Block 1 case val_n-1: Block n 1 Transla2on (Extended C) goto *JTab[x]; jtab: Jump Table Targ0 Targ1 Targ2 Targn-1 Targ0: Targ1: Targ2: Targn-1: Jump Targets Code Block 0 Code Block 1 Code Block 2 Code Block n 1

6 Outline Procedures Stack Structure Calling Conven2ons Passing control Passing data Managing local data Illustra2on of Recursion 6

7 Mechanisms in Procedures Passing control To beginning of procedure code Back to return point Passing data Procedure arguments Return value Memory management Allocate during procedure execu?on Deallocate upon return Mechanisms all implemented with machine instruc?ons x86-64 implementa?on of a procedure uses only those mechanisms required P( ) { y = Q(x); print(y) int Q(int i) { int t = 3*i; int v[10]; return v[t]; 7

8 Review: Assembly/Machine Code View CPU (Central Processing Unit) PC Registers Condi2on Codes Addresses Data Instruc2ons Memory Code Data Stack Programmer- Visible State PC: Program counter %rip Address of next instruc2on Called %rip in x86-64 Register file Heavily used program data Condi2on codes Store status informa2on about most recent arithme?c or logical opera?on Used for condi?onal branching Memory Byte addressable array Code and user data Stack to support procedures 8

9 x86-64 Stack Region of memory managed with stack discipline, i.e. last- in- first- out, or LIFO. Stack Bohom Registers Grows toward lower addresses Register %rsp contains lowest stack address address of top element Increasing Addresses %rax %rbx %r8 %r9 Stack Grows %rcx %rdx %r10 %r11 Stack Pointer: %rsp Down %rsi %rdi %r12 %r13 Stack Top %rsp %rbp %r14 %r15 9

10 x86-64 Stack: Push Stack Bohom pushq Src Fetch operand at Src Decrement %rsp by 8 Write operand at address given by %rsp Increasing Addresses Registers %rax %r8 %rbx %rcx %r9 %r10 Stack Grows %rdx %rsi %r11 %r12 Stack Pointer: %rsp - 8 Down %rdi %r13 %rsp %rbp %r14 %r15 Stack Top 10

11 x86-64 Stack: Pop popq Dest Read value at address given by %rsp Increment %rsp by 8 Store value at Dest (must be register) Registers Stack Bohom Increasing Addresses %rax %r8 %rbx %rcx %r9 %r10 Stack Grows %rdx %rsi %r11 %r12 Stack Pointer: %rsp +8 Down %rdi %rsp %r13 %r14 Stack Top %rbp %r15 11

12 Outline Procedures Stack Structure Calling Conven2ons Passing control Passing data Managing local data Illustra2on of Recursion 12

13 Code Examples void multstore (long x, long y, long *dest) { long t = mult2(x, y); *dest = t; long mult2 (long a, long b) { long s = a * b; return s; <multstore>: : push %rbx # Save %rbx : mov %rdx,%rbx # Save dest : callq <mult2> # mult2(x,y) : mov %rax,(%rbx) # Save at dest 40054c: pop %rbx # Restore %rbx 40054d: retq # Return <mult2>: : mov %rdi,%rax # a : imul %rsi,%rax # a * b : retq # Return

14 Procedure Control Flow Use stack to support procedure call and return Procedure call: call label Push return address on stack Jump to label Return address: Address of the next instruc?on right aser call Example from disassembly Procedure return: ret Pop address from stack Jump to address 14

15 Control Flow Example # <multstore>: : callq <mult2> : mov %rax,(%rbx) 0x130 0x128 0x <mult2>: : mov %rdi,%rax : retq %rsp %rip 0x120 0x

16 Control Flow Example # <multstore>: : callq <mult2> : mov %rax,(%rbx) <mult2>: : mov %rdi,%rax : retq 0x130 0x128 0x120 0x118 %rsp %rip 0x x118 0x

17 Control Flow Example # <multstore>: : callq <mult2> : mov %rax,(%rbx) <mult2>: : mov %rdi,%rax : retq 0x130 0x128 0x120 0x118 %rsp %rip 0x x118 0x

18 Control Flow Example # <multstore>: : callq <mult2> : mov %rax,(%rbx) <mult2>: : mov %rdi,%rax : retq 0x130 0x128 0x120 %rsp %rip 0x120 0x

19 Outline Procedures Stack Structure Calling Conven2ons Passing control Passing data Managing local data Illustra2ons of Recursion & Pointers 19

20 Procedure Data Flow Registers Stack Registers First 6 arguments %rdi 1 %rsi 2 Arg n %rax %rbx %r8 %r9 %rdx %rcx 3 4 %rcx %r10 %r8 5 Arg 8 %rdx %rsi %r11 %r12 %r9 6 Arg 7 %rdi %rsp %rbp %r13 %r14 %r15 Return value %rax Only allocate stack space when needed 20

21 Code Examples void multstore (long x, long y, long *dest) { long t = mult2(x, y); *dest = t; long mult2 (long a, long b) { long s = a * b; return s; <multstore>: : push %rbx # Save %rbx : mov %rdx,%rbx # Save dest : callq <mult2> # mult2(x,y) : mov %rax,(%rbx) # Save at dest 40054c: pop %rbx # Restore %rbx 40054d: retq # Return <mult2>: : mov %rdi,%rax # a : imul %rsi,%rax # a * b : retq # Return

22 Procedure Data Flow Registers Stack Registers First 6 arguments %rdi x %rsi y a b Arg n %rax %rbx %r8 %r9 %rdx %rcx dest %rcx %r10 %r8 Arg 8 %rdx %rsi %r11 %r12 %r9 Arg 7 %rdi %rsp %rbp %r13 %r14 %r15 Return value %rax Only allocate stack space when needed 22

Data Flow Examples void multstore (long x, long y, long *dest) {

long s = a * b; return s; 0000000000400540 <multstore>: # x in

400544: callq 400550 <mult2> # mult2(x,y) # t in %rax 400549: mov

%r9 %rax 0000000000400550 <mult2>: # a in %rdi, b in %rsi 400550:

23 Data Flow Examples void multstore (long x, long y, long *dest) { long t = mult2(x, y); *dest = t; long mult2 (long a, long b) { long s = a * b; return s; <multstore>: # x in %rdi, y in %rsi, dest in %rdx : mov %rdx,%rbx # Save dest : callq <mult2> # mult2(x,y) # t in %rax : mov %rax,(%rbx) # Save at dest %rdi %rsi %rdx %rcx %r8 x y *dest a b %r9 %rax <mult2>: # a in %rdi, b in %rsi : mov %rdi,%rax # a : imul %rsi,%rax # a * b # s in %rax : retq # Return

24 Outline Procedures Stack Structure Calling Conven2ons Passing control Passing data Managing local data Illustra2on of Recursion 24

25 Stack- Based Languages Languages that support recursion e.g., C, Pascal, Java Code must be Reentrant Mul?ple simultaneous instan?a?ons of single procedure Need some place to store state of each instan?a?on Arguments Local variables Return pointer Stack discipline State for given procedure needed for limited?me From when called to when return Callee returns before caller does Stack allocated in Frames State for single procedure instan?a?on 25

26 Call Chain Example yoo( ) { who(); who( ) { (); (); ( ) { (); Example Call Chain yoo who Procedure () is recursive 26

27 Stack Frames Carnegie Mellon Contents Return informa2on Local storage (if needed) Temporary space (if needed) Management Space allocated when enter procedure Set- up code Includes push by call instruc?on Deallocated when return Finish code Includes pop by ret instruc?on Frame Pointer: %rbp (Op2onal) x Stack Pointer: %rsp Previous Frame Frame for proc Stack Top 27

28 Example Stack yoo( ) { yoo who %rbp %rsp yoo yoo who(); 28

29 Example Stack yoo( ) { who( ) { who(); (); (); yoo who %rbp %rsp yoo yoo who 29

30 Example Stack yoo( ) { who( ) { ( ) { who(); (); (); (); yoo who %rbp %rsp yoo yoo who 30

31 Example Stack yoo( ) { who( ) { ( ) { who(); (); ( ) { (); (); (); yoo who %rbp %rsp yoo yoo who 31

32 Example Stack yoo( ) { who( ) { ( ) { who(); (); ( ) { ( ) (); (); { (); (); yoo who %rbp %rsp yoo yoo who 32

33 Example Stack yoo( ) { who( ) { ( ) { who(); (); ( ) { (); (); (); yoo who %rbp %rsp yoo yoo who 33

34 Example Stack yoo( ) { who( ) { ( ) { who(); (); (); (); yoo who %rbp %rsp yoo yoo who 34

35 Example Stack yoo( ) { who( ) { who(); (); (); yoo who %rbp %rsp yoo yoo who 35

36 Example Stack yoo( ) { who( ) { ( ) { who(); (); (); (); yoo who %rbp %rsp yoo yoo who 36

37 Example Stack yoo( ) { who( ) { who(); (); (); yoo who %rbp %rsp yoo yoo who 37

38 Example Stack yoo( ) { yoo who %rbp %rsp yoo yoo who(); 38

39 Outline Procedures Stack Structure (Last- in- First- out, LIFO) Calling Conven2ons Passing control Passing data Managing local data Illustra2on of Recursion 40

40 Review: Mechanisms in Procedures Passing control To beginning of procedure code Back to return point Passing data Procedure arguments Return value Memory management Allocate during procedure execu?on Deallocate upon return P( ) { y = Q(x); print(y) int Q(int i) { int t = 3*i; int v[10]; return v[t]; 41

41 Review: Procedure Passing Control Use stack to support procedure call and return (part of Applica2on Binary Interface, ABI) Procedure call: call label Push return address on stack Jump to label Return address: Address of the next instruc2on right aner call Procedure return: ret Pop return address from stack Jump to the return address 42

42 Review: Procedure Data Flow Registers Stack Registers First 6 arguments %rdi 1 %rsi 2 Arg n %rax %rbx %r8 %r9 %rdx %rcx 3 4 %rcx %r10 %r8 5 Arg 8 %rdx %rsi %r11 %r12 %r9 6 Arg 7 %rdi %rsp %rbp %r13 %r14 %r15 Return value %rax Only allocate stack space when needed 43

43 Review: Structure of Stack Need some place to store state of each instan?a?on Arguments Local variables Return pointer Stack discipline State for given procedure needed for limited?me From when called to when return Callee returns before caller does (LIFO) Stack allocated in Frames State for single procedure instan?a?on 45

44 x86-64/linux Stack Frame Current Stack Frame ( Top to Bohom) Argument build: Parameters for func?on about to call Local variables If can t keep in registers Saved register context Old frame pointer (op2onal) Caller Stack Frame (ABI Applica2on Binary Interface) Return address (Bottom) Frame pointer %rbp (Op2onal) Pushed by call instruc?on Arguments for this call Stack pointer (top) %rsp Caller Frame Arguments 7+ Return Addr Old %rbp Saved Registers + Local Variables Argument Build (Op2onal) Arg n Arg 8 Arg 7

Example: incr long incr(long *p, long val) { long x = *p; long y = x + val; *p = y; return x; %rdi %rsi %rdx %rcx %r8 %r9 1 2 3 4 5 6

45 Example: incr long incr(long *p, long val) { long x = *p; long y = x + val; *p = y; return x; %rdi %rsi %rdx %rcx %r8 %r incr: movq addq movq ret (%rdi), %rax %rax, %rsi %rsi, (%rdi) Register %rdi %rsi %rax Use(s) Argument p Argument val, y x, Return value 47

46 Example: Calling incr #1 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; Ini2al Stack Structure... Rtn address %rsp call_incr: subq $16, %rsp movq movl leaq call addq addq ret $15213, 8(%rsp) $3000, %rsi 8(%rsp), %rdi incr 8(%rsp), %rax $16, %rsp Resul2ng Stack Structure... Rtn address %rsp+8 Unused %rsp 48

47 Example: Calling incr #2 long call_incr() { long v1 = 15213; call_incr: subq $16, %rsp movq movl leaq call addq addq ret long v2 = incr(&v1, 3000); return v1+v2; $15213, 8(%rsp) $3000, %rsi 8(%rsp), %rdi incr 8(%rsp), %rax $16, %rsp Stack Structure... Rtn address %rsp+8 Unused %rsp Register Use(s) %rdi &v1 %rsi

$Example: Calling incr #3 long call_incr() { long v1 = 15213; call_incr: subq $16, %rsp movq movl leaq call addq addq ret long v2 = incr(&v1, 3000); return v1+v2; $15213, 8(%rsp) $3000, %rsi$

48 Example: Calling incr #3 long call_incr() { long v1 = 15213; call_incr: subq $16, %rsp movq movl leaq call addq addq ret long v2 = incr(&v1, 3000); return v1+v2; $15213, 8(%rsp) $3000, %rsi 8(%rsp), %rdi incr 8(%rsp), %rax $16, %rsp... Rtn address Unused Register %rdi Stack Structure Use(s) &v1 %rsi 3000 incr: movq addq movq ret %rsp+8 %rsp (%rdi), %rax %rax, %rsi %rsi, (%rdi)

49 Example: Calling incr #4 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); Rtn address return v1+v2; Unused Stack Structure %rsp+8 %rsp call_incr: subq $16, %rsp movq movl leaq call addq addq ret $15213, 8(%rsp) $3000, %rsi 8(%rsp), %rdi incr 8(%rsp), %rax $16, %rsp Register Use(s) %rax Return value Updated Stack Structure... Rtn address %rsp 51

50 Example: Calling incr #5 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; Updated Stack Structure... Rtn address %rsp call_incr: subq $16, %rsp movq movl leaq call addq addq ret $15213, 8(%rsp) $3000, %rsi 8(%rsp), %rdi incr 8(%rsp), %rax $16, %rsp Register Use(s) %rax Return value Final Stack Structure... %rsp 52

yoo: movq $15213, %rdx call who addq %rdx, %rax ret who: subq $18213, %rdx ret

51 Register Saving Conven2ons When procedure yoo calls who: yoo is the caller who is the callee Can register be used for temporary storage? yoo: movq $15213, %rdx call who addq %rdx, %rax ret who: subq $18213, %rdx ret Contents of register %rdx overwrizen by who This could be trouble something should be done! Need some coordina?on 53

52 Register Saving Conven2ons When procedure yoo calls who: yoo is the caller who is the callee Can register be used for temporary storage? Conven?ons (ABI Applica2on Binary Interface) Caller Saved Caller saves temporary values in its frame before the call Callee Saved Callee saves temporary values in its frame before using Callee restores them before returning to caller 54

53 x86-64 Linux Register Usage (Caller Saved) %rax Return value Also caller- saved Can be modified by procedure %rdi,..., %r9 Arguments Also caller- saved Can be modified by procedure %r10, %r11 Caller- saved Can be modified by procedure Return value Arguments Caller- saved temporaries %rax %rdi %rsi %rdx %rcx %r8 %r9 %r10 %r11 55

54 x86-64 Linux Register Usage (Callee Saved) Carnegie Mellon %rbx, %r12, %r13, %r14 Callee- saved Callee must save & restore %rbp Callee- saved Callee must save & restore May be used as frame pointer Can mix & match %rsp Special form of callee save Restored to original value upon exit from procedure Callee- saved Temporaries Special %rbx %r12 %r13 %r14 %rbp %rsp 56

55 x86-64 Integer Registers: Usage Conven2ons %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 58

56 Callee- Saved Example #1 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; Rtn address %rsp... Ini2al Stack Structure call_incr2: pushq %rbx subq movq movq movl leaq call addq addq popq ret $16, %rsp %rdi, %rbx $15213, 8(%rsp) $3000, %esi 8(%rsp), %rdi incr %rbx, %rax $16, %rsp %rbx Resul2ng Stack Structure... Rtn address Saved %rbx %rsp+8 Unused %rsp 59

$Callee- Saved Example #2 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000);$ .. Rtn address Resul2ng Stack Structure Saved %rbx call_incr2: pushq %rbx subq movq movq movl leaq

.. Rtn address Resul2ng Stack Structure Saved %rbx call_incr2: pushq %rbx subq movq movq movl leaq

57 Callee- Saved Example #2 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2;... Rtn address Resul2ng Stack Structure Saved %rbx call_incr2: pushq %rbx subq movq movq movl leaq call addq addq popq ret $16, %rsp %rdi, %rbx $15213, 8(%rsp) $3000, %esi 8(%rsp), %rdi incr %rbx, %rax $16, %rsp %rbx %rsp+8 Unused %rsp Pre- return Stack Structure... Rtn address %rsp 60

58 Outline Procedures Stack Structure Calling Conven2ons Passing control Passing data Managing local data Illustra2on of Recursion 61

59 Recursive Func2on /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) else return 0; return (x & 1) + pcount_r(x >> 1); pcount_r: movl testq je.l6 pushq movq andl shrq call addq.l6: popq rep; ret $0, %eax %rdi, %rdi %rbx %rdi, %rbx $1, %ebx %rdi pcount_r %rbx, %rax %rbx 62

60 Recursive Func2on Terminal Case /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) else return 0; return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rdi x Argument %rax Return value Return value pcount_r: movl testq je.l6 pushq movq andl shrq call addq.l6: popq rep; ret $0, %eax %rdi, %rdi %rbx %rdi, %rbx $1, %ebx %rdi pcount_r %rbx, %rax %rbx 63

61 Review: Jump jx Condi2on Descrip2on jmp 1 Uncondi2onal je ZF Equal / Zero jne ~ZF Not Equal / Not Zero js SF Nega2ve jns ~SF Nonnega2ve jg ~(SF^OF)&~ZF Greater (Signed) jge ~(SF^OF) Greater or Equal (Signed) jl (SF^OF) Less (Signed) jle (SF^OF) ZF Less or Equal (Signed) ja ~CF&~ZF Above (unsigned) jb CF Below (unsigned) 64

62 Recursive Func2on Register Save /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) else return 0; return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rdi x Argument pcount_r: movl testq je.l6 pushq movq andl shrq call addq.l6: popq rep; ret... $0, %eax %rdi, %rdi %rbx %rdi, %rbx $1, %ebx %rdi pcount_r %rbx, %rax %rbx Rtn address Saved %rbx %rsp

63 Recursive Func2on Call Setup /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) else return 0; return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rdi x >> 1 Rec. argument %rbx x & 1 Callee- saved pcount_r: movl testq je.l6 pushq movq andl shrq call addq.l6: popq rep; ret $0, %eax %rdi, %rdi %rbx %rdi, %rbx $1, %ebx %rdi pcount_r %rbx, %rax %rbx 66

64 Recursive Func2on Call /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) else return 0; return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rbx x & 1 Callee- saved %rax Recursive call return value pcount_r: movl testq je.l6 pushq movq andl shrq call addq.l6: popq rep; ret $0, %eax %rdi, %rdi %rbx %rdi, %rbx $1, %ebx %rdi pcount_r %rbx, %rax %rbx 67

65 Recursive Func2on Result /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) else return 0; return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rbx x & 1 Callee- saved %rax Return value pcount_r: movl testq je.l6 pushq movq andl shrq call addq.l6: popq rep; ret $0, %eax %rdi, %rdi %rbx %rdi, %rbx $1, %ebx %rdi pcount_r %rbx, %rax %rbx 68

66 Recursive Func2on Comple2on /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) else return 0; return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rax Return value Return value pcount_r: movl testq je.l6 pushq movq andl shrq call addq.l6: popq rep; ret $0, %eax %rdi, %rdi %rbx %rdi, %rbx $1, %ebx %rdi pcount_r %rbx, %rax %rbx... %rsp

67 Observa2ons About Recursion Handled Without Special Considera2on Stack frames mean that each func2on call has private storage Saved registers & local variables Saved return pointer Register saving conven2ons prevent one func2on call from corrup2ng another s data Unless the C code explicitly does so (e.g., buffer overflow) Stack discipline follows call / return pahern If P calls Q, then Q returns before P Last- In, First- Out Also works for mutual recursion P calls Q; Q calls P 70

68 x86-64 Procedure Summary Stack is the right data structure for procedure call / return If P calls Q, then Q returns before P Recursion (& mutual recursion) handled by normal calling conven2ons Can safely store values in local stack frame and in callee- saved registers Put func?on arguments at top of stack Result return in %rax Pointers are addresses of values On stack or global Caller Frame %rbp (Op2onal) %rsp Arguments 7+ Return Addr Old %rbp Saved Registers + Local Variables Argument Build

Machine-Level Programming III: Procedures

Machine-Level Programming III: Procedures CSE 238/2038/2138: Systems Programming Instructor: Fatma CORUT ERGİN Slides adapted from Bryant & O Hallaron s slides Mechanisms in Procedures Passing control