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

Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

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
Software Design Refinement Using Design Patterns Instructor: Dr. Hany H. Ammar Dept. of Computer

Software Design Refinement Using Design Patterns Instructor: Dr. Hany H. Ammar Dept. of Computer

Software Design Refinement Using Design Patterns Instructor: Dr. Hany H. Ammar Dept. of Computer Science and Electrical Engineering, WVU 1 Outline The Requirements, Analysis, Design, and Design Refinement Models Class diagram

762 views • 51 slides
Memory Layout for Process Stack Data Code 0 CS 140 Lecture Notes: Linkers Slide 1

Memory Layout for Process Stack Data Code 0 CS 140 Lecture Notes: Linkers Slide 1

Memory Layout for Process Stack Data Code 0 CS 140 Lecture Notes: Linkers Slide 1 Creating a Process Source Assembly Object Executable Code Code File 10101010 10101010 10101010 10101010 10101010 10101010 x.c cc x.s as

250 views • 8 slides
The Desig ign Process Embodiment Design and Detail Design Grant Crawford 3-22-2017 Revised

The Desig ign Process Embodiment Design and Detail Design Grant Crawford 3-22-2017 Revised

The Desig ign Process Embodiment Design and Detail Design Grant Crawford 3-22-2017 Revised Stanley Howard 2-20-2019 The Design Process Three Major Phases 1. Conceptual Design 2. Embodiment Design 3. Detailed Design Others 4. Planning

506 views • 34 slides
UNIX Process Control Its CPU state (register values). Bach 7 Its address space (memory

UNIX Process Control Its CPU state (register values). Bach 7 Its address space (memory

Process: A Context for Computation A process is largely defined by: UNIX Process Control Its CPU state (register values). Bach 7 Its address space (memory contents). Its environment (as reflected in Operating Systems Course

436 views • 5 slides
Database Design Process Requirements analysis Conceptual design: Entity-Relationship Model

Database Design Process Requirements analysis Conceptual design: Entity-Relationship Model

IT360: Applied Database Systems Slide Set: #3 Relational Model (Chapter 2) ER To Relational 1 Database Design Process Requirements analysis Conceptual design: Entity-Relationship Model Logical design: transform ER model into

413 views • 27 slides
Reducing Communication in Sparse Matrix Operations 2018 Blue Waters Symposium Luke Olson

Reducing Communication in Sparse Matrix Operations 2018 Blue Waters Symposium Luke Olson

Reducing Communication in Sparse Matrix Operations 2018 Blue Waters Symposium Luke Olson Department of Computer Science, University of Illinois at Urbana-Champaign Collaborators on this allocation: Amanda Bienz , University of Illinois at

446 views • 26 slides
Standard Cell Design Advanced VLSI Design CMPE 414 Standard Cell Libraries Standard cell

Standard Cell Design Advanced VLSI Design CMPE 414 Standard Cell Libraries Standard cell

Standard Cell Design Advanced VLSI Design CMPE 414 Standard Cell Libraries Standard cell libraries are required by almost all CAD tools for chip design Standard cell libraries contain primitive cells required for digital design However, more

213 views • 10 slides
The Best of Apache Kafka Architecture Ranganathan Balashanmugam @ran_than Hell Budapest

The Best of Apache Kafka Architecture Ranganathan Balashanmugam @ran_than Hell Budapest

Apache: Big Data 2015 The Best of Apache Kafka Architecture Ranganathan Balashanmugam @ran_than Hell Budapest About Me Graduated as Civil Engineer. <dev> 10+ years </dev> <Thoughtworker from=India/>

515 views • 33 slides

More recommend