Machine-Level Programming I: Basics 15-213/18-213 : Introduction to Computer

January 30, 2018
Instructors:
Franz Franchetti and Seth C. Goldstein

it was last year…
You can choose from coffee, tea, and

https://users.ece.cmu.edu/~franzf/officelocation.htm

Basics: Registers, operands, move
Arithmetic & logical operations
C, assembly, machine code

introduced in 1978
Added more features as time goes on
Now 3

PC & DOS
1MB address space
386 1985 275K 16-33
First 32 bit Intel processor ,

i7 Skylake 2015 1.9B
Added Features
Instructions to support multimedia operations
Instructions to enable more

nm
1st Pentium 4 2000 180 nm
1st Core 2 Duo 2006 65 nm
Recent Generations
Nehalem 2008

Process technology

Process technology dimension = width of narrowest wires
(10 nm ≈ 100 atoms wide)

Core i7
2.6-2.9 GHz
45 W

Desktop Model: Core i7
Integrated graphics
2.8-4.0 GHz
35-91 W

Server

Intel
A little bit slower, a lot cheaper
Then
Recruited top circuit designers

IA64
Totally different architecture (Itanium)
Executes IA32 code only as legacy
Performance disappointing
2003:

hello.c
shark> gcc –m64 hello.c

Presentation
Book covers x86-64
Web aside on IA32
We will

Basics: Registers, operands, move
Arithmetic & logical operations
C, assembly, machine code

…
Nice clean layers, but beware…
Of course, you know that:

processor design that one needs to understand for writing assembly/machine

(x86-64)
Register file
Heavily used program data
Condition codes
Store status information about most

PC

Registers

Memory

Code
Data
Stack

Addresses

Data

Instructions

Condition
Codes

Memory
Byte addressable array
Code and user data
Stack to support procedures

8 bytes
Data values
Addresses (untyped pointers)

Floating point data of 4, 8,

& 2 bytes)
Not part of memory (or cache)
%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

obsolete)

memory into register
Store register data into memory

Perform arithmetic function on

$-533
Like C constant, but prefixed with ‘$’
Encoded with 1, 2,

Warning: Intel docs use mov Dest, Source

Analog
movq $0x4,%rax
temp = 0x4;
movq $-147,(%rax)
*p = -147;
movq %rax,%rdx
temp2 = temp1;
movq

*p = temp;

movq (%rax),%rdx

temp = *p;

Src,Dest

in C movq (%rcx),%rax

Displacement D(R) Mem[Reg[R]+D]
Register R specifies start of memory region
Constant displacement

movq (%rsi), %rdx
movq %rdx, (%rdi)

void
whatAmI( a, b)
{
????
}

