Mechanisms in Procedures. CS429: Computer Organization and Architecture. x86-64 Stack. x86-64 Stack Pushing
|
|
- Elwin Wilkerson
- 5 years ago
- Views:
Transcription
1 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 To beginning of procedure code Back to urn point Passing Data Procedure arguments Return value Memory Management Allocate during procedure execution Deallocate upon urn Mechanisms all implemented with machine instructions x86-64 implementation of a procedure uses only those mechanisms required. P() y = Q(x) ; printf (y) ; int Q( int i ) int t = 3 i ; int v [10]; urn v[ t ]; CS429 Slideset 9: 1 CS429 Slideset 9: 2 x86-64 x86-64 Pushing "bottom" "bottom" Region of memory managed with stack discipline Grows toward lower addresses Increasing Addresses. Increasing Addresses Register contains lowest stack address address of top element "top" Pushing pushq Src Decrement by 8 Write operand at address given by pointer 8 "top" Grows Down CS429 Slideset 9: 3 CS429 Slideset 9: 4
2 x86-64 Popping Code Examples "bottom" void multstore (long x, long y, long dest ) long t = mult2(x, y) ; dest = t ; Popping popq Dest Read operand at address given by Increment by 8 pointer +8 "top" Increasing Addresses Grows Down <multstore >: : push # Save : mov %rdx, # Save dest : q <mult2> # mult2(x, y) 40054D: mov %rax, () # Save at dest : pop # Restore : q # Return Write to Dest CS429 Slideset 9: 5 CS429 Slideset 9: 6 Code Examples (2) Procedure Control Flow long mult2 (long a, long b) long s = a b; urn s ; <mult2 >: : mov %rdi, %rax # a : imul %rsi, %rax # a b : q # Return Use stack to support procedure and urn Procedure : label Push urn address on stack Jump to label Return address: Address of next instruction right after Procedure urn: Pop address from stack Jump to address CS429 Slideset 9: 7 CS429 Slideset 9: 8
3 Control Flow Example #1 Control Flow Example #2 Poised to execute in multstore. After in multstore. Now in mult <multstore >: : q <mult2> 40054D: mov %rax, (). 0x130. 0x128. 0x <multstore >: : q <mult2> 40054D: mov %rax, (). 0x130. 0x128. 0x120 0x118 0x40054D <mult2 >: : mov %rdi, %rax : q %rip 0x120 0x <mult2 >: : mov %rdi, %rax : q %rip 0x118 0x CS429 Slideset 9: 9 CS429 Slideset 9: 10 Control Flow Example #3 Control Flow Example #4 Execute through mult2 to q. After q in mult2. Back in multstore <multstore >: : q <mult2> 40054D: mov %rax, (). 0x130. 0x128. 0x120 0x118 0x40054D <multstore >: : q <mult2> 40054D: mov %rax, (). 0x130. 0x128. 0x <mult2 >: : mov %rdi, %rax : q %rip 0x118 0x <mult2 >: : mov %rdi, %rax : q %rip 0x120 0x40054D CS429 Slideset 9: 11 CS429 Slideset 9: 12
4 Procedure Data Flow Data Flow Examples Registers: First 6 arguments %rdi %rsi %rdx %rcx %r8 %r9 Mnemonic to remember the order: Diane s silk dress cost $89. Args past 6 are pushed on the stack in reverse order. Return value %rax Arg n Arg 8 Arg 7 Only allocate stack space when needed. void multstore (long x, long y, long dest ) long t = mult2(x, y) ; dest = t ; <multstore >: # x in %rdi, y in %rsi, dest in %rdx : mov %rdx, # Save dest : q <mult2> # mult2(x, y) # t in %rax 40054C: mov %rax, () # Save at dest CS429 Slideset 9: 13 CS429 Slideset 9: 14 Data Flow Examples (continued) -Based Languages long mult2 (long a, long b) long s = a b; urn s ; <mult2 >: # a in %rdi, b in %rsi : mov %rdi, %rax # a : imul %rsi, %rax # a b # s in %rax : q # Return 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 instantation: arguments, local variables, urn pointer discipline State for given procedure needed for a limited time: from to urn Callee urns before er does allocated in Frames State for a single procedure instantiation CS429 Slideset 9: 15 CS429 Slideset 9: 16
5 Call Chain Example Frames Code Structure () () ; () () ; () ; () () ; CS429 Slideset 9: 17 Procedure is recursive. In IA32, almost every procedure generated a stack frame. In x86-64, most s do not generate an explicit frame. Contents Return information Local storage (if needed) Temporary space (if needed) Management Space allocated when enter procedure Set-up code Includes push by instruction Deallocated when urning Finish code Includes pop by instruction CS429 Slideset 9: 18 Previous Frame Frame for proc top Frame pointer: %rbp (optional) pointer: Example (1) Example (2) () () ; () () ; () () ; CS429 Slideset 9: 19 CS429 Slideset 9: 20
6 Example (3) Example (4) () () () () ; () () () () ; CS429 Slideset 9: 21 CS429 Slideset 9: 22 Example (5) Example (6) () () () () ; () () () () ; CS429 Slideset 9: 23 CS429 Slideset 9: 24
7 Example (7) Example (8) () () () () ; () () ; () () ; CS429 Slideset 9: 25 CS429 Slideset 9: 26 Example (9) Example (10) () () () () ; () () ; () () ; CS429 Slideset 9: 27 CS429 Slideset 9: 28
8 Example (11) x86-64/linux Frame () () ; Current Frame ( Top to Bottom) Argument build: parameters for function about to Local variables, if can t keep in registers Saved register context Old frame pointer (optional) Caller frame Arguments 7+ Return addr Frame pointer Old %rbp %rbp (optional) pointer Saved Register + Local vars Argument Build (optional) Caller Frame Return address (pushed by instruction) Arguments for this CS429 Slideset 9: 29 CS429 Slideset 9: 30 Building a Frame Example: incr IA32 routines almost always constructed an explicit stack frame; x86-64 routines usually don t. If you do build a stack frame: proc : pushq %rbp movq, %rbp # save er s frame base # set ee s frame base # body of routine proc This example doesn t use explicit frames! long incr (long p, long val ) long x = p; long y = x + val ; p = y; urn x; movq %rbp, # discard ee s frame popq %rbp # reset er s frame base Reserve %rbp for this purpose if you re doing this. What does this do? incr : movq (%rdi ), %rax %rax, %rsi movq %rsi, (%rdi ) %rdi Argument p %rsi Argument val, y %rax x, urn value CS429 Slideset 9: 31 CS429 Slideset 9: 32
9 Example: Calling incr #1 Example: Calling incr #2 long incr () long v2 = incr(&v1, 3000) ; urn v1 + v2; incr : subq $16, movq $15213, 8( ) movl leaq $3000, %esi 8( ), %rdi incr 8( ), %rax $16, Initial Structure Rtn addr Resulting Structure Rtn addr Unused long incr () long v2 = incr(&v1, 3000) ; urn v1 + v2; incr : subq $16, movq $15213, 8( ) movl leaq $3000, %esi 8( ), %rdi incr 8( ), %rax $16, Structure Rtn addr Unused %rdi &v1 %rsi 3000 CS429 Slideset 9: 33 CS429 Slideset 9: 34 Example: Calling incr #3 Example: Calling incr #4 long incr () long v2 = incr(&v1, 3000) ; urn v1 + v2; incr : subq $16, movq $15213, 8( ) movl $3000, %esi leaq 8( ), %rdi incr 8( ), %rax $16, Structure Rtn addr Unused %rdi &v1 %rsi 3000 long incr () long v2 = incr(&v1, 3000) ; urn v1 + v2; incr : subq $16, movq $15213, 8( ) movl $3000, %esi leaq 8( ), %rdi incr 8( ), %rax $16, Structure Rtn addr Unused %rdi &v1 %rsi 3000 Updated Structure Rtn addr CS429 Slideset 9: 35 CS429 Slideset 9: 36
10 Example: Calling incr #5 long incr () long v2 = incr(&v1, 3000) ; urn v1 + v2; incr : subq $16, movq $15213, 8( ) movl $3000, %esi leaq 8( ), %rdi incr 8( ), %rax $16, Updated Structure Rtn addr %rax Return value Final Structure Register Saving Conventions When procedure s : is the er is the ee Can register be used for temporary storage? : movq $15213, %rdx %rdx, %rax : subq $18213, %rdx Contents of register %rdx are overwritten by This could be trouble; something should be done! Need to coordinate between er and ee. CS429 Slideset 9: 37 CS429 Slideset 9: 38 Register Saving Conventions When procedure s : is the er is the ee Can register be used for temporary storage? Conventions Caller Saved : Caller saves temporary values in its frame before the Callee Saved : Callee saves temporary values in its frame before using Callee restores them before urning to er x86-64 Linux Caller-saved Registers %rax Return value Also er-saved Can be modified by procedure %rdi,%rsi,%rdx,%rcx,%r8,%r9 Arguments Also er-saved Can be modified by procedure %r10, %r11 Caller-saved Can be modified by procedure Return value %rax Argument 1 %rdi Argument 2 %rsi Argument 3 %rdx Argument 4 %rcx Argument 5 %r8 Argument 6 %r9 Caller-saved %r10 temporaries %r11 CS429 Slideset 9: 39 CS429 Slideset 9: 40
11 x86-64 Linux Callee-saved Registers, %r12, %r13, %r14 %rbp Callee-saved Callee must save and restore Callee-saved Callee must save and restore May be used as frame pointer Can mix and match Special form of ee-saved Restored to original value upon exit from procedure Callee-saved %r12 Temporaries %r13 %r14 Special %rbp Special Callee-Saved Example #1 long incr2 ( long x ) long v2 = incr ( &v1, 3000 ) ; urn x + v2; incr2 : pushq subq $16, movq %rdi, movq $15213, 8( ) movl $3000, %esi leaq 8( ), %rdi incr, %rax $16, popq Initial Structure Rtn address Resulting Structure Rtn address Saved Unused CS429 Slideset 9: 41 CS429 Slideset 9: 42 Callee-Saved Example #2 Recursive Function long incr2 ( long x ) long v2 = incr ( &v1, 3000 ) ; urn x + v2; incr2 : pushq subq $16, movq %rdi, movq $15213, 8( ) movl $3000, %esi leaq 8( ), %rdi incr, %rax $16, popq Resulting Structure Rtn address Saved Unused Pre-urn Structure Rtn address urn 0; urn (x & 1) pushq movq %rdi, andl $1, %ebx shrq $1, %rdi pcount r, %rax popq CS429 Slideset 9: 43 CS429 Slideset 9: 44
12 Recursive Function Terminal Case Recursive Function Register Save urn 0; urn (x & 1) %rdi Argument x %rax Return value pushq movq andl shrq popq %rdi, $1, %ebx $1, %rdi pcount r, %rax urn 0; urn (x & 1) Rtn address Saved pushq movq andl shrq popq %rdi, $1, %ebx $1, %rdi pcount r, %rax %rdi Argument x %rax Return value CS429 Slideset 9: 45 CS429 Slideset 9: 46 Recursive Function Call Setup Recursive Function Call urn 0; urn (x & 1) Type %rdi x >> 1 Rec. argument %rax x & 1 Caller-saved pushq movq andl shrq popq %rdi, $1, %ebx $1, %rdi pcount r, %rax urn 0; urn (x & 1) Type x & 1 Callee-saved %rax Recursive urn value pushq movq %rdi, andl $1, %ebx shrq $1, %rdi popq pcount r, %rax CS429 Slideset 9: 47 CS429 Slideset 9: 48
13 Recursive Function Result Recursive Function Completion urn 0; urn (x & 1) Type x & 1 Callee-saved %rax Return value pushq movq %rdi, andl $1, %ebx shrq $1, %rdi pcount r popq, %rax urn 0; urn (x & 1) Type %rax Return value pushq movq %rdi, andl $1, %ebx shrq $1, %rdi pcount r, %rax popq CS429 Slideset 9: 49 CS429 Slideset 9: 50 Observations About Recursion Handled without Special Consideration frames mean that each function has private storage Saved registers and local variables Saved urn pointer Register saving conventions prevent one function from corrupting another s data Unless the C code explicitly does so (e.g., buffer overflow) discipline follows /urn pattern If P s Q, then Q urns before P Last-In, First-Out Also works for mutual recursion P s Q; Q s P x86-64 Procedure Summary Important Points is the right data structure for procedure / urn; if P s Q, then Q urns before P Recursion (and mutual recursion) are handled by normal ing conventions Can safely store values in local stack frame and in ee-saved registers Put function arguments at top of stack Result urn in %rax Pointers are addresses of values (on stack or global) Caller frame Arguments 7+ Return addr Frame pointer Old %rbp %rbp (optional) Saved Register + Local vars Argument pointer Build (optional) CS429 Slideset 9: 51 CS429 Slideset 9: 52
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
More informationMachine-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
More informationMachine-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
More informationBryant and O Hallaron, Computer Systems: A Programmer s Perspective, Third Edition. Carnegie Mellon
Carnegie Mellon Machine-Level Programming III: Procedures 15-213/18-213/14-513/15-513: Introduction to Computer Systems 7 th Lecture, September 18, 2018 Today Procedures Mechanisms Stack Structure Calling
More informationAssembly 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
More informationMachine- 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
More informationMachine-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
More informationProcedures 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*
More informationThe 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/
More informationThe 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
More informationMachine 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++;
More informationUniversity 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
More informationAssembly 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
More informationCS213. 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
More informationASSEMBLY 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
More informationAssembly 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
More informationSungkyunkwan 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
More informationStack 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()
More informationMachine- 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)
More informationSystems 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
More informationIA32 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
More informationThe 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
More informationGiving 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
More informationIA32 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
More informationAssembly 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
More informationAssembly 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
More information6.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
More informationPrinceton 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
More information%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
More informationvoid 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
More informationIA32 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
More informationX86 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
More informationRegion 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
More informationMachine 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
More informationAssembly 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
More informationData 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
More informationx86-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
More informationMachine-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
More informationStack 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
More informationAn 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
More informationCompiling 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ć
More informationFunction 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
More informationBuilding 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
More informationLecture 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
More informationAreas 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.
More informationAssembly Language: Function Calls" Goals of this Lecture"
Assembly Language: Function Calls" 1 Goals of this Lecture" Help you learn:" Function call problems:" Calling and urning" Passing parameters" Storing local variables" Handling registers without interference"
More informationCS24: 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
More informationLecture 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
More informationCSC 2400: Computing Systems. X86 Assembly: Function Calls"
CSC 24: Computing Systems X86 Assembly: Function Calls" 1 Lecture Goals! Challenges of supporting functions" Providing information for the called function" Function arguments and local variables" Allowing
More informationTopics of this Slideset. CS429: Computer Organization and Architecture. Instruction Set Architecture. Why Y86? Instruction Set Architecture
Topics of this Slideset CS429: Computer Organization and Architecture Dr. Bill Young Department of Computer Sciences University of Texas at Austin Intro to Assembly language Programmer visible state Y86
More informationFoundations 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)
More informationFunction Calls COS 217. Reading: Chapter 4 of Programming From the Ground Up (available online from the course Web site)
Function Calls COS 217 Reading: Chapter 4 of Programming From the Ground Up (available online from the course Web site) 1 Goals of Today s Lecture Finishing introduction to assembly language o EFLAGS register
More informationCS429: 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
More informationUniversity*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,
More informationProcedure Calls. Young W. Lim Sat. Young W. Lim Procedure Calls Sat 1 / 27
Procedure Calls Young W. Lim 2016-11-05 Sat Young W. Lim Procedure Calls 2016-11-05 Sat 1 / 27 Outline 1 Introduction References Stack Background Transferring Control Register Usage Conventions Procedure
More informationBuffer 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
More informationCredits and Disclaimers
Credits and Disclaimers 1 The eamples and discussion in the following slides have been adapted from a variet of sources, including: Chapter 3 of Computer Sstems 3 nd Edition b Brant and O'Hallaron 86 Assembl/GAS
More informationMachine 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
More informationMachine-Level Programming III: Procedures
Machine-Level Programming III: Procedures IA32 Region of memory managed with stack discipline Grows toward lower addresses Register indicates lowest stack address address of top element Bottom Increasing
More informationx86 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
More informationLecture 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
More informationBasic Data Types. CS429: Computer Organization and Architecture. Array Allocation. Array Access
Basic Data Types CS429: Computer Organization and Architecture Dr Bill Young Department of Computer Sciences University of Texas at Austin Last updated: October 31, 2017 at 09:37 Integral Stored and operated
More informationCSE 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,
More informationCSE351 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:
More informationAssembly Language: Function Calls" Goals of this Lecture"
Assembly Language: Function Calls" 1 Goals of this Lecture" Help you learn:" Function call problems:" Calling and returning" Passing parameters" Storing local variables" Handling registers without interference"
More informationRecitation: 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!
More informationAssembly Language: Function Calls. Goals of this Lecture. Function Call Problems
Assembly Language: Function Calls 1 Goals of this Lecture Help you learn: Function call problems: Calling and urning Passing parameters Storing local variables Handling registers without interference Returning
More informationCS 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
More informationCS429: Computer Organization and Architecture
CS429: Computer Organization and Architecture Dr. Bill Young Department of Computer Sciences University of Texas at Austin Last updated: October 11, 2017 at 17:42 CS429 Slideset 6: 1 Topics of this Slideset
More informationCS429: Computer Organization and Architecture
CS429: Computer Organization and Architecture Dr. Bill Young Department of Computer Sciences University of Texas at Austin Last updated: October 31, 2017 at 09:37 CS429 Slideset 10: 1 Basic Data Types
More informationHow 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
More informationx86-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
More informationPage 1. IA32 Stack CISC 360. Machine-Level Programming III: Procedures Sept. 22, IA32 Stack Popping Stack Bottom. IA32 Stack Pushing
CISC 36 Machine-Level Programming III: Procedures Sept. 22, 2 IA32 Region of memory managed with stack discipline Grows toward lower addresses Register indicates lowest stack address address of top element
More informationIntel 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
More informationAssembly Language: Function Calls
Assembly Language: Function Calls 1 Goals of this Lecture Help you learn: Function call problems: Calling and returning Passing parameters Storing local variables Handling registers without interference
More informationC 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
More informationHow 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 Programming
More informationBuffer 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.
More informationSystems 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
More information1 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
More informationCS24: INTRODUCTION TO COMPUTING SYSTEMS. Spring 2017 Lecture 7
CS24: INTRODUCTION TO COMPUTING SYSTEMS Spring 2017 Lecture 7 LAST TIME Dynamic memory allocation and the heap: A run-time facility that satisfies multiple needs: Programs can use widely varying, possibly
More information6.035 Project 3: Unoptimized Code Generation. Jason Ansel MIT - CSAIL
6.035 Project 3: Unoptimized Code Generation Jason Ansel MIT - CSAIL Quiz Monday 50 minute quiz Monday Covers everything up to yesterdays lecture Lexical Analysis (REs, DFAs, NFAs) Syntax Analysis (CFGs,
More informationComputer 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
More informationCSE 351 Section 4 GDB and x86-64 Assembly Hi there! Welcome back to section, we re happy that you re here
CSE 351 Section 4 GDB and x86-64 Assembly Hi there! Welcome back to section, we re happy that you re here x86-64 Assembly Language Assembly language is a human-readable representation of machine code instructions
More information18-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:
More informationCSC 8400: Computer Systems. Using the Stack for Function Calls
CSC 84: Computer Systems Using the Stack for Function Calls Lecture Goals Challenges of supporting functions! Providing information for the called function Function arguments and local variables! Allowing
More informationC 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
More informationCSE351 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
More informationCS356: Discussion #7 Buffer Overflows. Marco Paolieri
CS356: Discussion #7 Buffer Overflows Marco Paolieri (paolieri@usc.edu) Array Bounds class Bounds { public static void main(string[] args) { int[] x = new int[10]; for (int i = 0; i
More informationCS 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,
More informationCSC 2400: Computing Systems. X86 Assembly: Function Calls
CSC 24: Computing Systems X86 Assembly: Function Calls 1 Lecture Goals Challenges of supporting functions Providing information for the called function Function arguments and local variables Allowing the
More informationCredits 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
More informationAssembly I: Basic Operations. Jin-Soo Kim Computer Systems Laboratory Sungkyunkwan University
Assembly I: Basic Operations Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu Basic Execution Environment RAX RBX RCX RDX RSI RDI RBP RSP R8 R9 R10
More informationMachine- 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
More informationDo 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
More informationCS24: INTRODUCTION TO COMPUTING SYSTEMS. Spring 2017 Lecture 5
CS24: INTRODUCTION TO COMPUTING SYSTEMS Spring 2017 Lecture 5 LAST TIME Began exploring x86-64 instruction set architecture 16 general-purpose registers Also: All registers are 64 bits wide rax-rdx are
More informationQuestion Points Score Total: 100
Computer Science 2021 Spring 2016 Midterm Exam 1 February 29th, 2016 Time Limit: 50 minutes, 3:35pm-4:25pm This exam contains 7 pages (including this cover page) and 5 questions. Once we tell you to start,
More informationWhere 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
More informationCS429: Computer Organization and Architecture
CS429: Computer Organization and Architecture Warren Hunt, Jr. and Bill Young Department of Computer Sciences University of Texas at Austin Last updated: October 1, 2014 at 12:03 CS429 Slideset 6: 1 Topics
More informationPart 7. Stacks. Stack. Stack. Examples of Stacks. Stack Operation: Push. Piles of Data. The Stack
Part 7 Stacks The Stack Piles of Data Stack Stack A stack is an abstract data structure that stores objects Based on the concept of a stack of items like a stack of dishes Data can only be added to or
More information