process layout and function calls
play

Process Layout and Function Calls CS 161 Spring 2017 1 / 8 - PowerPoint PPT Presentation

Nov 08, 2022 •134 likes •440 views

Process Layout and Function Calls CS 161 Spring 2017 1 / 8 Process Layout in Memory 0xc0000000 Stack Stack high address grows towards decreasing addresses. dynamic is initialized at run-time . growth Heap grow

  1. Process Layout and Function Calls CS 161 – Spring 2017 1 / 8

  2. Process Layout in Memory 0xc0000000 ◮ Stack Stack high address ◮ grows towards decreasing addresses. dynamic ◮ is initialized at run-time . growth ◮ Heap ◮ grow towards increasing addresses. Heap ◮ is initialized at run-time . ◮ BSS section BSS ◮ size fixed at compile-time . Data ◮ is initialized at run-time . low address Text ◮ was grouped into Data in CS61C. 0x08048000 ◮ Data section ◮ is initialized at compile-time . ◮ Text section ◮ holds the program instructions (read-only). Process Layout 2 / 8

  3. Process Layout in Memory 0xc0000000 ◮ Stack Stack high address ◮ grows towards decreasing addresses. dynamic ◮ is initialized at run-time . growth ◮ Heap ◮ grow towards increasing addresses. Heap ◮ is initialized at run-time . ◮ BSS section BSS ◮ size fixed at compile-time . Data ◮ is initialized at run-time . low address Text ◮ was grouped into Data in CS61C. 0x08048000 ◮ Data section uninitialized variables ◮ is initialized at compile-time . initialized variables ◮ Text section ◮ holds the program instructions (read-only). Process Layout 2 / 8

  4. IA-32 Caveats Key Differences Between AT&T Syntax and Intel Syntax 1 AT&T Intel Parameter src before dst dst before src Order movl $4, %eax mov eax, 5 Parameter Mnemonics suffixed with Derived from name of reg- Size a letter indicating size of ister that is used (e.g. rax, operands: q for qword, l for eax, ax, al imply q, l, w, b, long (dword), w for word, respectively) and b for byte addl $4, %esp add esp, 4 Sigils Immediate values prefixed Assembler automatically de- with a $ , registers prefixed tects type of symbols; i.e., whether they are registers, with a % constants or something else [1] Adapted from: https://en.wikipedia.org/wiki/X86_assembly_language#Syntax IA-32 3 / 8

  5. Function Calls void foo(int a, int b, int c) { int bar[2]; char qux[3]; bar[0] = ’A’; qux[0] = 0x42; } int main(void) { int i = 1; foo(1, 2, 3); return 0; } Function Calls 4 / 8

  6. Function Calls in Assembler int main(void) ebp { int i = 1; esp foo(1, 2, 3); Larger Memory Addresses return 0; } main: pushl %ebp movl %esp,%ebp subl $4,%esp movl $1,-4(%ebp) pushl $3 pushl $2 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  7. Function Calls in Assembler int main(void) ebp { int i = 1; foo(1, 2, 3); Larger Memory Addresses esp sfp return 0; } main: pushl %ebp movl %esp,%ebp subl $4,%esp movl $1,-4(%ebp) pushl $3 pushl $2 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  8. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses esp + ebp sfp return 0; } main: pushl %ebp movl %esp,%ebp subl $4,%esp movl $1,-4(%ebp) pushl $3 pushl $2 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  9. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses ebp sfp return 0; esp } main: pushl %ebp movl %esp,%ebp subl $4,%esp movl $1,-4(%ebp) pushl $3 pushl $2 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  10. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses ebp sfp return 0; 1 esp } main: pushl %ebp movl %esp,%ebp subl $4,%esp movl $1,-4(%ebp) pushl $3 pushl $2 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  11. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses ebp sfp return 0; 1 } 3 main: 2 pushl %ebp 1 esp movl %esp,%ebp subl $4,%esp movl $1,-4(%ebp) pushl $3 pushl $2 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  12. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses ebp sfp return 0; 1 } 3 main: 2 pushl %ebp 1 movl %esp,%ebp rip esp subl $4,%esp movl $1,-4(%ebp) pushl $3 pushl $2 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  13. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ebp sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 movl %esp,%ebp rip esp subl $12,%esp movl $65,-8(%ebp) movb $66,-12(%ebp) leave ret Larger Memory Addresses Function Calls 5 / 8

  14. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ebp sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 movl %esp,%ebp rip subl $12,%esp esp sfp movl $65,-8(%ebp) movb $66,-12(%ebp) leave ret Larger Memory Addresses Function Calls 5 / 8

  15. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ofp (m) sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 movl %esp,%ebp rip subl $12,%esp esp + ebp sfp movl $65,-8(%ebp) movb $66,-12(%ebp) leave ret Larger Memory Addresses Function Calls 5 / 8

  16. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ofp (m) sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 movl %esp,%ebp rip subl $12,%esp ebp sfp movl $65,-8(%ebp) movb $66,-12(%ebp) leave esp ret Larger Memory Addresses Function Calls 5 / 8

  17. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ofp (m) sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 movl %esp,%ebp rip subl $12,%esp ebp sfp movl $65,-8(%ebp) movb $66,-12(%ebp) 00 00 00 41 leave esp ret Larger Memory Addresses Function Calls 5 / 8

  18. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ofp (m) sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 movl %esp,%ebp rip subl $12,%esp ebp sfp movl $65,-8(%ebp) movb $66,-12(%ebp) 00 00 00 41 leave 42 esp ret Larger Memory Addresses Function Calls 5 / 8

  19. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ofp (m) sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 movl %esp,%ebp rip subl $12,%esp esp + ebp sfp movl $65,-8(%ebp) movb $66,-12(%ebp) 00 00 00 41 leave: leave movl %ebp,%esp 42 popl %ebp ret Larger Memory Addresses Function Calls 5 / 8

  20. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ebp sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 movl %esp,%ebp rip esp subl $12,%esp sfp movl $65,-8(%ebp) movb $66,-12(%ebp) 00 00 00 41 leave: leave movl %ebp,%esp 42 popl %ebp ret Larger Memory Addresses Function Calls 5 / 8

  21. Function Calls in Assembler void foo(int a, int b, int c) { ofp int bar[2]; char qux[3]; bar[0] = ’A’; Larger Memory Addresses ebp sfp qux[0] = 0x42; 1 } 3 foo: 2 pushl %ebp 1 esp movl %esp,%ebp rip subl $12,%esp sfp movl $65,-8(%ebp) movb $66,-12(%ebp) 00 00 00 41 ret: leave popl %eip 42 ret Larger Memory Addresses Function Calls 5 / 8

  22. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses ebp sfp return 0; 1 } 3 main: 2 pushl %ebp 1 esp movl %esp,%ebp rip subl $4,%esp sfp movl $1,-4(%ebp) pushl $3 00 00 00 41 pushl $2 42 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  23. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses ebp sfp return 0; 1 esp } 3 main: 2 pushl %ebp 1 movl %esp,%ebp rip subl $4,%esp sfp movl $1,-4(%ebp) pushl $3 00 00 00 41 pushl $2 42 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  24. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses ebp sfp return 0; 1 esp } 3 main: 2 pushl %ebp 1 movl %esp,%ebp rip subl $4,%esp sfp movl $1,-4(%ebp) pushl $3 00 00 00 41 pushl $2 42 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

  25. Function Calls in Assembler int main(void) ofp { int i = 1; foo(1, 2, 3); Larger Memory Addresses esp + ebp sfp return 0; 1 } 3 main: 2 pushl %ebp 1 movl %esp,%ebp rip subl $4,%esp sfp movl $1,-4(%ebp) pushl $3 00 00 00 41 pushl $2 42 pushl $1 call foo addl $12,%esp Larger Memory Addresses xorl %eax,%eax leave ret Function Calls 5 / 8

