Alan L. Cox alc@riceAlan L. Cox [email protected] Some slides adapted from CMU 15.213 slides Cox Assembly...
Transcript of Alan L. Cox alc@riceAlan L. Cox [email protected] Some slides adapted from CMU 15.213 slides Cox Assembly...
![Page 2: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/2.jpg)
Cox Assembly 2
Objectives
Be able to read simple x86-64 assembly language programs
![Page 3: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/3.jpg)
Cox Assembly 3
Why Learn Assembly Language?
You’ll probably never write a program in assembly Compilers are much better and more patient than
you are
But, understanding assembly is key to understanding the machine-level execution model Behavior of programs in presence of bugs
• High-level language model breaks down
Tuning program performance• Understanding sources of program inefficiency
Implementing system software• Compiler has machine code as target
• Operating systems must manage process state
![Page 4: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/4.jpg)
Cox Assembly 4
Assembly Language
One assembly instruction
Straightforward translation to a group of machine language bits that describe one instruction
What do these instructions do?
Same kinds of things as high-level languages!
• Arithmetic & logic
– Core computation
• Data transfer
– Copying data between memory locations and/or registers
• Control transfer
– Changing which instruction is next
![Page 5: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/5.jpg)
Cox Assembly 5
Assembly Language (cont.)
But, assembly language has additional features:
Distinguishes instructions & data
Labels = names for program control points
Pseudo-instructions = special directives to the assembler
Macros = user-definable abbreviations for code & constants
![Page 6: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/6.jpg)
Cox Assembly 6
Example C Program
#include <stdio.h>
void
hello(char *name, int hour, int min)
{
printf("Hello, %s, it's %d:%02d.",
name, hour, min);
}
int
main(void)
{
hello(“Alan", 2, 55);return (0);
}
UNIX% clang -S main.c
main.c:
Run the command:
Output a file named main.s
containing the assembly
code for main.c
![Page 7: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/7.jpg)
Cox Assembly 7
C Compiler’s Output
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
.section .rodata
.LC1:
.string "Alan"
.text
.globl main
.type main, @function
main:
.LFB3:
pushq %rbp
.LCFI3:
movq %rsp, %rbp
.LCFI4:
movl $55, %edx
movl $2, %esi
movl $.LC1, %edi
call hello
movl $0, %eax
<..snip..>
![Page 8: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/8.jpg)
Cox Assembly 8
A Breakdown of the Output
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
<..snip..>
Instructions,Pseudo-Instructions,& Label Definitions
![Page 9: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/9.jpg)
Cox Assembly 9
Instructions: Opcodes
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
<..snip..>
Arithmetic,data transfer, &control transfer
![Page 10: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/10.jpg)
Cox Assembly 10
Instructions: Operands
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
<..snip..>
Registers,constants, &labels
![Page 11: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/11.jpg)
Cox Assembly 11
Instruction Set Architecture
Contract between programmer and the hardware
Defines visible state of the system
Defines how state changes in response to instructions
Assembly Programmer (compiler)
ISA is model of how a program will execute
Hardware Designer
ISA is formal definition of the correct way to execute a program
![Page 12: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/12.jpg)
Cox Assembly 12
Architecture vs. Implementation
Instruction Set Architecture
Defines what a computer system does in response to a program and a set of data
Programmer visible elements of computer system
Implementation
Defines how a computer does it
Sequence of steps to complete operations
Time to execute each operation
Hidden “bookkeeping” functions
![Page 13: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/13.jpg)
Cox Assembly 13
Often Many Implementations of an ISA
ISA Implementations
x86-64
Intel Core i7
AMD FX-83XX
VIA Nano
ARMv7-AApple A6/A6X
Qualcomm Krait
![Page 14: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/14.jpg)
Cox Assembly 14
Why separate architecture and implementation?
Compatibility
VAX architecture: mainframe single chip
ARM: 20x performance range
• high vs. low performance, power, price
Longevity
20-30 years of ISA
x86/x86-64 in 10th generation of implementations (architecture families)
Retain software investment
Amortize development costs over multiple markets
![Page 15: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/15.jpg)
Cox Assembly 15
Instruction Set Basics
Op Mode Ra Rb
Mem
Regs
Before State
Mem
Regs
After State
instructionInstruction formatsInstruction typesAddressing modes
Data typesOperations
Machine stateMemory organizationRegister organization
PC PC
![Page 16: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/16.jpg)
Cox Assembly 16
Typical Machine State
Memory
General-PurposeRegisters
Special-PurposeRegisters
ALU,FPU,…
CPU
![Page 17: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/17.jpg)
Integer Registers (IA32)
%eax
%ecx
%edx
%ebx
%esi
%edi
%esp
%ebp
%ax
%cx
%dx
%bx
%si
%di
%sp
%bp
%ah
%ch
%dh
%bh
%al
%cl
%dl
%bl
16-bit virtual registers(backwards compatibility)
gen
era
l pu
rpo
se
accumulate
counter
data
base
source
index
destination
index
stack
pointer
base
pointer
Origin(mostly obsolete)
Cox Assembly 17
![Page 18: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/18.jpg)
Moving Data: IA32
Moving Datamovl Source, Dest:
Operand Types
Immediate: Constant integer data
• Example: $0x400, $-533
• Like C constant, but prefixed with ‘$’
• Encoded with 1, 2, or 4 bytes
Register: One of 8 integer registers
• Example: %eax, %edx
• But %esp and %ebp reserved for special use
• Others have special uses for particular instructions
Memory: 4 consecutive bytes of memory at address given by register
• Simplest example: (%eax)
• Various other “address modes”
%eax
%ecx
%edx
%ebx
%esi
%edi
%esp
%ebp
Cox Assembly 18
![Page 19: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/19.jpg)
movl Operand Combinations
Cannot do memory-memory transfer with a single instruction
movl
Imm
Reg
Mem
Reg
Mem
Reg
Mem
Reg
Source Dest C Analog
movl $0x4,%eax temp = 0x4;
movl $-147,(%eax) *p = -147;
movl %eax,%edx temp2 = temp1;
movl %eax,(%edx) *p = temp;
movl (%eax),%edx temp = *p;
Src,Dest
Cox Assembly 19
![Page 20: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/20.jpg)
Simple Memory Addressing Modes
Normal (R) Mem[Reg[R]]
Register R specifies memory address
movl (%ecx),%eax
Displacement D(R) Mem[Reg[R]+D]
Register R specifies start of memory region
Constant displacement D specifies offset
movl 8(%ebp),%edx
Cox Assembly 20
![Page 21: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/21.jpg)
Using Simple Addressing Modes
void
swap(int *xp, int *yp)
{
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp = t0;
}
Body
SetUp
Finish
swap:
pushl %ebp
movl %esp, %ebp
pushl %ebx
movl 8(%ebp), %edx
movl 12(%ebp), %ecx
movl (%edx), %ebx
movl (%ecx), %eax
movl %eax, (%edx)
movl %ebx, (%ecx)
popl %ebx
popl %ebp
ret
Cox Assembly 21
![Page 22: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/22.jpg)
Using Simple Addressing Modes
void
swap(int *xp, int *yp)
{
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp = t0;
}
swap:
pushl %ebp
movl %esp, %ebp
pushl %ebx
movl 8(%ebp), %edx
movl 12(%ebp), %ecx
movl (%edx), %ebx
movl (%ecx), %eax
movl %eax, (%edx)
movl %ebx, (%ecx)
popl %ebx
popl %ebp
ret
Body
SetUp
Finish
Cox Assembly 22
![Page 23: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/23.jpg)
Understanding Swap
void
swap(int *xp, int *yp)
{
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp = t0;
}
Stack(in memory)
Register Value
%edx xp
%ecx yp
%ebx t0
%eax t1
yp
xp
Rtn adr
Old %ebp %ebp0
4
8
12
Offset
•••
Old %ebx-4 %esp
movl 8(%ebp), %edx # edx = xp
movl 12(%ebp), %ecx # ecx = yp
movl (%edx), %ebx # ebx = *xp (t0)
movl (%ecx), %eax # eax = *yp (t1)
movl %eax, (%edx) # *xp = t1
movl %ebx, (%ecx) # *yp = t0
Cox Assembly 23
![Page 24: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/24.jpg)
Understanding Swap
0x120
0x124
Rtn adr
%ebp 0
4
8
12
Offset
-4
123
456
Address0x124
0x120
0x11c
0x118
0x114
0x110
0x10c
0x108
0x104
0x100
yp
xp
%eax
%edx
%ecx
%ebx
%esi
%edi
%esp
%ebp 0x104movl 8(%ebp), %edx # edx = xp
movl 12(%ebp), %ecx # ecx = yp
movl (%edx), %ebx # ebx = *xp (t0)
movl (%ecx), %eax # eax = *yp (t1)
movl %eax, (%edx) # *xp = t1
movl %ebx, (%ecx) # *yp = t0
Cox Assembly 24
![Page 25: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/25.jpg)
Understanding Swap
0x120
0x124
Rtn adr
%ebp 0
4
8
12
Offset
-4
123
456
Address0x124
0x120
0x11c
0x118
0x114
0x110
0x10c
0x108
0x104
0x100
yp
xp
%eax
%edx
%ecx
%ebx
%esi
%edi
%esp
%ebp
0x124
0x104
0x120
movl 8(%ebp), %edx # edx = xp
movl 12(%ebp), %ecx # ecx = yp
movl (%edx), %ebx # ebx = *xp (t0)
movl (%ecx), %eax # eax = *yp (t1)
movl %eax, (%edx) # *xp = t1
movl %ebx, (%ecx) # *yp = t0
Cox Assembly 25
![Page 26: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/26.jpg)
Understanding Swap
0x120
0x124
Rtn adr
%ebp 0
4
8
12
Offset
-4
123
456
Address0x124
0x120
0x11c
0x118
0x114
0x110
0x10c
0x108
0x104
0x100
yp
xp
%eax
%edx
%ecx
%ebx
%esi
%edi
%esp
%ebp
0x120
0x104
0x124
0x124
movl 8(%ebp), %edx # edx = xp
movl 12(%ebp), %ecx # ecx = yp
movl (%edx), %ebx # ebx = *xp (t0)
movl (%ecx), %eax # eax = *yp (t1)
movl %eax, (%edx) # *xp = t1
movl %ebx, (%ecx) # *yp = t0
Cox Assembly 26
![Page 27: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/27.jpg)
456
Understanding Swap
0x120
0x124
Rtn adr
%ebp 0
4
8
12
Offset
-4
123
456
Address0x124
0x120
0x11c
0x118
0x114
0x110
0x10c
0x108
0x104
0x100
yp
xp
%eax
%edx
%ecx
%ebx
%esi
%edi
%esp
%ebp
0x124
0x120
123
0x104movl 8(%ebp), %edx # edx = xp
movl 12(%ebp), %ecx # ecx = yp
movl (%edx), %ebx # ebx = *xp (t0)
movl (%ecx), %eax # eax = *yp (t1)
movl %eax, (%edx) # *xp = t1
movl %ebx, (%ecx) # *yp = t0
Cox Assembly 27
![Page 28: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/28.jpg)
Understanding Swap
0x120
0x124
Rtn adr
%ebp 0
4
8
12
Offset
-4
123
456
Address0x124
0x120
0x11c
0x118
0x114
0x110
0x10c
0x108
0x104
0x100
yp
xp
%eax
%edx
%ecx
%ebx
%esi
%edi
%esp
%ebp
456
0x124
0x120
0x104
123
123
movl 8(%ebp), %edx # edx = xp
movl 12(%ebp), %ecx # ecx = yp
movl (%edx), %ebx # ebx = *xp (t0)
movl (%ecx), %eax # eax = *yp (t1)
movl %eax, (%edx) # *xp = t1
movl %ebx, (%ecx) # *yp = t0
Cox Assembly 28
![Page 29: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/29.jpg)
456
456
Understanding Swap
0x120
0x124
Rtn adr
%ebp 0
4
8
12
Offset
-4
Address0x124
0x120
0x11c
0x118
0x114
0x110
0x10c
0x108
0x104
0x100
yp
xp
%eax
%edx
%ecx
%ebx
%esi
%edi
%esp
%ebp
456456
0x124
0x120
123
0x104
123
movl 8(%ebp), %edx # edx = xp
movl 12(%ebp), %ecx # ecx = yp
movl (%edx), %ebx # ebx = *xp (t0)
movl (%ecx), %eax # eax = *yp (t1)
movl %eax, (%edx) # *xp = t1
movl %ebx, (%ecx) # *yp = t0
Cox Assembly 29
![Page 30: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/30.jpg)
Understanding Swap
0x120
0x124
Rtn adr
%ebp 0
4
8
12
Offset
-4
456
123
Address0x124
0x120
0x11c
0x118
0x114
0x110
0x10c
0x108
0x104
0x100
yp
xp
%eax
%edx
%ecx
%ebx
%esi
%edi
%esp
%ebp
456
0x124
0x120
0x104
123123
movl 8(%ebp), %edx # edx = xp
movl 12(%ebp), %ecx # ecx = yp
movl (%edx), %ebx # ebx = *xp (t0)
movl (%ecx), %eax # eax = *yp (t1)
movl %eax, (%edx) # *xp = t1
movl %ebx, (%ecx) # *yp = t0
Cox Assembly 30
![Page 31: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/31.jpg)
Complete Memory Addressing Modes
Most General Form
D(Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]+D]
D: Constant “displacement” 1, 2, or 4 bytes
Rb: Base register: Any of 8 integer registers
Ri: Index register: Any, except for %esp
•Unlikely you’d use %ebp, either
S: Scale: 1, 2, 4, or 8 (why these numbers?)
Special Cases
(Rb,Ri) Mem[Reg[Rb]+Reg[Ri]]
D(Rb,Ri) Mem[Reg[Rb]+Reg[Ri]+D]
(Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]]
Cox Assembly 31
![Page 32: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/32.jpg)
%rsp
x86-64 Integer Registers
Extend existing registers. Add 8 new ones.
Make %ebp/%rbp general purpose
%eax
%ebx
%ecx
%edx
%esi
%edi
%esp
%ebp
%r8d
%r9d
%r10d
%r11d
%r12d
%r13d
%r14d
%r15d
%r8
%r9
%r10
%r11
%r12
%r13
%r14
%r15
%rax
%rbx
%rcx
%rdx
%rsi
%rdi
%rbp
Cox 32Assembly
![Page 33: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/33.jpg)
Instructions
Long word l (4 Bytes) ↔ Quad word q (8
Bytes)
New instructions: movl ➙ movq
addl ➙ addq
sall ➙ salq
etc.
32-bit instructions that generate 32-bit results
Set higher order bits of destination register to 0
Example: addl
Cox Assembly 33
![Page 34: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/34.jpg)
32-bit code for swap
void
swap(int *xp, int *yp)
{
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp = t0;
}
Body
SetUp
Finish
swap:
pushl %ebp
movl %esp,%ebp
pushl %ebx
movl 8(%ebp), %edx
movl 12(%ebp), %ecx
movl (%edx), %ebx
movl (%ecx), %eax
movl %eax, (%edx)
movl %ebx, (%ecx)
popl %ebx
popl %ebp
ret
Cox Assembly 34
![Page 35: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/35.jpg)
64-bit code for swap
Operands passed in registers (why useful?) First (xp) in %rdi, second (yp) in %rsi
64-bit pointers
No stack operations required
32-bit data Data held in registers %eax and %edx
movl operation
void
swap(int *xp, int *yp)
{
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp = t0;
}
Body
SetUp
Finish
swap:
movl (%rdi), %edx
movl (%rsi), %eax
movl %eax, (%rdi)
movl %edx, (%rsi)
ret
Assembly 35Cox
![Page 36: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/36.jpg)
64-bit code for long int swap
64-bit data Data held in registers %rax and %rdx
movq operation
• “q” stands for quad-word
void
swap_l(long *xp, long *yp)
{
long t0 = *xp;
long t1 = *yp;
*xp = t1;
*yp = t0;
}
Body
SetUp
Finish
swap_l:
movq (%rdi), %rdx
movq (%rsi), %rax
movq %rax, (%rdi)
movq %rdx, (%rsi)
ret
Cox Assembly 36
![Page 37: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/37.jpg)
Cox Assembly 37
Application Binary Interface (ABI)
Standardizes the use of memory and registers by C compilers
Enables interoperability of code compiled by different C compilers
• E.g., a program compiled with Intel’s optimizing C
compiler can call a library function that was compiled by the GNU C compiler
Sets the size of built-in data types
• E.g., int, long, etc.
Dictates the implementation of function calls
• E.g., how parameters and return values are passed
![Page 38: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/38.jpg)
Cox Assembly 38
Register Usage
The x86-64 ABI specifies that registers are used as follows
Temporary (callee can change these)
%rax, %r10, %r11
Parameters to function calls
%rdi, %rsi, %rdx, %rcx, %r8, %r9
Callee saves (callee can only change these after saving their current value)
%rbx, %rbp, %r12-%r15
– %rbp is typically used as the “frame” pointer to the current function’s local variables
Return values
%rax, %rdx
![Page 39: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/39.jpg)
Cox Assembly 39
Procedure Calls and the Stack
Where are local variables stored?
Registers (only 16)
Stack
Stack provides as much local storage as necessary
Until memory exhausted
Each procedure allocates its own space on the stack
Referencing the stack
%rsp points to the bottom
of the stack in x86-64
Shared Libraries
Heap
Read/Write Data
Read-only Code and Data
Unused
0x7FFFFFFFFFFF
0x000000000000
%rsp
Unused
Stack
![Page 40: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/40.jpg)
Cox Assembly 40
Control Flow: Function Calls
What must assembly/machine language do?
Caller Callee
1. Save function arguments
2. Branch to function body
3. Execute body
• May allocate memory
• May call functions
4. Save function result
5. Branch to where called
1. Use registers %rdi, %rsi, etc., then stack2. Use call (jump to procedure, save return location on stack)3. Use sub %rsp to create new stack frame4. Use %rax5. Use ret
![Page 41: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/41.jpg)
Cox Assembly 41
Program Stack
Figure 3.3 is reproduced from the AMD64 ABI Draft 0.99.5 by Matz et al.
![Page 42: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/42.jpg)
Cox Assembly 42
What are Pseudo-Instructions?
Assembler directives, with various purposes
Data & instruction encoding:
Separate instructions & data into sections
Reserve memory with initial data values
Reserve memory w/o initial data values
Align instructions & data
Provide information useful to linker or debugger
Correlate source code with assembly/machine
…
![Page 43: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/43.jpg)
Cox Assembly 43
Instructions & Pseudo-Instructions
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
<..snip..>
Instructions,Pseudo-Instructions,& Label Definitions
Separate instructions & data
![Page 44: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/44.jpg)
Cox Assembly 44
Instructions & Pseudo-Instructions
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
<..snip..>
Instructions,Pseudo-Instructions,& Label Definitions
Reserve memory with
initial data values
![Page 45: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/45.jpg)
Cox Assembly 45
Instructions & Pseudo-Instructions
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
<..snip..>
Instructions,Pseudo-Instructions,& Label Definitions
Correlate source code with
assembly/machine
![Page 46: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/46.jpg)
Cox Assembly 46
Label Types
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
<..snip..>
Definitions,internal references,& external references
The label’s value is the
address of the subsequent
instruction or pseudo-
instruction
![Page 47: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/47.jpg)
Cox Assembly 47
Assembly/Machine Language –Semantics
Basic model of execution
Fetch instruction, from memory @ PC
Increment PC
Decode instruction
Fetch operands, from registers or memory
Execute operation
Store result(s), in registers or memory
![Page 48: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/48.jpg)
Cox Assembly 48
Simulate Program Execution
.file "main.c"
.section .rodata
.LC0:
.string "Hello, %s, it's %d:%02d."
.text
.globl hello
.type hello, @function
hello:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
subq $16, %rsp
.LCFI2:
movq %rdi, -8(%rbp)
movl %esi, -12(%rbp)
movl %edx, -16(%rbp)
movl -16(%rbp), %ecx
movl -12(%rbp), %edx
movq -8(%rbp), %rsi
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size hello, .-hello
.section .rodata
.LC1:
.string "Alan"
.text
.globl main
.type main, @function
main:
.LFB3:
pushq %rbp
.LCFI3:
movq %rsp, %rbp
.LCFI4:
movl $55, %edx
movl $2, %esi
movl $.LC1, %edi
call hello
movl $0, %eax
<..next slide..>
![Page 49: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/49.jpg)
Cox Assembly 49
Simulate Program … (cont.)
movl $0, %eax
leave
ret
.LFE3:
.size main, .-main
<..snip..>
![Page 50: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/50.jpg)
Exercise
Cox Assembly 50
`
`
0x7000000000880x7000000000840x7000000000800x70000000007c0x7000000000780x7000000000740x7000000000700x70000000006c0x7000000000680x7000000000640x7000000000600x70000000005c0x7000000000580x7000000000540x7000000000500x70000000004c
0x7000000000480x7000000000440x7000000000400x70000000003c0x7000000000380x7000000000340x7000000000300x70000000002c0x7000000000280x7000000000240x7000000000200x70000000001c0x7000000000180x7000000000140x700000000010
0x70000000000c0x7000000000080x7000000000040x700000000000
%rbp
%rsp
%rdi
%rsi%esi
%edi
initial values:%rbp
%rsp
0x700000000088
0x70000000006c
%eax
%ecx
%edx
%rax
%rcx
%rdx
.LC0 0x408280
0x408400.LC1
&”movl $0, %eax” in main() == 0x400220
![Page 51: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/51.jpg)
Cox Assembly 51
More x86-64 Assembly
Chapter 3 of the textbook explains x86 and x86-64 assembly in greater detail
More examples translated from C
More detail than you’re expected to know for this course
Some code sequences generated by the compiler can still be confusing
Usually not important for this class (web is helpful if you are still curious)
![Page 52: Alan L. Cox alc@riceAlan L. Cox alc@rice.edu Some slides adapted from CMU 15.213 slides Cox Assembly 2 Objectives Be able to read simple x86-64 assembly language programs Cox Assembly](https://reader034.fdocuments.in/reader034/viewer/2022042214/5eb961b9cada941255243b4a/html5/thumbnails/52.jpg)
Cox Assembly 52
Next Time
Program Linking