*yp)
{
long t0 = *xp;
long t1 = *yp;

swap:
movq (%rdi), %rax
movq (%rsi), %rdx
movq %rdx, (%rdi)
movq %rax, (%rsi)
ret

t0 = *xp;
long t1 = *yp;
*xp = t1;

Memory

Register Value
%rdi xp
%rsi yp
%rax t0
%rdx t1

swap:
movq (%rdi), %rax # t0 = *xp
movq (%rsi), %rdx # t1 = *yp
movq %rdx, (%rdi) # *xp = t1
movq %rax, (%rsi) # *yp = t0
ret

Registers

*xp
movq (%rsi), %rdx # t1 =

*xp
movq (%rsi), %rdx # t1 =

*xp
movq (%rsi), %rdx # t1 =

*xp
movq (%rsi), %rdx # t1 =

*xp
movq (%rsi), %rdx # t1 =

in C movq (%rcx),%rax

Displacement D(R) Mem[Reg[R]+D]
Register R specifies start of memory region
Constant displacement

2, or 4 bytes
Rb: Base register: Any of 16 integer

Basics: Registers, operands, move
Arithmetic & logical operations
C, assembly, machine code

to address denoted by expression
Uses
Computing addresses without a memory reference
E.g.,

long m12(long x)
{
return x*12;
}

leaq (%rdi,%rdi,2), %rax # t = x+2*x
salq $2, %rax # return t<<2

Converted to ASM by compiler:

Dest  Src
imulq Src,Dest Dest = Dest * Src
salq Src,Dest Dest = Dest

at all” in Austrian German
Check out: quiz: day 5: Machine

Dest  1
negq Dest Dest =  Dest
notq Dest Dest = ~Dest
See book for

once
long arith
(long x, long y, long z)
{
long t1 =

arith:
leaq (%rdi,%rsi), %rax
addq %rdx, %rax
leaq (%rsi,%rsi,2), %rdx
salq $4, %rdx
leaq 4(%rdi,%rdx), %rcx
imulq %rcx, %rax
ret

long t1 = x+y;
long t2 = z+t1;
long t3

arith:
leaq (%rdi,%rsi), %rax # t1
addq %rdx, %rax # t2
leaq (%rsi,%rsi,2), %rdx
salq $4, %rdx # t4
leaq 4(%rdi,%rdx), %rcx # t5
imulq %rcx, %rax # rval
ret

Compiler optimization:
Reuse of registers
Substitution (copy propagation)
Strength reduction

Basics: Registers, operands, move
Arithmetic & logical operations
C, assembly, machine code

program (p1.c p2.c)
Asm program (p1.s p2.s)
Object program (p1.o p2.o)
Executable program

Static libraries (.a)

Turning C into Object Code

Code in files p1.c p2.c
Compile with command: gcc –Og p1.c p2.c -o p
Use basic optimizations (-Og) [New to recent versions of GCC]
Put resulting binary in file p

sumstore(long x, long y,

Generated x86-64 Assembly

sumstore:
pushq %rbx
movq %rdx, %rbx
call plus
movq %rax, (%rbx)
popq %rbx
ret

Obtain (on shark machine) with command
gcc –Og –S sum.c
Produces file sum.s
Warning: Will get very different results on non-Shark machines (Andrew Linux, Mac OS-X, …) due to different versions of gcc and different compiler settings.

(%rbx)
popq %rbx
.cfi_def_cfa_offset 8
ret
.cfi_endproc
.LFE35:
.size sumstore, .-sumstore

(%rbx)
popq %rbx
.cfi_def_cfa_offset 8
ret
.cfi_endproc
.LFE35:
.size sumstore, .-sumstore
Things that look weird and are preceded by

sumstore:
pushq %rbx
movq %rdx, %rbx
call plus
movq %rax, (%rbx)
popq %rbx
ret

8 bytes
Data values
Addresses (untyped pointers)

Floating point data of 4, 8,

memory into register
Store register data into memory

Perform arithmetic function on

0xd3
0xe8
0xf2
0xff
0xff

Object Code

Assembler
Translates .s into .o
Binary encoding of each instruction
Nearly-complete image of executable code
Missing linkages between code in different files
Linker
Resolves references between files
Combines with static run-time libraries
E.g., code for malloc, printf
Some libraries are dynamically linked
Linking occurs when program begins execution

Total of 14 bytes
Each instruction 1, 3, or 5 bytes
Starts at address 0x0400595

8-byte value to memory
Quad words in x86-64 parlance
Operands:
t: Register %rax
dest: Register %rbx
*dest: Memory M[%rbx]
Object Code
3-byte

*dest = t;

movq %rax, (%rbx)

0x40059e: 48 89 03

bit pattern of series of instructions
Produces approximate rendition of assembly

0000000000400595 :
400595: 53 push %rbx
400596: 48 89 d3 mov %rdx,%rbx
400599: e8 f2 ff ff ff callq 400590
40059e: 48 89 03 mov %rax,(%rbx)
4005a1: 5b pop %rbx
4005a2: c3 retq

starting at sumstore
x/14xb sumstore

code
Disassembler examines bytes and reconstructs assembly source
% objdump -d WINWORD.EXE

WINWORD.EXE:

Reverse engineering forbidden by
Microsoft End User License Agreement

leads to many quirks and artifacts
C, assembly, machine code
New forms