Recommend

Process Layout and Function Calls CS 161 Spring 2016 January 25, 2016 1 / 7 Process Layout

Process Layout and Function Calls CS 161 Spring 2016 January 25, 2016 1 / 7 Process Layout

Process Layout and Function Calls CS 161 Spring 2016 January 25, 2016 1 / 7 Process Layout in Memory 0xc0000000 Stack Stack high address grows towards decreasing addresses. dynamic is initialized at run-time . growth

610 views • 29 slides
Recursion A process by which a function calls itself repeatedly. Either directly. X

Recursion A process by which a function calls itself repeatedly. Either directly. X

1/28/2016 Recursion A process by which a function calls itself repeatedly. Either directly. X calls X. Or cyclically in a chain. X calls Y, and Y calls X. Used for repetitive computations in which each action is stated in

290 views • 10 slides
Recursion 1 Recursion n A process by which a function calls itself repeatedly Either

Recursion 1 Recursion n A process by which a function calls itself repeatedly Either

Recursion 1 Recursion n A process by which a function calls itself repeatedly Either directly. n X calls X Or cyclically in a chain. n X calls Y, and Y calls X n Used for repetitive computations in which each action is stated in terms of a

519 views • 51 slides
Function Calls Function Calls Python supports expressions with math-like functions A

