CSC 252: Computer Organization Spring 2018: Lecture 6
|
|
|
- Kerry Palmer
- 5 years ago
- Views:
Transcription
1 CSC 252: Computer Organization Spring 2018: Lecture 6 Instructor: Yuhao Zhu Department of Computer Science University of Rochester Action Items: Assignment 2 is out
2 Announcement Programming Assignment 2 is out Due on Feb 16, 11:59 PM You may still have 3 slip days Read the instructions before getting started!!! You get 1/4 point off for every wrong answer Maxed out at 10 due 2
3 Announcement Programming Assignment 2 is out Due on Feb 16, 11:59 PM You may still have 3 slip days Read the instructions before getting started!!! You get 1/4 point off for every wrong answer Maxed out at 10 2
4 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); 3
5 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); Memory Content Memory Address 0x10 0x11 0x16 3
6 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); Memory Content Memory Address 0x10 0x11 0x16 3
7 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a Memory Content 4 Memory Address 0x10 0x11 0x16 3
8 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a Memory Content 4 Memory Address 0x10 0x11 0x16 3
9 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 0x16 3
10 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 0x16 3
11 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 The content of a pointer variable is memory address. 0x16 3
12 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 The content of a pointer variable is memory address. c random 0x16 3
13 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 The content of a pointer variable is memory address. c random 0x16 3
14 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 The content of a pointer variable is memory address. The & operator (address-of operator) returns the memory address of a variable. c random 0x16 3
15 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 The content of a pointer variable is memory address. The & operator (address-of operator) returns the memory address of a variable. c random 0x10 0x16 3
16 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 The content of a pointer variable is memory address. The & operator (address-of operator) returns the memory address of a variable. c random 0x10 0x16 3
17 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 3 Memory Address 0x10 0x11 The content of a pointer variable is memory address. The & operator (address-of operator) returns the memory address of a variable. The * operator returns the content stored at the memory location pointed by the pointer variable (dereferencing) c random 0x10 0x16 3
18 How Does Pointer Work in C??? char a = 4; char b = 3; char *c; c = &a; b += (*c); C Variable a b Memory Content 4 37 Memory Address 0x10 0x11 The content of a pointer variable is memory address. The & operator (address-of operator) returns the memory address of a variable. The * operator returns the content stored at the memory location pointed by the pointer variable (dereferencing) c random 0x10 0x16 3
19 Memory Addressing Modes An addressing mode specifies: how to calculate the effective memory address of an operand by using information held in registers and/or constants 4
20 Memory Addressing Modes An addressing mode specifies: how to calculate the effective memory address of an operand by using information held in registers and/or constants Normal: (R) Memory address: content of Register R (Reg[R]) Essentially pointer dereferencing in C movq (%rcx),%rax; // address = %rcx 4
21 Memory Addressing Modes An addressing mode specifies: how to calculate the effective memory address of an operand by using information held in registers and/or constants Normal: (R) Memory address: content of Register R (Reg[R]) Essentially pointer dereferencing in C movq (%rcx),%rax; // address = %rcx Displacement: D(R) Memory address: Reg[R]+D Register R specifies start of memory region Constant displacement D specifies offset movq 8(%rbp),%rdx; // address = %rbp + 8 4
22 Complete Memory Addressing Modes Most General Form: D(Rb,Ri,S) Memory address: Reg[Rb] + S * Reg[Ri] + D E.g., 8(%eax, %ebx, 4); // address = %eax + 4 * %ebx + 8 D: Constant displacement Rb: Base register: Any of 16 integer registers Ri: Index register: Any, except for %rsp S: Scale: 1, 2, 4, or 8 5
23 Complete Memory Addressing Modes Most General Form: D(Rb,Ri,S) Memory address: Reg[Rb] + S * Reg[Ri] + D E.g., 8(%eax, %ebx, 4); // address = %eax + 4 * %ebx + 8 D: Constant displacement Rb: Base register: Any of 16 integer registers Ri: Index register: Any, except for %rsp S: Scale: 1, 2, 4, or 8 Special Cases (Rb,Ri) D(Rb,Ri) (Rb,Ri,S) Reg[Rb]+Reg[Ri] Reg[Rb]+Reg[Ri]+D Reg[Rb]+S*Reg[Ri] 5
24 Address Computation Examples %rdx %rcx 0xf000 0x0100 Expression Address Computation Address 0x8(%rdx) (%rdx,%rcx) (%rdx,%rcx,4) 0x80(,%rdx,2) 6
25 Address Computation Examples %rdx %rcx 0xf000 0x0100 Expression Address Computation Address 0x8(%rdx) (%rdx,%rcx) 0xf x8 0xf008 (%rdx,%rcx,4) 0x80(,%rdx,2) 6
26 Address Computation Examples %rdx %rcx 0xf000 0x0100 Expression Address Computation Address 0x8(%rdx) (%rdx,%rcx) 0xf x8 0xf x100 0xf008 0xf100 (%rdx,%rcx,4) 0x80(,%rdx,2) 6
27 Address Computation Examples %rdx %rcx 0xf000 0x0100 Expression Address Computation Address 0x8(%rdx) (%rdx,%rcx) (%rdx,%rcx,4) 0x80(,%rdx,2) 0xf x8 0xf x100 0xf *0x100 0xf008 0xf100 0xf400 6
28 Address Computation Examples %rdx %rcx 0xf000 0x0100 Expression Address Computation Address 0x8(%rdx) (%rdx,%rcx) (%rdx,%rcx,4) 0x80(,%rdx,2) 0xf x8 0xf x100 0xf *0x100 2*0xf x80 0xf008 0xf100 0xf400 0x1e080 6
29 Address Computation Instruction leaq 4(%rsi,%rdi,2), %rax 7
30 Address Computation Instruction leaq 4(%rsi,%rdi,2), %rax %rax = %rsi + %rdi *
31 Address Computation Instruction leaq 4(%rsi,%rdi,2), %rax leaq Src, Dst %rax = %rsi + %rdi * Src is address mode expression Set Dst to address denoted by expression No actual memory reference is made 7
32 Address Computation Instruction leaq 4(%rsi,%rdi,2), %rax leaq Src, Dst Src is address mode expression Set Dst to address denoted by expression No actual memory reference is made Uses %rax = %rsi + %rdi * Computing addresses without a memory reference E.g., translation of p = &x[i]; 7
33 Address Computation Instruction Interesting Use Computing arithmetic expressions of the form x + k*y Faster arithmetic computation 8
34 Address Computation Instruction Interesting Use Computing arithmetic expressions of the form x + k*y Faster arithmetic computation long m12(long x) { return x*12; } 8
35 Address Computation Instruction Interesting Use Computing arithmetic expressions of the form x + k*y Faster arithmetic computation long m12(long x) { return x*12; } Converted to ASM by compiler: leaq (%rdi,%rdi,2), %rax # t <- x+x*2 salq $2, %rax # return t<<2 8
36 Assembly Program Instructions Assembly Programmer s Perspective of a Computer CPU PC ALU Register File Condition Codes Addresses Data Instructions Memory Code Data Stack Heap 9
37 Assembly Program Instructions Assembly Programmer s Perspective of a Computer CPU PC ALU Register File Condition Codes Addresses Data Instructions Memory Code Data Stack Heap Data Movement Instruction: Transfer data between memory and register movq %eax, (%ebx) 9
38 Assembly Program Instructions Assembly Programmer s Perspective of a Computer CPU PC ALU Register File Condition Codes Addresses Data Instructions Memory Code Data Stack Heap Data Movement Instruction: Transfer data between memory and register movq %eax, (%ebx) Compute Instruction: Perform arithmetics on register or memory data addq %eax, %ebx C constructs: +, -, >>, etc. 9
39 Assembly Program Instructions Assembly Programmer s Perspective of a Computer CPU PC ALU Register File Condition Codes Addresses Data Instructions Memory Code Data Stack Heap Data Movement Instruction: Transfer data between memory and register movq %eax, (%ebx) Compute Instruction: Perform arithmetics on register or memory data addq %eax, %ebx C constructs: +, -, >>, etc. Control Instruction: Alter the sequence of instructions (by changing PC) jmp, call C constructs: if-else, do-while, function call, etc. 9
40 Today: Compute and Control Instructions Arithmetic & logical operations Control: Condition codes Conditional branches (if else ) Loops (for, while) Switch Statements (case switch ) 10
41 Some Arithmetic Operations (2 Operands) Format Computation Notes addq src, dest Dest = Dest + Src 11
42 Some Arithmetic Operations (2 Operands) Format Computation Notes addq src, dest Dest = Dest + Src addq %rax, %rbx 11
43 Some Arithmetic Operations (2 Operands) Format Computation Notes addq src, dest Dest = Dest + Src + u v u + v TAdd w (u, v) addq %rax, %rbx 11
44 Some Arithmetic Operations (2 Operands) Format Computation Notes addq src, dest Dest = Dest + Src + u v u + v TAdd w (u, v) addq %rax, %rbx %rbx = %rax + %rbx Truncation if overflow, set carry bit (more later ) 11
45 Some Arithmetic Operations (2 Operands) Format Computation Notes addq src, dest Dest = Dest + Src subq src, dest Dest = Dest - Src imulq src, dest Dest = Dest * Src salq src, dest Dest = Dest << Src Also called shlq sarq src, dest Dest = Dest >> Src Arithmetic shift shrq src, dest Dest = Dest >> Src Logical shift xorq src, dest andq src, dest orq src, dest Dest = Dest ^ Src Dest = Dest & Src Dest = Dest Src 12
46 Some Arithmetic Operations (2 Operands) No distinction between signed and unsigned (why?) Bit level behaviors for signed and unsigned arithmetic are exactly the same assuming truncation 13
47 Some Arithmetic Operations (2 Operands) No distinction between signed and unsigned (why?) Bit level behaviors for signed and unsigned arithmetic are exactly the same assuming truncation long signed_add (long x, long y) { long res = x + y; return res; } #x in %rdx, y in %rax addq %rdx, %rax 13
48 Some Arithmetic Operations (2 Operands) No distinction between signed and unsigned (why?) Bit level behaviors for signed and unsigned arithmetic are exactly the same assuming truncation long signed_add (long x, long y) { long res = x + y; return res; } #x in %rdx, y in %rax addq %rdx, %rax long unsigned_add (unsigned long x, unsigned long y) { unsigned long res = x + y; return res; } #x in %rdx, y in %rax addq %rdx, %rax 13
49 Some Arithmetic Operations (2 Operands) No distinction between signed and unsigned (why?) Bit level behaviors for signed and unsigned arithmetic are exactly the same assuming truncation Bit-level 010 +) long signed_add (long x, long y) { long res = x + y; return res; } long unsigned_add (unsigned long x, unsigned long y) { unsigned long res = x + y; return res; } #x in %rdx, y in %rax addq %rdx, %rax #x in %rdx, y in %rax addq %rdx, %rax 13
50 Some Arithmetic Operations (2 Operands) No distinction between signed and unsigned (why?) Bit level behaviors for signed and unsigned arithmetic are exactly the same assuming truncation Bit-level Signed 010 +) long signed_add (long x, long y) { long res = x + y; return res; } 2 +) -3-1 long unsigned_add (unsigned long x, unsigned long y) { unsigned long res = x + y; return res; } #x in %rdx, y in %rax addq %rdx, %rax #x in %rdx, y in %rax addq %rdx, %rax 13
51 Some Arithmetic Operations (2 Operands) No distinction between signed and unsigned (why?) Bit level behaviors for signed and unsigned arithmetic are exactly the same assuming truncation Bit-level Signed Unsigned ) 101 +) -3 +) long signed_add (long x, long y) { long res = x + y; return res; } -1 long unsigned_add (unsigned long x, unsigned long y) { unsigned long res = x + y; return res; } 7 #x in %rdx, y in %rax addq %rdx, %rax #x in %rdx, y in %rax addq %rdx, %rax 13
52 Some Arithmetic Operations (1 Operand) Unary Instructions (one operand) Format Computation incq dest Dest = Dest + 1 decq dest Dest = Dest - 1 negq dest Dest = -Dest notq dest Dest = ~Dest 14
53 Some Arithmetic Operations (1 Operand) Unary Instructions (one operand) Format Computation incq dest Dest = Dest + 1 decq dest Dest = Dest - 1 negq dest Dest = -Dest notq dest Dest = ~Dest Questions? 14
54 Today: Compute and Control Instructions Arithmetic & logical operations Control: Condition codes Conditional branches (if else ) Loops (for, while) Switch Statements (case switch ) 15
55 Three Basic Programming Constructs 16
56 Three Basic Programming Constructs Sequential Subtask 1 Subtask 2 a = x + y; y = a - c; 16
57 Three Basic Programming Constructs Sequential Conditional Subtask 1 True Test Condition False Subtask 2 Subtask 1 Subtask 2 a = x + y; y = a - c; if (x > y) r = x - y; else r = y - x; 16
58 Three Basic Programming Constructs Sequential Conditional Iterative Subtask 1 True Test False Test Condition Condition False Subtask 2 Subtask 1 Subtask 2 True Subtask a = x + y; y = a - c; if (x > y) r = x - y; else r = y - x; while (x > 0) { } x -; 16
59 Three Basic Programming Constructs Conditional True Test Condition False Subtask 1 Subtask 2 if (x > y) r = x - y; else r = y - x; 17
60 Three Basic Programming Constructs Both conditional and iterative programming requires altering the sequence of instructions (control flow) True Conditional Test Condition False Subtask 1 Subtask 2 if (x > y) r = x - y; else r = y - x; 17
61 Three Basic Programming Constructs Both conditional and iterative programming requires altering the sequence of instructions (control flow) We need a set of control instructions to do so True Conditional Test Condition False Subtask 1 Subtask 2 if (x > y) r = x - y; else r = y - x; 17
62 Three Basic Programming Constructs Both conditional and iterative programming requires altering the sequence of instructions (control flow) We need a set of control instructions to do so Two fundamental questions: How to test condition and how to represent test results? True Conditional Test Condition False Subtask 1 Subtask 2 How to alter control flow according to the test results? if (x > y) r = x - y; else r = y - x; 17
63 Condition Codes Hold Test Results Assembly Programmer s Perspective of a Computer CPU PC ALU Register File Condition Codes Addresses Data Instructions Memory Code Data Stack Heap 18
64 Condition Codes Hold Test Results Assembly Programmer s Perspective of a Computer CPU PC ALU Register File Condition Codes Addresses Data Instructions Memory Code Data Stack Heap Condition Codes Hold the status of most recent test 4 common condition codes in x86-64 A set of special registers (more often: bits in one single register) Sometimes also called: Status Register, Flag Register 18
65 Condition Codes Hold Test Results Assembly Programmer s Perspective of a Computer CPU PC ALU Register File Condition Codes Addresses Data Instructions Memory Code Data Stack Heap Condition Codes Hold the status of most recent test 4 common condition codes in x86-64 CF ZF SF OF A set of special registers (more often: bits in one single register) Sometimes also called: Status Register, Flag Register 18
66 Condition Codes Hold Test Results Assembly Programmer s Perspective of a Computer CPU PC ALU Register File Condition Codes Addresses Data Instructions Memory Code Data Stack Heap Condition Codes Hold the status of most recent test 4 common condition codes in x86-64 CF ZF SF OF A set of special registers (more often: bits in one single register) Sometimes also called: Status Register, Flag Register CF Carry Flag (for unsigned) ZF Zero Flag SF Sign Flag OF Overflow Flag (for signed) 18
67 Explicit Set Condition Codes: Compare cmpq Src2, Src1 19
68 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction 19
69 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction cmpq b,a like computing a-b, and sets condition codes accordingly 19
70 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction cmpq b,a like computing a-b, and sets condition codes accordingly cmpq 0xFF, 0x80 (assuming 8-bit word size here) 0 CF 0 ZF 0 SF 0 OF 19
71 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction cmpq b,a like computing a-b, and sets condition codes accordingly CF (Carry Flag): Treat a and b as unsigned value, set CF if a-b generates a borrow out of the most significant bit (i.e., a < b). Effectively detecting overflow for unsigned cmpq 0xFF, 0x80 (assuming 8-bit word size here) 0 CF 0 ZF 0 SF 0 OF 19
72 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction cmpq b,a like computing a-b, and sets condition codes accordingly CF (Carry Flag): Treat a and b as unsigned value, set CF if a-b generates a borrow out of the most significant bit (i.e., a < b). Effectively detecting overflow for unsigned cmpq 0xFF, 0x80 (assuming 8-bit word size here) 01 CF 0 ZF 0 SF 0 OF 19
73 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction cmpq b,a like computing a-b, and sets condition codes accordingly CF (Carry Flag): Treat a and b as unsigned value, set CF if a-b generates a borrow out of the most significant bit (i.e., a < b). Effectively detecting overflow for unsigned ZF (Zero Flag): set if a == b (i.e., bit patterns are the same) cmpq 0xFF, 0x80 (assuming 8-bit word size here) 01 CF 0 ZF 0 SF 0 OF 19
74 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction cmpq b,a like computing a-b, and sets condition codes accordingly CF (Carry Flag): Treat a and b as unsigned value, set CF if a-b generates a borrow out of the most significant bit (i.e., a < b). Effectively detecting overflow for unsigned ZF (Zero Flag): set if a == b (i.e., bit patterns are the same) SF (Sign Flag): set if (a-b)<0 (i.e., most significant bit is 1) cmpq 0xFF, 0x80 (assuming 8-bit word size here) 01 CF 0 ZF 0 SF 0 OF 19
75 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction cmpq b,a like computing a-b, and sets condition codes accordingly CF (Carry Flag): Treat a and b as unsigned value, set CF if a-b generates a borrow out of the most significant bit (i.e., a < b). Effectively detecting overflow for unsigned ZF (Zero Flag): set if a == b (i.e., bit patterns are the same) SF (Sign Flag): set if (a-b)<0 (i.e., most significant bit is 1) cmpq 0xFF, 0x80 (assuming 8-bit word size here) CF ZF SF 0 OF 19
76 Explicit Set Condition Codes: Compare cmpq Src2, Src1 Explicit Setting by Compare Instruction cmpq b,a like computing a-b, and sets condition codes accordingly CF (Carry Flag): Treat a and b as unsigned value, set CF if a-b generates a borrow out of the most significant bit (i.e., a < b). Effectively detecting overflow for unsigned ZF (Zero Flag): set if a == b (i.e., bit patterns are the same) SF (Sign Flag): set if (a-b)<0 (i.e., most significant bit is 1) OF (Overflow Flag) set if a-b overflows (treat a and b as signed) (a>0 && b<0 && (a-b)<0) (a<0 && b>0 && (a-b)>0) cmpq 0xFF, 0x80 (assuming 8-bit word size here) CF ZF SF 0 OF 19
77 Explicit Set Condition Codes: Test testq Src2, Src1 Explicit Setting by Test Instruction test b,a like computing a&b, but instead of setting the result, it sets condition codes ZF (Zero Flag): set if a & b == 0 SF (Sign Flag): set if a & b < 0 OF and CF are always set to 0 20
78 Implicit Set Condition Codes addq Src, Dest 21
79 Implicit Set Condition Codes addq Src, Dest Condition Codes could also be implicitly set by arithmetic operations (think of it as side effect) 21
80 Implicit Set Condition Codes addq Src, Dest Condition Codes could also be implicitly set by arithmetic operations (think of it as side effect) Assume Src is a, Dest is b, addition result is t = a + b (after truncation) 21
81 Implicit Set Condition Codes addq Src, Dest Condition Codes could also be implicitly set by arithmetic operations (think of it as side effect) Assume Src is a, Dest is b, addition result is t = a + b (after truncation) CF set if carry out from most significant bit (unsigned overflow) 21
82 Implicit Set Condition Codes addq Src, Dest Condition Codes could also be implicitly set by arithmetic operations (think of it as side effect) Assume Src is a, Dest is b, addition result is t = a + b (after truncation) CF set if carry out from most significant bit (unsigned overflow) ZF set if t == 0 21
83 Implicit Set Condition Codes addq Src, Dest Condition Codes could also be implicitly set by arithmetic operations (think of it as side effect) Assume Src is a, Dest is b, addition result is t = a + b (after truncation) CF set if carry out from most significant bit (unsigned overflow) ZF set if t == 0 SF set if t < 0 (as signed, i.e., MSB is 1) 21
84 Implicit Set Condition Codes addq Src, Dest Condition Codes could also be implicitly set by arithmetic operations (think of it as side effect) Assume Src is a, Dest is b, addition result is t = a + b (after truncation) CF set if carry out from most significant bit (unsigned overflow) ZF set if t == 0 SF set if t < 0 (as signed, i.e., MSB is 1) OF set if signed overflow (a>0 && b>0 && t<0) (a<0 && b<0 && t>=0) 21
85 Today: Compute and Control Instructions Arithmetic & logical operations Control: Condition codes Conditional branches (if else ) Loops (for, while) Switch Statements (case switch ) 22
86 Conditional Branch Example 23
87 Conditional Branch Example long absdiff (long x, long y) { long result; if (x > y) result = x-y; else result = y-x; return result; } 23
88 Conditional Branch Example gcc Og -S fno-if-conversion control.c long absdiff (long x, long y) { long result; if (x > y) result = x-y; else result = y-x; return result; } absdiff: cmpq %rsi,%rdi # x:y jle.l4 movq %rdi,%rax subq %rsi,%rax ret.l4: # x <= y movq %rsi,%rax subq %rdi,%rax ret 23
89 Conditional Branch Example gcc Og -S fno-if-conversion control.c long absdiff (long x, long y) { long result; if (x > y) result = x-y; else result = y-x; return result; } Register %rdi %rsi %rax Use(s) x y Return value absdiff: cmpq %rsi,%rdi # x:y jle.l4 movq %rdi,%rax subq %rsi,%rax ret.l4: # x <= y movq %rsi,%rax subq %rdi,%rax ret 23
90 Conditional Branch Example gcc Og -S fno-if-conversion control.c long absdiff (long x, long y) { long result; if (x > y) result = x-y; else result = y-x; return result; } Register %rdi %rsi %rax Use(s) x y Return value absdiff: cmpq %rsi,%rdi # x:y jle.l4 movq %rdi,%rax subq %rsi,%rax ret.l4: # x <= y movq %rsi,%rax subq %rdi,%rax ret Labels are symbolic names used to refer to instruction addresses. 23
MACHINE LEVEL PROGRAMMING 1: BASICS
MACHINE LEVEL PROGRAMMING 1: BASICS CS 045 Computer Organization and Architecture Prof. Donald J. Patterson Adapted from Bryant and O Hallaron, Computer Systems: A Programmer s Perspective, Third Edition
CS201- Lecture 7 IA32 Data Access and Operations Part II
CS201- Lecture 7 IA32 Data Access and Operations Part II RAOUL RIVAS PORTLAND STATE UNIVERSITY Announcements 2 Address Computation Examples %rdx %rcx 0xf000 0x0100 movq 8(%rdx),%rax movq (%rdx,%rcx),%rax
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
Assembly 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
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
L08: Assembly Programming II. Assembly Programming II. CSE 351 Spring Guest Lecturer: Justin Hsia. Instructor: Ruth Anderson
Assembly Programming II CSE 351 Spring 2017 Guest Lecturer: Justin Hsia Instructor: Ruth Anderson Teaching Assistants: Dylan Johnson Kevin Bi Linxing Preston Jiang Cody Ohlsen Yufang Sun Joshua Curtis
x86 64 Programming I CSE 351 Autumn 2017 Instructor: Justin Hsia
x86 64 Programming I 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 Administrivia
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
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
x86-64 Programming II
x86-64 Programming II CSE 351 Winter 2018 Instructor: Mark Wyse Teaching Assistants: Kevin Bi Parker DeWilde Emily Furst Sarah House Waylon Huang Vinny Palaniappan http://xkcd.com/409/ Administrative Homework
L09: Assembly Programming III. Assembly Programming III. CSE 351 Spring Guest Lecturer: Justin Hsia. Instructor: Ruth Anderson
Assembly Programming III CSE 351 Spring 2017 Guest Lecturer: Justin Hsia Instructor: Ruth Anderson Teaching Assistants: Dylan Johnson Kevin Bi Linxing Preston Jiang Cody Ohlsen Yufang Sun Joshua Curtis
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
Foundations of Computer Systems
18-600 Foundations of Computer Systems Lecture 5: Data and Machine-Level Programming I: Basics September 13, 2017 Required Reading Assignment: Chapter 3 of CS:APP (3 rd edition) by Randy Bryant & Dave
x86 64 Programming II
x86 64 Programming II CSE 351 Autumn 2018 Instructor: Justin Hsia Teaching Assistants: Akshat Aggarwal An Wang Andrew Hu Brian Dai Britt Henderson James Shin Kevin Bi Kory Watson Riley Germundson Sophie
Carnegie Mellon. Bryant and O Hallaron, Computer Systems: A Programmer s Perspective, Third Edition
1 Machine-Level Programming II: Control 15-213: Introduction to Computer Systems 6 th Lecture, Sept. 13, 2018 2 Today Control: Condition codes Conditional branches Loops Switch Statements 3 Recall: ISA
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
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
Assembly Programming III
Assembly Programming III CSE 410 Winter 2017 Instructor: Justin Hsia Teaching Assistants: Kathryn Chan, Kevin Bi, Ryan Wong, Waylon Huang, Xinyu Sui Facebook Stories puts a Snapchat clone above the News
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
Machine Level Programming: Basics
Machine Level Programming: Basics Computer Systems Organization (Spring 2017) CSCI-UA 201, Section 2 Instructor: Joanna Klukowska Why do we look at machine code? understanding how the high-level programming
Chapter 3 Machine-Level Programming I: Basics. Bryant and O Hallaron, Computer Systems: A Programmer s Perspective, Third Edition
Chapter 3 Machine-Level Programming I: Basics 1 Machine Programming I: Basics History of Intel processors and architectures C, assembly, machine code Assembly Basics: Registers, operands, move Arithmetic
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
x86 64 Programming I CSE 351 Autumn 2018 Instructor: Justin Hsia
x86 64 Programming I CSE 351 Autumn 2018 Instructor: Justin Hsia Teaching Assistants: Akshat Aggarwal An Wang Andrew Hu Brian Dai Britt Henderson James Shin Kevin Bi Kory Watson Riley Germundson Sophie
Machine-Level Programming I: Basics
Machine-Level Programming I: Basics CSE 238/2038/2138: Systems Programming Instructor: Fatma CORUT ERGİN Slides adapted from Bryant & O Hallaron s slides 1 Today: Machine Programming I: Basics History
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
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)
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
x86 Programming I CSE 351 Autumn 2016 Instructor: Justin Hsia
x86 Programming I CSE 351 Autumn 2016 Instructor: Justin Hsia Teaching Assistants: Chris Ma Hunter Zahn John Kaltenbach Kevin Bi Sachin Mehta Suraj Bhat Thomas Neuman Waylon Huang Xi Liu Yufang Sun http://xkcd.com/409/
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
Machine-Level Programming II: Control
Machine-Level Programming II: Control 15-213: Introduction to Computer Systems 6 th Lecture, Feb. 2, 2017 Instructors: Franz Franchetti and Seth C. Goldstein 1 Office Hours Thanks for Coming! and sorry
Roadmap. Java: Assembly language: OS: Machine code: Computer system:
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 ret %rbp %rsp, %rbp
Roadmap. Java: Assembly language: OS: Machine code: Computer system:
Roadmap C: car *c = malloc(sizeof(car)); c->miles = 100; c->gals = 17; float mpg = get_mpg(c); free(c); Assembly language: Machine code: get_mpg: pushq movq... popq ret %rbp %rsp, %rbp %rbp 0111010000011000
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
Bryant and O Hallaron, Computer Systems: A Programmer s Perspective, Third Edition. Carnegie Mellon
Carnegie Mellon Machine-Level Programming I: Basics 15-213/18-213/15-213: Introduction to Computer Systems 5 th Lecture, September 12, 2017 Today s Instructor: Phil Gibbons 2 Today: Machine Programming
CSC 252: Computer Organization Spring 2018: Lecture 5
CSC 252: Computer Organization Spring 2018: Lecture 5 Instructor: Yuhao Zhu Department of Computer Science University of Rochester Action Items: Assignment 1 is due tomorrow, midnight Assignment 2 is out
CS429: Computer Organization and Architecture
CS429: Computer Organization and Architecture Dr. Bill Young Department of Computer Sciences University of Texas at Austin Last updated: October 9, 2017 at 10:51 CS429 Slideset 7: 1 Topics of this Slideset
Machine-Level Programming I: Basics
Machine-Level Programming I: Basics 15-213/18-213: Introduction to Computer Systems 5 th Lecture, September 13, 2016 Instructor: Phil Gibbons 1 Today: Machine Programming I: Basics History of Intel processors
Control flow (1) Condition codes Conditional and unconditional jumps Loops Conditional moves Switch statements
Control flow (1) Condition codes Conditional and unconditional jumps Loops Conditional moves Switch statements 1 Conditionals and Control Flow Two key pieces 1. Comparisons and tests: check conditions
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
Machine- Level Programming II: Arithme6c & Control
Machine- Level Programming II: Arithme6c & Control 15-213: Introduc0on to Computer Systems 5 th Lecture, Sep. 7, 2010 Instructors: Randy Bryant and Dave O Hallaron Modified by Karen L. Karavanic 2015 1
CS367. Program Control
CS367 Program Control outline program control condition codes branching looping conditional moves switches (special case of branching) Condition Codes Processor State (x86-64, Partial) Info about currently
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
2/12/2016. Today. Machine-Level Programming II: Control. Condition Codes (Implicit Setting) Processor State (x86-64, Partial)
Today Machine-Level Programming II: Control CSci 2021: Machine Architecture and Organization Lectures #9-11, February 8th-12th, 2016 Control: Condition codes Conditional branches Loops Switch Statements
Machine-Level Programming I: Basics
Machine-Level Programming I: Basics 15-213/18-213: Introduction to Computer Systems 5 th Lecture, January 30, 2018 Instructors: Franz Franchetti and Seth C. Goldstein 1 Office Hours Not too well attended
Topics of this Slideset. CS429: Computer Organization and Architecture. x86 Evolution: Programmer s View. Intel x86 Processors
Topics of this Slideset CS429: Computer Organization and Architecture Dr. Bill Young Department of Computer Science University of Texas at Austin Last updated: October 29, 2018 at 11:54 Assembly Programmer
The Hardware/Software Interface CSE351 Spring 2013
The Hardware/Software Interface CSE351 Spring 2013 x86 Programming II 2 Today s Topics: control flow Condition codes Conditional and unconditional branches Loops 3 Conditionals and Control Flow A conditional
cmovxx ra, rb 2 fn ra rb irmovq V, rb 3 0 F rb V rmmovq ra, D(rB) 4 0 ra rb mrmovq D(rB), ra 5 0 ra rb OPq ra, rb 6 fn ra rb jxx Dest 7 fn Dest
Instruction Set Architecture Computer Architecture: Instruction Set Architecture CSci 2021: Machine Architecture and Organization Lecture #16, February 24th, 2016 Your instructor: Stephen McCamant Based
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
Machine-Level Programming II: Arithmetic & Control /18-243: Introduction to Computer Systems 6th Lecture, 5 June 2012
n Mello Machine-Level Programming II: Arithmetic & Control 15-213/18-243: Introduction to Computer Systems 6th Lecture, 5 June 2012 Instructors: Gregory Kesden The course that gives CMU its Zip! Last Time:
Credits to Randy Bryant & Dave O Hallaron
Mellon Machine Level Programming II: Arithmetic & Control Lecture 4, March 10, 2011 Alexandre David Credits to Randy Bryant & Dave O Hallaron from Carnegie Mellon 1 Today Complete addressing mode, address
Outline. Review: Assembly/Machine Code View. Processor State (x86-64, Par2al) Condi2on Codes (Explicit Se^ng: Compare) Condi2on Codes (Implicit Se^ng)
Outline Machine- Level Representa2on: Control CSCI 2021: Machine Architecture and Organiza2on Pen- Chung Yew Department Computer Science and Engineering University of Minnesota Control: Condi2on codes
CSC 252: Computer Organization Spring 2018: Lecture 11
CSC 252: Computer Organization Spring 2018: Lecture 11 Instructor: Yuhao Zhu Department of Computer Science University of Rochester Action Items: Assignment 3 is due March 2, midnight Announcement Programming
Machine-Level Programming II: Control and Arithmetic
Machine-Level Programming II: Control and Arithmetic CSCI 2400: Computer Architecture Instructor: David Ferry Slides adapted from Bryant & O Hallaron s slides 1 Today Complete addressing mode, address
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 Programming
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.
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
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
Today: Machine Programming I: Basics. Machine-Level Programming I: Basics. Intel x86 Processors. Intel x86 Evolution: Milestones
Today: Machine Programming I: Basics Machine-Level Programming I: Basics CSci 2021: Machine Architecture and Organization Lectures #7-8, February 3th-5th, 2016 Assembly Basics:, operands, move Arithmetic
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
CS 33. Machine Programming (2) CS33 Intro to Computer Systems XII 1 Copyright 2017 Thomas W. Doeppner. All rights reserved.
CS 33 Machine Programming (2) CS33 Intro to Computer Systems XII 1 Copyright 2017 Thomas W. Doeppner. All rights reserved. Processor State (x86-64, Partial) %rax %eax %r8 %r8d %rbx %ebx %r9 %r9d %rcx %ecx
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
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:
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
Machine-Level Programming II: Arithmetic & Control. Complete Memory Addressing Modes
Machine-Level Programming II: Arithmetic & Control CS-281: Introduction to Computer Systems Instructor: Thomas C. Bressoud 1 Complete Memory Addressing Modes Most General Form D(Rb,Ri,S)Mem[Reg[Rb]+S*Reg[Ri]+
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
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
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 Programming
Bryant 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
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
x86 Programming III CSE 351 Autumn 2016 Instructor: Justin Hsia
x86 Programming III CSE 351 Autumn 2016 Instructor: Justin Hsia Teaching Assistants: Chris Ma Hunter Zahn John Kaltenbach Kevin Bi Sachin Mehta Suraj Bhat Thomas Neuman Waylon Huang Xi Liu Yufang Sun http://xkcd.com/648/
Question 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,
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++;
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
+ Machine Level Programming: x86-64 History
+ Machine Level Programming: x86-64 History + Intel x86 Processors Dominate laptop/desktop/server market Evolutionary design Backwards compatible up until 8086, introduced in 1978 Added more features as
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
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
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
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,
Computer Architecture I: Outline and Instruction Set Architecture. CENG331 - Computer Organization. Murat Manguoglu
Computer Architecture I: Outline and Instruction Set Architecture CENG331 - Computer Organization Murat Manguoglu Adapted from slides of the textbook: http://csapp.cs.cmu.edu/ Outline Background Instruction
CSE 401 Compilers. x86-64 Lite for Compiler Writers A quick (a) introduccon or (b) review. Hal Perkins Winter UW CSE 401 Winter 2017 J-1
CSE 401 Compilers x86-64 Lite for Compiler Writers A quick (a) introduccon or (b) review [pick one] Hal Perkins Winter 2017 UW CSE 401 Winter 2017 J-1 Agenda Overview of x86-64 architecture Core part only,
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
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
CS 261 Fall Mike Lam, Professor. x86-64 Control Flow
CS 261 Fall 2018 Mike Lam, Professor x86-64 Control Flow Topics Condition codes Jumps Conditional moves Jump tables Motivation We cannot translate the following C function to assembly, using only data
Machine Level Programming I: Basics
Carnegie Mellon Machine Level Programming I: Basics Kai Shen Why do I care for machine code? Chances are, you ll never write programs in machine code Compilers are much better & more patient than you are
x86-64 Programming I CSE 351 Summer 2018 Instructor: Justin Hsia Teaching Assistants: Josie Lee Natalie Andreeva Teagan Horkan
x86-64 Programming I CSE 351 Summer 2018 Instructor: Justin Hsia Teaching Assistants: Josie Lee Natalie Andreeva Teagan Horkan http://www.smbc-comics.com/?id=2999 Administrivia Lab 1b due on Thursday (7/5)
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()
CSC 252: Computer Organization Spring 2018: Lecture 14
CSC 252: Computer Organization Spring 2018: Lecture 14 Instructor: Yuhao Zhu Department of Computer Science University of Rochester Action Items: Mid-term: March 8 (Thursday) Announcements Mid-term exam:
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,
Review addressing modes
Review addressing modes Op Src Dst Comments movl $0, %rax Register movl $0, 0x605428 Direct address movl $0, (%rcx) Indirect address movl $0, 20(%rsp) Indirect with displacement movl $0, -8(%rdi, %rax,
CS 33. Machine Programming (2) CS33 Intro to Computer Systems XI 1 Copyright 2018 Thomas W. Doeppner. All rights reserved.
CS 33 Machine Programming (2) CS33 Intro to Computer Systems XI 1 Copyright 2018 Thomas W. Doeppner. All rights reserved. Observations about arith int arith(int x, int y, int z) { int t1 = x+y; int t2
CS429: 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
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
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*
Basic 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
last time Assembly part 2 / C part 1 condition codes reminder: quiz
last time Assembly part 2 / C part 1 linking extras: different kinds of relocations addresses versus offset to addresses dynamic linking (briefly) AT&T syntax destination last O(B, I, S) B + I S + O jmp
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
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
%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
Topics 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
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)