Bryant and O Hallaron, Computer Systems: A Programmer s Perspective, Third Edition. Carnegie Mellon
|
|
|
- Bertha Lamb
- 5 years ago
- Views:
Transcription
1 Carnegie Mellon
2 Machine-Level Programming III: Procedures /18-213/14-513/15-513: Introduction to Computer Systems 7 th Lecture, September 18, 2018
3 Today Procedures Mechanisms Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion 3
4 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 execution Deallocate upon return Mechanisms all implemented with machine instructions x86-64 implementation 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]; 4
5 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 execution Deallocate upon return Mechanisms all implemented with machine instructions x86-64 implementation 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]; 5
6 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 execution Deallocate upon return Mechanisms all implemented with machine instructions x86-64 implementation 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]; 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 execution Deallocate upon return Mechanisms all implemented with machine instructions x86-64 implementation 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 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 execution Deallocate upon return Mechanisms all implemented with machine instructions x86-64 implementation of a procedure uses only those mechanisms required P( ) { y = Q(x); print(y) Machine instructions implement the mechanisms, but the choices are determined by designers. These choices make up the Application Binary Interface (ABI). int Q(int i) { int t = 3*i; int v[10]; return v[t]; 8
9 Today Procedures Mechanisms Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion 9
10 Carnegie Mellon x86-64 Stack Region of memory managed with stack discipline Memory viewed as array of bytes. Different regions have different purposes. (Like ABI, a policy decision) stack code m e m o r y 10
11 Carnegie Mellon x86-64 Stack Region of memory managed with stack discipline Stack Bottom stack Stack Pointer: %rsp Stack Top code 11
12 x86-64 Stack Region of memory managed with stack discipline Grows toward lower addresses Register %rsp contains lowest stack address address of top element Stack Pointer: %rsp Stack Bottom Stack Top Increasing Addresses Stack Grows Down 12
13 x86-64 Stack: Push pushq Src Fetch operand at Src val Decrement %rsp by 8 Write operand at address given by %rsp Stack Bottom Increasing Addresses Stack Pointer: %rsp Stack Top Stack Grows Down 13
14 x86-64 Stack: Push pushq Src Fetch operand at Src val Decrement %rsp by 8 Write operand at address given by %rsp Stack Bottom Increasing Addresses Stack Pointer: %rsp -8 Stack Top Stack Grows Down 14
15 x86-64 Stack: Pop popq Dest Read value at address given by %rsp Increment %rsp by 8 Store value at Dest (usually a register) Stack Bottom Increasing Addresses Stack Pointer: %rsp val Stack Top Stack Grows Down 15
16 x86-64 Stack: Pop popq Dest Read value at address given by %rsp Increment %rsp by 8 Store value at Dest (usually a register) Stack Bottom Increasing Addresses val Stack Pointer: %rsp +8 Stack Top Stack Grows Down 16
17 x86-64 Stack: Pop popq Dest Read value at address given by %rsp Increment %rsp by 8 Store value at Dest (usually a register) Stack Bottom Increasing Addresses Stack Pointer: %rsp (The memory doesn t change, only the value of %rsp) val Stack Top Stack Grows Down 17
18 Today Procedures Mechanisms Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion 18
19 Code Examples void multstore(long x, long y, long *dest) { long t = mult2(x, y); *dest = t; <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 long mult2(long a, long b) { <mult2>: long s = a * b; : mov %rdi,%rax # a return s; : imul %rsi,%rax # a * b : retq # Return 19
20 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 instruction right after call Example from disassembly Procedure return: ret Pop address from stack Jump to address 20
21 Control Flow Example # <multstore>: : callq <mult2> : mov %rax,(%rbx) 0x130 0x128 0x120 %rsp %rip 0x120 0x <mult2>: : mov %rdi,%rax : retq 21
22 Control Flow Example # <multstore>: : callq <mult2> : mov %rax,(%rbx) 0x130 0x128 0x120 0x118 %rsp %rip 0x x118 0x <mult2>: : mov %rdi,%rax : retq 22
23 Control Flow Example # <multstore>: : callq <mult2> : mov %rax,(%rbx) 0x130 0x128 0x120 0x118 %rsp %rip 0x x118 0x <mult2>: : mov %rdi,%rax : retq 23
24 Control Flow Example # <multstore>: : callq <mult2> : mov %rax,(%rbx) 0x130 0x128 0x120 %rsp %rip 0x120 0x <mult2>: : mov %rdi,%rax : retq 24
25 Today Procedures Mechanisms tack Structure Calling Conventions Passing control Passing data Managing local data Illustrations of Recursion & Pointers 25
26 Procedure Data Flow Registers First 6 arguments %rdi Stack %rsi %rdx %rcx %r8 %r9 Return value Arg n Arg 8 Arg 7 %rax Only allocate stack space when needed 26
27 Data Flow Examples void multstore (long x, long y, long *dest) { long t = mult2(x, y); *dest = t; Carnegie Mellon <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 long mult2 (long a, long b) { long s = a * b; return s; <mult2>: # a in %rdi, b in %rsi : mov %rdi,%rax # a : imul %rsi,%rax # a * b # s in %rax : retq # Return 27
28 Today Procedures Mechanisms Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion 28
29 Stack-Based Languages Languages that support recursion e.g., C, Pascal, Java Code must be Reentrant Multiple simultaneous instantiations of single procedure Need some place to store state of each instantiation Arguments Local variables Return pointer Stack discipline State for given procedure needed for limited time From when called to when return Callee returns before caller does Stack allocated in Frames state for single procedure instantiation 29
30 Call Chain Example yoo( ) { who(); who( ) { (); (); ( ) { (); Example Call Chain yoo who Procedure () is recursive 30
31 Stack Frames Contents Return information Local storage (if needed) Temporary space (if needed) Frame Pointer: %rbp (Optional) x Previous Frame Frame for proc Management Space allocated when enter procedure Set-up code Includes push by call instruction Deallocated when return Finish code Includes pop by ret instruction Stack Pointer: %rsp Stack Top 31
32 Example Stack yoo( ) { who(); yoo who %rbp %rsp yoo yoo 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( ) { who( ) { ( ) who(); (); { (); (); yoo who %rbp %rsp yoo yoo who 38
39 Example Stack yoo( ) { who( ) { who(); (); (); yoo who %rbp %rsp yoo yoo who 39
40 Example Stack yoo( ) { who( ) { ( ) who(); (); { (); (); yoo who %rbp %rsp yoo yoo who 40
41 Example Stack yoo( ) { who( ) { who(); (); (); yoo who %rbp %rsp yoo yoo who 41
42 Example Stack yoo( ) { who(); yoo who %rbp %rsp yoo yoo 42
43 x86-64/linux Stack Frame Current Stack Frame ( Top to Bottom) Argument build: Parameters for function about to call Local variables If can t keep in registers Saved register context Old frame pointer (optional) Caller Stack Frame Return address Pushed by call instruction Arguments for this call Frame pointer %rbp (Optional) Stack pointer %rsp Caller Frame Arguments 7+ Return Addr Old %rbp Saved Registers + Local Variables Argument Build (Optional) 43
44 Example: incr long incr(long *p, long val) { long x = *p; long y = x + val; *p = y; return x; 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 44
45 Example: Calling incr #1 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2;... Rtn address Initial Stack Structure %rsp call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret Resulting Stack Structure... Rtn address %rsp+8 Unused %rsp 45
46 Example: Calling incr #2 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret... Rtn address Unused Register %rdi Stack Structure Use(s) &v1 %rsi 3000 %rsp+8 %rsp 46
47 Example: Calling incr #2 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret... Rtn address Stack Structure Aside 1: movl $3000, Unused %esi Note: movl -> %exx zeros out high order 32 bits. Why use movl instead of movq? 1 byte shorter. Register %rdi Use(s) &v1 %rsi 3000 %rsp+8 %rsp 47
48 Example: Calling incr #2 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; Aside 2: leaq call_incr: subq Computes $16, %rsp+8 movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret... Rtn address Unused 8(%rsp), %rdi Actually, used for what it is meant! Register %rdi Stack Structure Use(s) &v1 %rsi 3000 %rsp+8 %rsp 48
49 Example: Calling incr #2 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret... Rtn address Unused Register %rdi Stack Structure Use(s) &v1 %rsi 3000 %rsp+8 %rsp 49
50 Example: Calling incr #3 long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret... Rtn address Unused Register %rdi Stack Structure Use(s) &v1 %rsi 3000 %rsp+8 %rsp 50
51 Example: Calling incr #4 Stack Structure long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2; call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret... Rtn address Unused Register %rax %rsp+8 %rsp Use(s) Return value 51
52 Example: Calling incr #5a Stack Structure long call_incr() { long v1 = 15213; long v2 = incr(&v1, 3000); return v1+v2;... Rtn address Unused %rsp+8 %rsp call_incr: subq $16, %rsp movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret Register Use(s) %rax Return value Updated Stack Structure... Rtn address %rsp 52
53 Example: Calling incr #5b 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 $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq 8(%rsp), %rax addq $16, %rsp ret Register Use(s) %rax Return value Final Stack Structure... %rsp 53
54 Register Saving Conventions 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 overwritten by who This could be trouble something should be done! Need some coordination 54
55 Register Saving Conventions When procedure yoo calls who: yoo is the caller who is the callee Can register be used for temporary storage? Conventions 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 55
56 x86-64 Linux Register Usage #1 %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 56
57 x86-64 Linux Register Usage #2 %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 57
58 Quiz Time! Check out: 58
59 Callee-Saved Example #1 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; Initial Stack Structure... Rtn address %rsp X comes in register %rdi. We need %rdi for the call to incr. Where should be put x, so we can use it after the call to incr? 59
60 Callee-Saved Example #2 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret Initial Stack Structure... Rtn address %rsp Resulting Stack Structure... Rtn address Saved %rbx %rsp 60
61 Callee-Saved Example #3 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret Initial Stack Structure... Rtn address Saved %rbx %rsp Resulting Stack Structure... Rtn address Saved %rbx %rsp+8 %rsp 61
62 Callee-Saved Example #4 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret... Rtn address Saved %rbx Stack Structure %rsp+8 %rsp x is saved in %rbx, a callee saved register 62
63 Callee-Saved Example #5 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret... Rtn address Saved %rbx Unused Stack Structure %rsp+8 %rsp x is saved in %rbx, a callee saved register 63
64 Callee-Saved Example #6 Stack Structure long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret... Rtn address Saved %rbx Unused %rsp+8 %rsp Upon return from incr: x is safe in %rbx Return result v2 is in %rax Compute x+v2 64
65 Callee-Saved Example #7 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret Stack Structure... Rtn address Saved %rbx %rsp Unused Return result in %rax 65
66 Callee-Saved Example #8 long call_incr2(long x) { long v1 = 15213; long v2 = incr(&v1, 3000); return x+v2; call_incr2: pushq %rbx subq $16, %rsp movq %rdi, %rbx movq $15213, 8(%rsp) movl $3000, %esi leaq 8(%rsp), %rdi call incr addq %rbx, %rax addq $16, %rsp popq %rbx ret Initial Stack Structure... Rtn address Saved %rbx %rsp Unused final Stack Structure... Rtn address %rsp Saved %rbx Unused 66
67 Today Procedures Mechanisms Stack Structure Calling Conventions Passing control Passing data Managing local data Illustration of Recursion 68
68 Recursive Function /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); pcount_r: movl $0, %eax testq %rdi, %rdi je.l6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx.l6: rep; ret 69
69 Recursive Function Terminal Case /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rdi x Argument %rax Return value Return value pcount_r: movl $0, %eax testq %rdi, %rdi je.l6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx.l6: rep; ret 70
70 Recursive Function Register Save /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); pcount_r: movl $0, %eax testq %rdi, %rdi je.l6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx.l6: rep; ret Register Use(s) Type %rdi x Argument... Rtn address Saved %rbx %rsp 71
71 Recursive Function Call Setup /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rdi x >> 1 Recursive argument %rbx x & 1 Callee-saved pcount_r: movl $0, %eax testq %rdi, %rdi je.l6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx.l6: rep; ret 72
72 Recursive Function Call /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rbx x & 1 Callee-saved %rax Recursive call return value pcount_r: movl $0, %eax testq %rdi, %rdi je.l6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx.l6: rep; ret 73
73 Recursive Function Result /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rbx x & 1 Callee-saved %rax Return value pcount_r: movl $0, %eax testq %rdi, %rdi je.l6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx.l6: rep; ret 74
74 Recursive Function Completion /* Recursive popcount */ long pcount_r(unsigned long x) { if (x == 0) return 0; else return (x & 1) + pcount_r(x >> 1); Register Use(s) Type %rax Return value Return value pcount_r: movl $0, %eax testq %rdi, %rdi je.l6 pushq %rbx movq %rdi, %rbx andl $1, %ebx shrq %rdi call pcount_r addq %rbx, %rax popq %rbx.l6: rep; ret... %rsp 75
75 Observations About Recursion Handled Without Special Consideration Stack frames mean that each function call has private storage Saved registers & local variables Saved return pointer Register saving conventions prevent one function call from corrupting another s data Unless the C code explicitly does so (e.g., buffer overflow in Lecture 9) Stack discipline follows call / return pattern If P calls Q, then Q returns before P Last-In, First-Out Also works for mutual recursion P calls Q; Q calls P 76
76 x86-64 Procedure Summary Important Points 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 conventions Can safely store values in local stack frame and in callee-saved registers Put function arguments at top of stack Result return in %rax Pointers are addresses of values On stack or global Caller Frame %rbp (Optional) %rsp Arguments 7+ Return Addr Old %rbp Saved Registers + Local Variables Argument Build 77
77 Small Exercise long add5(long b0, long b1, long b2, long b3, long b4) { return b0+b1+b2+b3+b4; long add10(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return add5(a0, a1, a2, a3, a4)+ add5(a5, a6, a7, a8, a9); Where are a0,, a9 passed? rdi, rsi, rdx, rcx, r8, r9, stack Where are b0,, b4 passed? rdi, rsi, rdx, rcx, r8 Which registers do we need to save? Ill-posed question. Need assembly. rbx, rbp, r9 (during first call to add5) 78
78 Small Exercise long add5(long b0, long b1, long b2, long b3, long b4) { return b0+b1+b2+b3+b4; long add10(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return add5(a0, a1, a2, a3, a4)+ add5(a5, a6, a7, a8, a9); add10: pushq %rbp pushq %rbx movq %r9, %rbp call add5 movq %rax, %rbx movq 48(%rsp), %r8 movq 40(%rsp), %rcx movq 32(%rsp), %rdx movq 24(%rsp), %rsi movq %rbp, %rdi call add5 addq %rbx, %rax popq %rbx popq %rbp ret add5: addq addq addq leaq ret %rsi, %rdi %rdi, %rdx %rdx, %rcx (%rcx,%r8), %rax 79
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
Machine-level Programs Procedure
Computer Systems Machine-level Programs Procedure Han, Hwansoo Mechanisms in Procedures Passing control To beginning of procedure code Back to return point Passing data Procedure arguments Return value
CS429: Computer Organization and Architecture
CS429: Computer Organization and Architecture Dr. Bill Young Department of Computer Sciences University of Texas at Austin Last updated: February 28, 2018 at 06:32 CS429 Slideset 9: 1 Mechanisms in Procedures
Machine- Level Representa2on: Procedure
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
Machine-Level Programming (2)
Machine-Level Programming (2) Yanqiao ZHU Introduction to Computer Systems Project Future (Fall 2017) Google Camp, Tongji University Outline Control Condition Codes Conditional Branches and Conditional
Procedures and the Call Stack
Procedures and the Call Stack Topics Procedures Call stack Procedure/stack instructions Calling conventions Register-saving conventions Why Procedures? Why functions? Why methods? int contains_char(char*
Mechanisms in Procedures. CS429: Computer Organization and Architecture. x86-64 Stack. x86-64 Stack Pushing
CS429: Computer Organization and Architecture Dr. Bill Young Department of Computer Sciences University of Texas at Austin Last updated: February 28, 2018 at 06:32 Mechanisms in Procedures Passing Control
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
The Stack & Procedures
The Stack & Procedures CSE 351 Autumn 2017 Instructor: Justin Hsia Teaching Assistants: Lucas Wotton Michael Zhang Parker DeWilde Ryan Wong Sam Gehman Sam Wolfson Savanna Yee Vinny Palaniappan http://xkcd.com/648/
The Stack & Procedures
The Stack & Procedures CSE 351 Spring 2017 Instructor: Ruth Anderson Teaching Assistants: Dylan Johnson Kevin Bi Linxing Preston Jiang Cody Ohlsen Yufang Sun Joshua Curtis Administrivia Homework 2 due
void P() {... y = Q(x); print(y); return; } ... int Q(int t) { int v[10];... return v[t]; } Computer Systems: A Programmer s Perspective
![void P() {... y = Q(x); print(y); return; } ... int Q(int t) { int v[10];... return v[t]; } Computer Systems: A Programmer s Perspective](/thumbs/81/82921282.jpg "void P() {... y = Q(x); print(y); return; } ... int Q(int t) { int v[10];... return v[t]; } Computer Systems: A Programmer s Perspective")
void P() { y = Q(x); print(y); return;... int Q(int t) { int v[10]; return v[t]; Computer Systems: A Programmer s Perspective %rax %rbx 0x101 0x41 0x7FFFFA8 0x1 0x7FFFFF8 0xB5A9 0x7FFFFF0 0x789ABC 0x7FFFFE8
Machine Program: Procedure. Zhaoguo Wang
Machine Program: Procedure Zhaoguo Wang Requirements of procedure calls? P() { y = Q(x); y++; 1. Passing control int Q(int i) { int t, z; return z; Requirements of procedure calls? P() { y = Q(x); y++;
Stack Frame Components. Using the Stack (4) Stack Structure. Updated Stack Structure. Caller Frame Arguments 7+ Return Addr Old %rbp
Stack Frame Components Frame pointer %rbp Stack pointer Caller Frame rguments 7+ Return ddr Old %rbp Saved Registers + Local Variables rgument Build 1 Using the Stack (4) Stack Structure long call_incr()
Assembly Programming IV
Assembly Programming IV CSE 351 Spring 2017 Instructor: Ruth Anderson Teaching Assistants: Dylan Johnson Kevin Bi Linxing Preston Jiang Cody Ohlsen Yufang Sun Joshua Curtis 1 Administrivia Homework 2 due
Sungkyunkwan University
Switch statements IA 32 Procedures Stack Structure Calling Conventions Illustrations of Recursion & Pointers long switch_eg (long x, long y, long z) { long w = 1; switch(x) { case 1: w = y*z; break; case
Foundations of Computer Systems
18-600 Foundations of Computer Systems Lecture 6: Machine-Level Programming III: Loops, Procedures, the Stack, and More September 18, 2017 Required Reading Assignment: Chapter 3 of CS:APP (3 rd edition)
Machine- Level Programming III: Switch Statements and IA32 Procedures
Machine- Level Programming III: Switch Statements and IA32 Procedures CS 485: Systems Programming Fall 2015 Instructor: James Griffioen Adapted from slides by R. Bryant and D. O Hallaron (hjp://csapp.cs.cmu.edu/public/instructors.html)
%r8 %r8d. %r9 %r9d. %r10 %r10d. %r11 %r11d. %r12 %r12d. %r13 %r13d. %r14 %r14d %rbp. %r15 %r15d. Sean Barker
Procedure Call Registers Return %rax %eax %r8 %r8d Arg 5 %rbx %ebx %r9 %r9d Arg 6 Arg 4 %rcx %ecx %r10 %r10d Arg 3 %rdx %edx %r11 %r11d Arg 2 %rsi %esi %r12 %r12d Arg 1 %rdi %edi %r13 %r13d ptr %esp %r14
Assembly Programming IV
Assembly Programming IV CSE 410 Winter 2017 Instructor: Justin Hsia Teaching Assistants: Kathryn Chan, Kevin Bi, Ryan Wong, Waylon Huang, Xinyu Sui The Data That Turned the World Upside Down The company
IA32 Stack. Stack BoDom. Region of memory managed with stack discipline Grows toward lower addresses. Register %esp contains lowest stack address
IA32 Procedures 1 IA32 Stack Region of memory managed with stack discipline Grows toward lower addresses Stack BoDom Increasing Addresses Register contains lowest stack address address of top element Stack
x86-64 Programming III
x86-64 Programming III CSE 351 Summer 2018 Instructor: Justin Hsia Teaching Assistants: Josie Lee Natalie Andreeva Teagan Horkan http://xkcd.com/1652/ Administrivia Homework 2 due Wednesday (7/11) Lab
Building an Executable
Building an Executable CSE 351 Summer 2018 Instructor: Justin Hsia Teaching Assistants: Josie Lee Natalie Andreeva Teagan Horkan http://xkcd.com/1790/ Administrivia Lab 2 due Monday (7/16) Homework 3 due
University of Washington
Roadmap C: car *c = malloc(sizeof(car)); c->miles = 100; c->gals = 17; float mpg = get_mpg(c); free(c); Assembly language: Machine code: Computer system: get_mpg: pushq %rbp movq %rsp, %rbp... popq %rbp
Lecture 4: x86_64 Assembly Language
CSCI-GA.1144-001 PAC II Lecture 4: x86_64 Assembly Language Some slides adapted (and slightly modified) from: Randy Bryant Dave O Hallaron Mohamed Zahran (aka Z) mzahran@cs.nyu.edu http://www.mzahran.com
Systems I. Machine-Level Programming V: Procedures
Systems I Machine-Level Programming V: Procedures Topics abstraction and implementation IA32 stack discipline Procedural Memory Usage void swap(int *xp, int *yp) int t0 = *xp; int t1 = *yp; *xp = t1; *yp
ASSEMBLY III: PROCEDURES. Jo, Heeseung
ASSEMBLY III: PROCEDURES Jo, Heeseung IA-32 STACK (1) Characteristics Region of memory managed with stack discipline Grows toward lower addresses Register indicates lowest stack address - address of top
Assembly III: Procedures. Jo, Heeseung
Assembly III: Procedures Jo, Heeseung IA-32 Stack (1) Characteristics Region of memory managed with stack discipline Grows toward lower addresses Register indicates lowest stack address - address of top
Princeton University Computer Science 217: Introduction to Programming Systems. Assembly Language: Function Calls
Princeton University Computer Science 217: Introduction to Programming Systems Assembly Language: Function Calls 1 Goals of this Lecture Help you learn: Function call problems x86-64 solutions Pertinent
Assembly Language: Function Calls
Assembly Language: Function Calls 1 Goals of this Lecture Help you learn: Function call problems x86-64 solutions Pertinent instructions and conventions 2 Function Call Problems (1) Calling and returning
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 IA-32 (1) Characteristics Region of memory managed with stack discipline
CS213. Machine-Level Programming III: Procedures
CS213 Machine-Level Programming III: Procedures Topics IA32 stack discipline Register saving conventions Creating pointers to local variables IA32 Region of memory managed with stack discipline Grows toward
Machine Language CS 3330 Samira Khan
Machine Language CS 3330 Samira Khan University of Virginia Feb 2, 2017 AGENDA Logistics Review of Abstractions Machine Language 2 Logistics Feedback Not clear Hard to hear Use microphone Good feedback
Machine Programming 3: Procedures
Machine Programming 3: Procedures CS61, Lecture 5 Prof. Stephen Chong September 15, 2011 Announcements Assignment 2 (Binary bomb) due next week If you haven t yet please create a VM to make sure the infrastructure
CS 107. Lecture 13: Assembly Part III. Friday, November 10, Stack "bottom".. Earlier Frames. Frame for calling function P. Increasing address
CS 107 Stack "bottom" Earlier Frames Lecture 13: Assembly Part III Argument n Friday, November 10, 2017 Computer Systems Increasing address Argument 7 Frame for calling function P Fall 2017 Stanford University
The course that gives CMU its Zip! Machine-Level Programming III: Procedures Sept. 17, 2002
15-213 The course that gives CMU its Zip! Machine-Level Programming III: Procedures Sept. 17, 2002 Topics IA32 stack discipline Register saving conventions Creating pointers to local variables class07.ppt
6.1. CS356 Unit 6. x86 Procedures Basic Stack Frames
6.1 CS356 Unit 6 x86 Procedures Basic Stack Frames 6.2 Review of Program Counter (Instruc. Pointer) PC/IP is used to fetch an instruction PC/IP contains the address of the next instruction The value in
Giving credit where credit is due
CSCE 230J Computer Organization Machine-Level Programming III: Procedures Dr. Steve Goddard goddard@cse.unl.edu Giving credit where credit is due Most of slides for this lecture are based on slides created
Compiling C Programs Into X86-64 Assembly Programs
CSE 2421: Systems I Low-Level Programming and Computer Organization Compiling C Programs Into X86-64 Assembly Programs Part B: If Else, Loops, Recursion & Switch Presentation L Read/Study: Bryant 3.6 Gojko
x86-64 Programming III & The Stack
x86-64 Programming III & The Stack CSE 351 Winter 2018 Instructor: Mark Wyse Teaching Assistants: Kevin Bi Parker DeWilde Emily Furst Sarah House Waylon Huang Vinny Palaniappan http://xkcd.com/1652/ Administrative
Areas for growth: I love feedback
Assembly part 2 1 Areas for growth: I love feedback Speed, I will go slower. Clarity. I will take time to explain everything on the slides. Feedback. I give more Kahoot questions and explain each answer.
IA32 Stack. Lecture 5 Machine-Level Programming III: Procedures. IA32 Stack Popping. IA32 Stack Pushing. Topics. Pushing. Popping
Lecture 5 Machine-Level Programming III: Procedures Topics IA32 stack discipline Register saving conventions Creating pointers to local variables IA32 Region of memory managed with stack discipline Grows
Machine- Level Programming III: Switch Statements and IA32 Procedures
Machine- Level Programming III: Switch Statements and IA32 Procedures 15-213: Introduc;on to Computer Systems 6 th Lecture, Sep. 9, 2010 Instructors: Randy Bryant and Dave O Hallaron Today Switch statements
CS 261 Fall Machine and Assembly Code. Data Movement and Arithmetic. Mike Lam, Professor
CS 261 Fall 2018 0000000100000f50 55 48 89 e5 48 83 ec 10 48 8d 3d 3b 00 00 00 c7 0000000100000f60 45 fc 00 00 00 00 b0 00 e8 0d 00 00 00 31 c9 89 0000000100000f70 45 f8 89 c8 48 83 c4 10 5d c3 Mike Lam,
Machine/Assembler Language Putting It All Together
COMP 40: Machine Structure and Assembly Language Programming Fall 2015 Machine/Assembler Language Putting It All Together Noah Mendelsohn Tufts University Email: noah@cs.tufts.edu Web: http://www.cs.tufts.edu/~noah
C to Assembly SPEED LIMIT LECTURE Performance Engineering of Software Systems. I-Ting Angelina Lee. September 13, 2012
6.172 Performance Engineering of Software Systems SPEED LIMIT PER ORDER OF 6.172 LECTURE 3 C to Assembly I-Ting Angelina Lee September 13, 2012 2012 Charles E. Leiserson and I-Ting Angelina Lee 1 Bugs
IA32 Stack The course that gives CMU its Zip! Machine-Level Programming III: Procedures Sept. 17, IA32 Stack Popping. IA32 Stack Pushing
15-213 The course that gives CMU its Zip! Machine-Level Programming III: Procedures Sept. 17, 2002 Topics IA32 stack discipline Register saving conventions Creating pointers to local variables IA32 Region
X86 Assembly -Procedure II:1
X86 Assembly -Procedure II:1 IA32 Object Code Setup Label.L61 becomes address 0x8048630 Label.L62 becomes address 0x80488dc Assembly Code switch_eg:... ja.l61 # if > goto default jmp *.L62(,%edx,4) # goto
Systems Programming and Computer Architecture ( )
Systems Group Department of Computer Science ETH Zürich Systems Programming and Computer Architecture (252-0061-00) Timothy Roscoe Herbstsemester 2016 AS 2016 Compiling C Control Flow 1 8: Compiling C
Lecture 3 CIS 341: COMPILERS
Lecture 3 CIS 341: COMPILERS HW01: Hellocaml! Announcements is due tomorrow tonight at 11:59:59pm. HW02: X86lite Will be available soon look for an announcement on Piazza Pair-programming project Simulator
Machine-Level Programming II: Control
Mellon Machine-Level Programming II: Control CS140 Computer Organization and Assembly Slides Courtesy of: Randal E. Bryant and David R. O Hallaron 1 First https://www.youtube.com/watch?v=ivuu8jobb1q 2
1 Number Representation(10 points)
Name: Sp15 Midterm Q1 1 Number Representation(10 points) 1 NUMBER REPRESENTATION(10 POINTS) Let x=0xe and y=0x7 be integers stored on a machine with a word size of 4bits. Show your work with the following
Compiling C Programs Into x86-64 Assembly Programs
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 3.7.1-3.7.6 Presentation K Gojko Babić
Region of memory managed with stack discipline Grows toward lower addresses. Register %esp contains lowest stack address = address of top element
Machine Representa/on of Programs: Procedures Instructors: Sanjeev Se(a 1 IA32 Stack Region of memory managed with stack discipline Grows toward lower addresses Stack BoGom Increasing Addresses Register
Buffer Overflows Many of the following slides are based on those from Complete Powerpoint Lecture Notes for Computer Systems: A Programmer's Perspective (CS:APP) Randal E. Bryant and David R. O'Hallaron
CSE 351 Midterm - Winter 2017
CSE 351 Midterm - Winter 2017 February 08, 2017 Please read through the entire examination first, and make sure you write your name and NetID on all pages! We designed this exam so that it can be completed
CSCI 2021: x86-64 Control Flow
CSCI 2021: x86-64 Control Flow Chris Kauffman Last Updated: Mon Mar 11 11:54:06 CDT 2019 1 Logistics Reading Bryant/O Hallaron Ch 3.6: Control Flow Ch 3.7: Procedure calls Goals Jumps and Control flow
Intel x86-64 and Y86-64 Instruction Set Architecture
CSE 2421: Systems I Low-Level Programming and Computer Organization Intel x86-64 and Y86-64 Instruction Set Architecture Presentation J Read/Study: Bryant 3.1 3.5, 4.1 Gojko Babić 03-07-2018 Intel x86
Data Representa/ons: IA32 + x86-64
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 4 4 4 int 4 4 4 long
Function Calls and Stack
Function Calls and Stack Philipp Koehn 16 April 2018 1 functions Another Example 2 C code with an undefined function int main(void) { int a = 2; int b = do_something(a); urn b; } This can be successfully
Machine-Level Programming II: Control
Machine-Level Programming II: Control CSE 238/2038/2138: Systems Programming Instructor: Fatma CORUT ERGİN Slides adapted from Bryant & O Hallaron s slides 1 Today Control: Condition codes Conditional
CSE351 Spring 2018, Midterm Exam April 27, 2018
CSE351 Spring 2018, Midterm Exam April 27, 2018 Please do not turn the page until 11:30. Last Name: First Name: Student ID Number: Name of person to your left: Name of person to your right: Signature indicating:
CS356: Discussion #15 Review for Final Exam. Marco Paolieri Illustrations from CS:APP3e textbook
CS356: Discussion #15 Review for Final Exam Marco Paolieri (paolieri@usc.edu) Illustrations from CS:APP3e textbook Processor Organization Pipeline: Computing Throughput and Delay n 1 2 3 4 5 6 clock (ps)
CSE 351 Midterm Exam Spring 2016 May 2, 2015
Name: CSE 351 Midterm Exam Spring 2016 May 2, 2015 UWNetID: Solution Please do not turn the page until 11:30. Instructions The exam is closed book, closed notes (no calculators, no mobile phones, no laptops,
C to Machine Code x86 basics: Registers Data movement instructions Memory addressing modes Arithmetic instructions
C to Machine Code x86 basics: Registers Data movement instructions Memory addressing modes Arithmetic instructions Program, Application Software Hardware next few weeks Programming Language Compiler/Interpreter
Lecture 4 CIS 341: COMPILERS
Lecture 4 CIS 341: COMPILERS CIS 341 Announcements HW2: X86lite Available on the course web pages. Due: Weds. Feb. 7 th at midnight Pair-programming project Zdancewic CIS 341: Compilers 2 X86 Schematic
18-600: Recitation #4 Exploits
18-600: Recitation #4 Exploits 20th September 2016 Agenda More x86-64 assembly Buffer Overflow Attack Return Oriented Programming Attack 3 Recap: x86-64: Register Conventions Arguments passed in registers:
Stack Discipline Jan. 19, 2018
15-410 An Experience Like No Other Discipline Jan. 19, 2018 Dave Eckhardt Brian Railing Slides originally stolen from 15-213 1 15-410, S 18 Synchronization Registration The wait list will probably be done
Machine-level Programming (3)
Machine-level Programming (3) Procedures A: call A call A return Two issues How to return to the correct position? How to pass arguments and return values between callee to caller? 2 Procedure Control
Recitation: Attack Lab
15-213 Recitation: Attack Lab TA 11 Feb 2017 Agenda Reminders Stacks Attack Lab Activities Reminders Bomb lab is due tomorrow (14 Feb, 2017)! But if you wait until the last minute, it only takes a minute!
Buffer Overflow Attack (AskCypert CLaaS)
Buffer Overflow Attack (AskCypert CLaaS) ---------------------- BufferOverflow.c code 1. int main(int arg c, char** argv) 2. { 3. char name[64]; 4. printf( Addr;%p\n, name); 5. strcpy(name, argv[1]); 6.
Do not turn the page until 5:10.
University of Washington Computer Science & Engineering Autumn 2018 Instructor: Justin Hsia 2018-10-29 Last Name: First Name: Student ID Number: Name of person to your Left Right All work is my own. I
An Experience Like No Other. Stack Discipline Aug. 30, 2006
15-410 An Experience Like No Other Discipline Aug. 30, 2006 Bruce Maggs Dave Eckhardt Slides originally stolen from 15-213 15-410, F 06 Synchronization Registration If you're here but not registered, please
How Software Executes
How Software Executes CS-576 Systems Security Instructor: Georgios Portokalidis Overview Introduction Anatomy of a program Basic assembly Anatomy of function calls (and returns) Memory Safety Intel x86
Where We Are. Optimizations. Assembly code. generation. Lexical, Syntax, and Semantic Analysis IR Generation. Low-level IR code.
Where We Are Source code if (b == 0) a = b; Low-level IR code Optimized Low-level IR code Assembly code cmp $0,%rcx cmovz %rax,%rdx Lexical, Syntax, and Semantic Analysis IR Generation Optimizations Assembly
CSE351 Autumn 2014 Midterm Exam (29 October 2014)
CSE351 Autumn 2014 Midterm Exam (29 October 2014) Please read through the entire examination first! We designed this exam so that it can be completed in 50 minutes and, hopefully, this estimate will prove
CSE 351 Midterm - Winter 2015
CSE 351 Midterm - Winter 2015 February 09, 2015 Please read through the entire examination first! We designed this exam so that it can be completed in 50 minutes and, hopefully, this estimate will prove
18-600: Recitation #4 Exploits (Attack Lab)
18-600: Recitation #4 Exploits (Attack Lab) September 19th, 2017 Announcements Some students have triggered the bomb multiple times Use breakpoints for explode_bomb() Attack lab will be released on Sep.
Processor state. Information about currently executing program. %rax, %rdi, ... %r14 %r15. %rsp. %rip CF ZF SF OF. Temporary data
Processor state Information about currently executing program Temporary data %rax, %rdi, current parameters, local variables Location of runtime stack %rsp Location of current instruction %rip Status of
CSE 351 Midterm - Winter 2015 Solutions
CSE 351 Midterm - Winter 2015 Solutions February 09, 2015 Please read through the entire examination first! We designed this exam so that it can be completed in 50 minutes and, hopefully, this estimate
CSC 252: Computer Organization Spring 2018: Lecture 6
CSC 252: Computer Organization Spring 2018: Lecture 6 Instructor: Yuhao Zhu Department of Computer Science University of Rochester Action Items: Assignment 2 is out Announcement Programming Assignment
x86 Programming I CSE 351 Winter
x86 Programming I CSE 351 Winter 2017 http://xkcd.com/409/ Administrivia Lab 2 released! Da bomb! Go to section! No Luis OH Later this week 2 Roadmap C: car *c = malloc(sizeof(car)); c->miles = 100; c->gals
Credits and Disclaimers
Credits and Disclaimers 1 The examples and discussion in the following slides have been adapted from a variety of sources, including: Chapter 3 of Computer Systems 3 nd Edition by Bryant and O'Hallaron
Machine Level Programming: Control
Machine Level Programming: Control Computer Systems Organization (Spring 2017) CSCI-UA 201, Section 3 Instructor: Joanna Klukowska Slides adapted from Randal E. Bryant and David R. O Hallaron (CMU) Mohamed
CSE 401/M501 Compilers
CSE 401/M501 Compilers x86-64 Lite for Compiler Writers A quick (a) introduction or (b) review [pick one] Hal Perkins Autumn 2018 UW CSE 401/M501 Autumn 2018 J-1 Administrivia HW3 due tonight At most 1
CS 3330 Exam 1 Fall 2017 Computing ID:
S 3330 Fall 2017 xam 1 Variant page 1 of 8 mail I: S 3330 xam 1 Fall 2017 Name: omputing I: Letters go in the boxes unless otherwise specified (e.g., for 8 write not 8 ). Write Letters clearly: if we are
Assembly II: Control Flow. Jin-Soo Kim Computer Systems Laboratory Sungkyunkwan University
Assembly II: Control Flow Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu Processor State (x86-64) RAX 63 31 EAX 0 RBX EBX RCX RDX ECX EDX General-purpose
C++ Named Return Value Optimization
C++ Named Return Value Optimization post. Robert.Schneider@hotmail.de meetup.com/c-user-group-karlsruhe auto create() -> T { T castor /* initialize */; //... return castor; } void use() { T pollux = create();
Computer Systems C S Cynthia Lee
Computer Systems C S 1 0 7 Cynthia Lee 2 Today s Topics Function call and return in x86-64 Registers Call stack NEXT TIME: NEW topic: the build process Taking a look at each step of the process Preprocessor,
CSE P 501 Exam Sample Solution 12/1/11
Question 1. (10 points, 5 each) Regular expressions. Give regular expressions that generate the following sets of strings. You may only use the basic operations of concatenation, choice ( ), and repetition
CSE351 Autumn 2014 Midterm Exam (29 October 2014)
CSE351 Autumn 2014 Midterm Exam (29 October 2014) (Version A) Please read through the entire examination first! We designed this exam so that it can be completed in 50 minutes and, hopefully, this estimate
CS24: INTRODUCTION TO COMPUTING SYSTEMS. Spring 2018 Lecture 4
CS24: INTRODUCTION TO COMPUTING SYSTEMS Spring 2018 Lecture 4 LAST TIME Enhanced our processor design in several ways Added branching support Allows programs where work is proportional to the input values
CS429: Computer Organization and Architecture
CS429: Computer Organization and Architecture Dr. Bill Young Department of Computer Sciences University of Texas at Austin Last updated: February 26, 2018 at 12:02 CS429 Slideset 8: 1 Controlling Program
Brief Assembly Refresher
Brief Assembly Refresher 1 Changelog 1 Changes made in this version not seen in first lecture: 23 Jan 2018: if-to-assembly if (...) goto needed b < 42 23 Jan 2018: caller/callee-saved: correct comment
Assembly II: Control Flow
Assembly II: Control Flow Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu SSE2030: Introduction to Computer Systems, Spring 2018, Jinkyu Jeong (jinkyu@skku.edu)
University*of*Washington*
Roadmap* C:* car *c = malloc(sizeof(car)); c->miles = 100; c->gals = 17; float mpg = get_mpg(c); free(c); Assembly* language:* Machine* code:* Computer* system:* get_mpg: pushq movq... popq %rbp %rsp,
Computer Organization: A Programmer's Perspective
A Programmer's Perspective Instruction Set Architecture Gal A. Kaminka galk@cs.biu.ac.il Outline: CPU Design Background Instruction sets Logic design Sequential Implementation A simple, but not very fast
x86 Programming II CSE 351 Winter
x86 Programming II CSE 351 Winter 2017 http://xkcd.com/1652/ Administrivia 2 Address Computation Instruction v leaq src, dst lea stands for load effective address src is address expression (any of the
Changelog. Assembly (part 1) logistics note: lab due times. last time: C hodgepodge
Changelog Assembly (part 1) Corrections made in this version not seen in first lecture: 31 August 2017: slide 34: split out from previous slide; clarify zero/positive/negative 31 August 2017: slide 26:
Corrections made in this version not seen in first lecture:
Assembly (part 1) 1 Changelog 1 Corrections made in this version not seen in first lecture: 31 August 2017: slide 34: split out from previous slide; clarify zero/positive/negative 31 August 2017: slide
Machine Level Programming: Basics
Machine Level Programming: Basics Computer Systems Organization (Spring 2017) CSCI-UA 201, Section 2 Instructor: Joanna Klukowska Slides adapted from Randal E. Bryant and David R. O Hallaron (CMU) Mohamed