Function Calls Function Calls Python supports expressions with math-like functions A

Module 3 Function Calls Function Calls Python supports expressions with math-like functions A function in an expression is a function call Function calls have the form name (x,y,) function argument name Arguments are

333 views • 20 slides
Review: Stack Frame CS451 16 Spring Process memory layout Stack is used to store data

Review: Stack Frame CS451 16 Spring Process memory layout Stack is used to store data

Review: Stack Frame CS451 16 Spring Process memory layout Stack is used to store data associated stack with function calls Data stores static data where values can change. data segment On top of it, dynamic data is allocated with malloc()

328 views • 20 slides
Registers and Stack Frames Lecture 6 Function calls and stack frames function invocation

Registers and Stack Frames Lecture 6 Function calls and stack frames function invocation

Registers and Stack Frames Lecture 6 Function calls and stack frames function invocation contexts are strictly nested stack mechanism is adequate for managing parameters and locals Information needed for function calls arguments

577 views • 14 slides
Recursion What happens when a function calls itself? This is known as a recursive function

Recursion What happens when a function calls itself? This is known as a recursive function

Recursion What happens when a function calls itself? This is known as a recursive function Recursion What happens when a function calls itself? This is known as a recursive function Every function call is added to the stack

482 views • 19 slides
Recall: Function Calls to Create Transform Matrices Previously made function calls to generate

Recall: Function Calls to Create Transform Matrices Previously made function calls to generate

Recall: Function Calls to Create Transform Matrices Previously made function calls to generate 4x4 matrices for identity, translate, scale, rotate transforms Put transform matrix into CTM Example CTM Matrix 1 0 0 0

609 views • 34 slides
Agenda Phone Overview Layout Display Keys Working with Calls

Agenda Phone Overview Layout Display Keys Working with Calls

Agenda Phone Overview Layout Display Keys Working with Calls Answering Your Phone Forwarding Calls Place on Hold Transfer Working with Voicemail Setting up voicemail Listening

276 views • 12 slides
Chapter 13 Recursion 1 Recursion A function that "calls itself" In function

Chapter 13 Recursion 1 Recursion A function that "calls itself" In function

Chapter 13 Recursion 1 Recursion A function that "calls itself" In function definition, call to same function Divide and Conquer Basic design technique Break large task into subtasks Use recursion when subtasks

461 views • 16 slides
Functions Function Calls Python supports expressions with math-like functions A function

Functions Function Calls Python supports expressions with math-like functions A function

Mini-Lecture 4 Functions Function Calls Python supports expressions with math-like functions A function in an expression is a function call Will explain the meaning of this later Function expressions have the form fun (x,y,)

411 views • 15 slides
CSE 351: The Hardware/Software Interface Section 4 Procedure calls Procedure calls In x86

CSE 351: The Hardware/Software Interface Section 4 Procedure calls Procedure calls In x86

CSE 351: The Hardware/Software Interface Section 4 Procedure calls Procedure calls In x86 assembly, values are passed to function calls on the stack Perks: Concise, easy to remember Drawbacks: Always requires memory accesses In

496 views • 14 slides
CSC 2400: Computer Systems Using the Stack for Function Calls Lecture Goals int add3(int a, int

CSC 2400: Computer Systems Using the Stack for Function Calls Lecture Goals int add3(int a, int

CSC 2400: Computer Systems Using the Stack for Function Calls Lecture Goals int add3(int a, int b, int c) { int d; How are function calls d = a + b + c; implemented at the return d; } machine level? int main() { int sum, avg;

782 views • 42 slides
Layout Dynamic layout Layout design pattern Layout strategies 2 Dynamic Layout Applications

Layout Dynamic layout Layout design pattern Layout strategies 2 Dynamic Layout Applications

Layout Dynamic layout Layout design pattern Layout strategies 2 Dynamic Layout Applications need to be able to adjust the presentation of our interfaces. We need to dynamically reposition and resize our content in response to: Change in

681 views • 28 slides
Layout Dynamic layout Layout design pattern Layout strategies 2 Dynamic Layout Applications

Layout Dynamic layout Layout design pattern Layout strategies 2 Dynamic Layout Applications

Layout Dynamic layout Layout design pattern Layout strategies 2 Dynamic Layout Applications need to be able to adjust the presentation of our interfaces. We need to dynamically reposition and resize our content in response to: Change in

594 views • 26 slides
MIPS Procedure Calls Lecture 6 CS301 Function Call Steps Place parameters in accessible

MIPS Procedure Calls Lecture 6 CS301 Function Call Steps Place parameters in accessible

MIPS Procedure Calls Lecture 6 CS301 Function Call Steps Place parameters in accessible location Transfer control to function Acquire storage for procedure variables Perform calculations in function Place result in place

393 views • 26 slides
Dynamic Memory Management 333 Dynamic Memory Management Process Memory Layout Process Memory

Dynamic Memory Management 333 Dynamic Memory Management Process Memory Layout Process Memory

Dynamic Memory Management Dynamic Memory Management 333 Dynamic Memory Management Process Memory Layout Process Memory Layout (1) Each Linux process runs within its own virtual address space tables and the MMU (if available) security due to

1.25k views • 68 slides
What does the compiler actually do with my code? An introduction to the C++ ABI Filip

What does the compiler actually do with my code? An introduction to the C++ ABI Filip

What does the compiler actually do with my code? An introduction to the C++ ABI Filip Strmbck 1 Introduction 2 What is an ABI? 3 Object layout 4 Function calls 5 Virtual functions 6 Exceptions What does the compiler actually do with my

714 views • 60 slides
Interprocedural Analysis with Data-Dependent Calls Circularity dilemma In languages with function

Interprocedural Analysis with Data-Dependent Calls Circularity dilemma In languages with function

Interprocedural Analysis with Data-Dependent Calls Circularity dilemma In languages with function pointers, first-class functions, or Problem: dynamically dispatched messages, callee(s) at call site 1. to compute possible callees, depend on

286 views • 6 slides
AGENDA Process Ministry Space Needs Master Plan Layout Overall Master Plan Probable Phase I

AGENDA Process Ministry Space Needs Master Plan Layout Overall Master Plan Probable Phase I

AGENDA Process Ministry Space Needs Master Plan Layout Overall Master Plan Probable Phase I Exterior Images Floor Plans & Worship Layout Interior Images Building Information and Cost Next Steps Discussion PROCESS First Meeting May,

548 views • 39 slides
A ROADMAP FOR Implementing FORWARD THROUGH the Calls to Action FERGUSON PROCESS 1 12/7/15

A ROADMAP FOR Implementing FORWARD THROUGH the Calls to Action FERGUSON PROCESS 1 12/7/15

12/7/15 A ROADMAP FOR Implementing FORWARD THROUGH the Calls to Action FERGUSON PROCESS 1 12/7/15 THE PROCESS SO FAR Typical Collective Impact Ferguson Commission Network Mindset Supports Detailed Universa l Member existing

401 views • 13 slides
The Geometry of Innocent Flesh on the Bone Return-into-libc without Function Calls (on the x86)

The Geometry of Innocent Flesh on the Bone Return-into-libc without Function Calls (on the x86)

The Geometry of Innocent Flesh on the Bone Return-into-libc without Function Calls (on the x86) Hovav Shacham CCS 07 hovav@cs.ucsd.edu Technical Background Gadget: a short instructions sequence (e.x. pop %edx; ret;)

520 views • 31 slides
Lecture 4: Procedure Calls Todays topics: Procedure calls Large constants The

Lecture 4: Procedure Calls Todays topics: Procedure calls Large constants The

Lecture 4: Procedure Calls Todays topics: Procedure calls Large constants The compilation process Reminder: Assignment 1 is due on Thursday 1 Recap The jal instruction is used to jump to the procedure and save the

442 views • 23 slides
CS/EE 6710 Introduction to Layout Inverter Layout Example Layout Design Rules Composite Layout

CS/EE 6710 Introduction to Layout Inverter Layout Example Layout Design Rules Composite Layout

CS/EE 6710 Introduction to Layout Inverter Layout Example Layout Design Rules Composite Layout Drawing the mask layers that will be used by the fabrication folks to make the devices Very different from schematics In schematics

486 views • 24 slides

More recommend