Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void...
Transcript of Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void...
![Page 1: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/1.jpg)
Compilers:From Programming to Execution
David BrumleyCarnegie Mellon University
![Page 2: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/2.jpg)
You will find
at least one error
on each set of slides. :)
2
![Page 3: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/3.jpg)
3
To answer the question
“Is this program safe?”
We need to know
“What will executingthis program do?”
![Page 4: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/4.jpg)
#include <stdio.h>
void answer(char *name, int x){
printf(“%s, the answer is: %d\n”,name, x);
}
void main(int argc, char *argv[]){
int x;
x = 40 + 2;
answer(argv[1], x);}
4
What will executing this program do?
42.c
![Page 5: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/5.jpg)
5
void answer(char *name, int x){
printf(“%s, the answer is: %d\n”,name, x);
}
void main(int argc, char *argv[]){
int x;
x = 40 + 2;
answer(argv[1], x);}
David, the answer is 42
David
Compilation
001101011010101000101
The compiler and machine determines
the semantics
The compiler and machine determines
the semantics
![Page 6: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/6.jpg)
6
CompilationSource Language
TargetLanguage
Input
Output
“Compiled Code”
![Page 7: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/7.jpg)
7
Interpretation
Source Language
Input
Output
“Interpreted Code”
![Page 8: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/8.jpg)
Today: Overview of Compilation
1. How is C code translated to executable code?
2. What is the machine model for executing code?
8
![Page 9: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/9.jpg)
Key Concepts
• Compilation workflow
• x86 execution model
• Endian
• Registers
• Stack
• Heap
• Stack frames
9
![Page 10: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/10.jpg)
Compilation Workflow
10
![Page 11: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/11.jpg)
11
CompilationSource
LanguageTargetLanguage
42.c in C 42 in x86
42.c
Pre-processor
(cpp)
Linker(ld)
42
Compiler(cc1)
Assembler(as)
![Page 12: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/12.jpg)
12
Pre-processor
(cpp)
Linker(ld)
Compiler(cc1)
Assembler(as)
#include <stdio.h>
void answer(char *name, int x){
printf(“%s, the answer is: %d\n”,name, x);
}
...
#include expansion#define substitution
$ cpp
![Page 13: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/13.jpg)
13
Pre-processor
(cpp)
Linker(ld)
Compiler(cc1)
Assembler(as)
#include <stdio.h>
void answer(char *name, int x){
printf(“%s, the answer is: %d\n”,name, x);
}
...
Creates Assembly
$ gcc -S
![Page 14: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/14.jpg)
_answer:Leh_func_begin1:
pushq %rbpLtmp0:
movq %rsp, %rbpLtmp1:
subq $16, %rspLtmp2:
movl %esi, %eaxmovq %rdi, -8(%rbp)movl %eax, -12(%rbp)movq -8(%rbp), %rax....
14
gcc –S 42.c outputs 42.s
![Page 15: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/15.jpg)
15
Pre-processor
(cpp)
Linker(ld)
Compiler(cc1)
Assembler(as)
Creates object code
$ as <options>
_answer:Leh_func_begin1:
pushq %rbpLtmp0:
movq %rsp, %rbpLtmp1:
subq $16, %rspLtmp2:
movl %esi, %eaxmovq %rdi, -8(%rbp)movl %eax, -12(%rbp)movq -8(%rbp), %rax....
42.s
![Page 16: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/16.jpg)
16
Pre-processor
(cpp)
Linker(ld)
Compiler(cc1)
Assembler(as)
Links with other files and libraries to produce an exe
$ ld <options>010110010101010110101010110101010101010101111111000011010101101010100101011010111101010010110000101010111101
42.o
![Page 17: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/17.jpg)
Disassembling
• Today: using objdump (part of binutils)
– objdump –D <exe>
• If you compile with “-g”, you will see more information
– objdump –D –S
• Later: Disassembly
17
![Page 18: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/18.jpg)
Binary
Final executable consists of several segments
• Text for code written
• Read-only data for constants such as “hello world” and globals
• ...
18
The program binary (aka executable)
Code Segment(.text)
Data Segment(.data)
...
$ readelf –S <file>
![Page 19: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/19.jpg)
Basic Execution Model
19
![Page 20: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/20.jpg)
ProcessMemoryFile system
Basic Execution
20
Binary
Code
Data
...Stack
Heap
Processor
Fetch, decode, execute
read and write
![Page 21: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/21.jpg)
21
x86 Processor
EAX
EDX
ECX
EBX
ESP
EBP
EDI
ESI
EIP
EFLAGS
Address of next
instruction
Condition codes
GeneralPurpose
![Page 22: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/22.jpg)
Registers have up to 4 addressing modes
1. Lower 8 bits
2. Mid 8 bits
3. Lower 16 bits
4. Full register
22
EAX
EDX
ECX
EBX
ESP
EBP
EDI
ESI
![Page 23: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/23.jpg)
EAX, EDX, ECX, and EBX
23
EAX
EDX
ECX
EBX
ALAH
Bit 32 16 15 8 7 0
DH DL
CLCH
BH BL
• 32 bit registers(three letters)
• Lower bits (bits 0-7) (two letters with L suffix)
• Mid-bits (bits 8-15) (two letters with H suffix)
EAX
EDX
ECX
EBX
AX
Bit 32 16 15 0
DX
CX
BX
• Lower 16 bits (bits 0-15) (2 letters with X suffix)
![Page 24: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/24.jpg)
ESP, EBP, ESI, and EDI
24
EAX
EDX
ECX
EBX
ALAH
DH DL
CLCH
BH BL
ESP
EBP
ESI
EDI
SP
Bit 32 16 15 0
BP
SI
DI
• Lower 16 bits (bits 0-15) (2 letters)
![Page 25: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/25.jpg)
Basic Ops and AT&T vs Intel Syntax
Meaning AT&T Intel
ebx = eax movl %eax, %ebx mov ebx, eax
eax = eax + ebx addl %ebx, %eax add eax, ebx
ecx = ecx << 2 shl $2, %ecx shl ecx, 2
25
• AT&T is at odds with assignment order. It is the default for objdump, and traditionally used for UNIX.
• Intel order mirrors assignment. Windows traditionally uses Intel, as is available via the objdump ‘-M intel’ command line option
source first
destination first
![Page 26: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/26.jpg)
Memory Operations
26
![Page 27: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/27.jpg)
x86: Byte Addressable
27
...
Address 0 holds 1 byte
Address 1 holds 1 byte
Address 2 holds 1 byte
Address 3 holds 1 byte
Alternative: Word addressable Example: For 32-bit word size, it’s valid to fetch 4 bytes from Mem[0], but not Mem[6] since 6 is not a multiple of 4.
I can fetch bytes at any address
Memory is just like using an
array!
It’s convention: lower address at the bottom
![Page 28: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/28.jpg)
x86: Addressing bytes
28
Addresses are indicated by operands that have a bracket “[]” or paren “()”, for Intel vs. AT&T, resp.
Register Value
eax 0x3
edx 0x0
ebx 0x5
What doesmov dl, [al]
do?
Moves 0xcc into dl
00x00
Addr
6
0xaa
0xbb
0xcc
0xdd
0xee
0xff
![Page 29: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/29.jpg)
x86: Addressing bytes
29
Addresses are indicated by operands that have a bracket “[]” or paren “()”, for Intel vs. AT&T, resp.
Register Value
eax 0x3
edx 0xcc
ebx 0x5
What doesmov edx , [eax]
do?
Which 4 bytes get moved, and which is the LSB in edx?
00x00
Addr
6
0xaa
0xbb
0xcc
0xdd
0xee
0xff
![Page 30: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/30.jpg)
Endianess
• Endianess: Order of individually addressable units
• Little Endian: Least significant byte first
so address a goes in littlest byte (e.g., AL), a+1 in the next (e.g., AH), etc.
30
Register Value
eax 0x3
edx 0xcc
ebx 0x500x00
Addr
6
0xaa
0xbb
0xcc
0xdd
0xee
0xff
![Page 31: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/31.jpg)
00x00
Addr
6
0xaa
0xbb
0xcc
0xdd
0xee
0xff
EDX
31
Register Value
eax 0x3
edx 0xcc
ebx 0x5
mov edx, [eax]
0xcc
0xdd
0xffBit 0
0xee
Endianess: Ordering of individually addressable unitsLittle Endian: Least significant byte first... so ...address a goes in the least significant byte (the littlest bit) a+1 goes into the next byte, and so on.
EDX = 0xffeeddcc!
![Page 32: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/32.jpg)
00x00
Addr
6
0xaa
0xbb
0xcc
0xdd
0xee
0xff
EBX
mov [eax], ebx
00 00 0500 05000000
32
Register Value
eax 0x3
edx 0xcc
ebx 0x5
Bit 0
Endianess: Ordering of individually addressable unitsLittle Endian: Least significant byte first... so ...address a goes in the least significant byte (the littlest bit) a+1 goes into the next byte, and so on.
![Page 33: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/33.jpg)
33
There are other ways to address memory than just [register].
These are called Addressing Modes.
An Addressing Mode specifies how to calculate the effective memory address of an operand by using information from registers and constants
contained with the instruction or elsewhere.
![Page 34: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/34.jpg)
34
Motivation: Addressing Buffers
Type buf[s];buf[index] = *(<buf addr>+sizeof(Type)*index)
![Page 35: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/35.jpg)
Motivation: Addressing Buffers
typedef uint32_t addr_t;
uint32_t w, x, y, z;
uint32_t buf[3] = {1,2,3};
addr_t ptr = (addr_t) buf;
w = buf[2];
x = *(buf + 2);
35
0
0
0
3
0
0
0
2
0
0
0
1
Mem
ory
What is x? what memory cell does it ref?
buf[2]
buf
![Page 36: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/36.jpg)
Motivation: Addressing Buffers
typedef uint32_t addr_t;
uint32_t w, x, y, z;
uint32_t buf[3] = {1,2,3};
addr_t ptr = (addr_t) buf;
w = buf[2];
x = *(buf + 2);
y = *( (uint32_t *) (ptr+8));
36
0
0
0
3
0
0
0
2
0
0
0
1
Mem
ory
buf[2]
buf
Equivalent
(addr_t) (ptr + 8) = (uint32_t *) buf+2
![Page 37: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/37.jpg)
37
Motivation: Addressing Buffers
Type buf[s];buf[index] = *(<buf addr>+sizeof(Type)*index)
Say at imm +r1 Say in Register r2
Constant scaling factor
s, typically 1, 2, 4, or 8
imm + r1 + s*r2
AT&T: imm (r1, r2, s)Intel: r1 + r2*s + imm
![Page 38: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/38.jpg)
AT&T Addressing Modes for Common Codes
38
Form Meaning on memory M
imm (r) M[r + imm]
imm (r1, r2) M[r1 + r2 + imm]
imm (r1, r2, s) M[r1 + r2*s + imm]
imm M[imm]
![Page 39: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/39.jpg)
Referencing Memory
39
<eax> = *buf;mov -0x38(%ebp),%eax (I)mov eax, [ebp-0x38] (A)
<eax> = buf;lea -0x38(%ebp),%eax (I)lea eax, [ebp-0x38] (A)
Loading a value from memory: mov
Loading an address: lea
![Page 40: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/40.jpg)
Suppose I want to access address0xdeadbeef directly
40
lea eax, 0xdeadbeef (I)Loads the address
mov eax, 0xdeadbeef (I)Deref the address
Note missing $. This distinguishes the
address from the value
![Page 41: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/41.jpg)
Control Flow
41
![Page 42: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/42.jpg)
Assembly is “Spaghetti Code”
Nice C Abstractions
• if-then-else
• while
• for loops
• do-while
Assembly
• Jump
– Direct: jmp addr
– Indirect: jmp reg
• Branch
– Test EFLAG
– if(EFLAG SET) goto line
42
![Page 43: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/43.jpg)
x86 ProcessorJumps
• jmp 0x45, called a direct jump
• jmp *eax , called an indirect jump
Branches• if (EFLAG) jmp x
Use one of the 32 EFLAG bits to determine if jump taken
43
EAX
EDX
ECX
EBX
ESP
EBP
EDI
ESI
EIP
EFLAGS
Note:No direct
way to get or set EIP
![Page 44: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/44.jpg)
Implementing “if”
C
1. if(x <= y) 2. z = x;
3. else 4. z = y;
Psuedo-Assembly
1. Computing x – y. Set eflags:1. CF =1 if x < y
2. ZF =1 if x==y
2. Test EFLAGS. If both CF and ZF not set, branch to E
3. mov x, z
4. Jump to F
5. mov y, z
6. <end of if-then-else>
44
Assembly is 2 instrs1. Set eflag to
conditional2. Test eflag and branch
![Page 45: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/45.jpg)
If (x > y)
%eax holds x and 0xc(%ebp) holds y
cmp 0xc(%ebp), %eaxja addr
45
Same as “sub” instructionr = %eax - M[%ebp+0xc], i.e., x – y
Jump if CF=0 and ZF=0
(x >= y) (x != y)⋀ x > y⇒
![Page 46: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/46.jpg)
Setting EFLAGS
• Instructions may set an eflag, e.g.,
• “cmp” and arithmetic instructions most common
– Was there a carry (CF Flag set)
– Was the result zero (ZF Flag set)
– What was the parity of the result (PF flag)
– Did overflow occur (OF Flag)
– Is the result signed (SF Flag)
46
![Page 47: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/47.jpg)
47
From the Intel x86 manual
Aside: Although the x86 processorknows every time integer overflowoccurs, C does not make this resultvisible.
![Page 48: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/48.jpg)
See the x86 manuals available onIntel’s website for more information
Instr. Description Condition
JO Jump if overflow OF == 1
JNO Jump if not overflow OF == 0
JS Jump if sign SF == 1
JZ Jump if zero ZF == 1
JE Jump if equal ZF == 1
JL Jump if less than SF <> OF
JLE Jump if less than or equal ZF ==1 or SF <> OF
JB Jump if below CF == 1
JP Jump if parity PF == 1
48
![Page 49: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/49.jpg)
Memory Organization
49
![Page 50: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/50.jpg)
run time heap
shared libraries
user stack
0x00000000
0xC0000000 (3GB)
%esp
brk
MemoryProgram textShared libsData...
•Stack grows down•Heap grows up
The Stack grows down towards lower addresses.
50
![Page 51: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/51.jpg)
Variables
• On the stack– Local variables
– Lifetime: stack frame
• On the heap– Dynamically
allocated via new/malloc/etc.
– Lifetime: until freed
51
run time heap
shared libraries
user stack
0x00000000
0xC0000000 (3GB)
![Page 52: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/52.jpg)
Procedures
• Procedures are not native to assembly
• Compilers implement procedures
– On the stack
– Following the call/return stack discipline
52
![Page 53: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/53.jpg)
Procedures/Functions
• We need to address several issues:1. How to allocate space for local variables
2. How to pass parameters
3. How to pass return values
4. How to share 8 registers with an infinite number of local variables
• A stack frame provides space for these values– Each procedure invocation has its own stack frame
– Stack discipline is LIFO• If procedure A calls B, B’s frame must exit before A’s
53
![Page 54: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/54.jpg)
54
orange
red
green
Function Call Chain
green
...
green
orange(…)
{
...red()...
}
red(…)
{
...
green()
...
green()
}
green(…)
{
...
green()
...
}
![Page 55: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/55.jpg)
55
orange
red
green
Function Call Chain
green
...
green
Frame for• locals• pushing parameters• temporary space
Call to red “pushes” new frame
When greenreturns it “pops” its frame
![Page 56: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/56.jpg)
On the stack
int orange(int a, int b)
{
char buf[16];
int c, d;
if(a > b)c = a;
elsec = b;
d = red(c, buf);
return d;
}
Need to access arguments
Need space to storelocal vars (buf, c, and d)
Need space to put arguments for callee
Need a way for callee to return values
Calling convention determines the above features56
![Page 57: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/57.jpg)
cdecl – the default for Linux & gcc
57
int orange(int a, int b)
{
char buf[16];
int c, d;
if(a > b)c = a;
elsec = b;
d = red(c, buf);
return d;
}
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
return addr
orange’s ebp
…
%ebpframe
%espstack
parameterarea (caller)
orange’sinitialstack
frame
to be createdbefore
calling red
after red hasbeen called
gro
w
Don’t worry!We will walk
through theseone by one.
![Page 58: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/58.jpg)
When orange attains control,
1. return address has already been pushed onto stack by caller
58
…
b
a
return addr
%ebp(caller)
%esp
![Page 59: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/59.jpg)
When orange attains control,
1. return address has already been pushed onto stack by caller
2. own the frame pointer
- push caller’s ebp
- copy current esp into ebp
- first argument is at ebp+8
59
…
b
a
return addr
caller’s ebp %ebpand
%esp
![Page 60: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/60.jpg)
When orange attains control,
1. return address has already been pushed onto stack by caller
2. own the frame pointer
- push caller’s ebp
- copy current esp into ebp
- first argument is at ebp+8
3. save values of other callee-save registers if used
- edi, esi, ebx: via push or mov
- esp: can restore by arithmetic
60
…
b
a
return addr
caller’s ebp
callee-save%ebp
%esp
![Page 61: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/61.jpg)
When orange attains control,
1. return address has already been pushed onto stack by caller
2. own the frame pointer
- push caller’s ebp
- copy current esp into ebp
- first argument is at ebp+8
3. save values of other callee-save registers if used
- edi, esi, ebx: via push or mov
- esp: can restore by arithmetic
4. allocate space for locals
- subtracting from esp
- “live” variables in registers, which on contention, can be “spilled” to stack space
61
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
%ebp
%esp
orange’sinitialstack
frame
![Page 62: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/62.jpg)
For caller orange to call callee red,
62
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
%ebp
%esp
![Page 63: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/63.jpg)
For caller orange to call callee red,
1. push any caller-save registers if their values are needed after red returns
- eax, edx, ecx
63
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
%ebp
%esp
![Page 64: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/64.jpg)
For caller orange to call callee red,
1. push any caller-save registers if their values are needed after red returns
- eax, edx, ecx
2. push arguments to red from right to left (reversed)
- from callee’s perspective, argument 1 is nearest in stack
64
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
%ebp
%esp
![Page 65: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/65.jpg)
For caller orange to call callee red,
1. push any caller-save registers if their values are needed after red returns
- eax, edx, ecx
2. push arguments to red from right to left (reversed)
- from callee’s perspective, argument 1 is nearest in stack
3. push return address, i.e., the next instruction to execute in orange after red returns
65
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
return addr
%ebp
%esp
orange’sstack
frame
![Page 66: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/66.jpg)
For caller orange to call callee red,
1. push any caller-save registers if their values are needed after red returns
- eax, edx, ecx
2. push arguments to red from right to left (reversed)
- from callee’s perspective, argument 1 is nearest in stack
3. push return address, i.e., the next instruction to execute in orange after red returns
4. transfer control to red
- usually happens together with step 3 using call
66
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
return addr
%ebp
orange’sstack
frame
%esp
![Page 67: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/67.jpg)
When red attains control,
1. return address has already been pushed onto stack by orange
67
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
return addr
%ebp
%esp
![Page 68: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/68.jpg)
When red attains control,
1. return address has already been pushed onto stack by orange
2. own the frame pointer
68
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
return addr
orange’s ebp %ebpand
%esp
![Page 69: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/69.jpg)
When red attains control,
1. return address has already been pushed onto stack by orange
2. own the frame pointer
3. … (red is doing its stuff) …
69
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
return addr
orange’s ebp
…%ebp
%esp
![Page 70: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/70.jpg)
When red attains control,
1. return address has already been pushed onto stack by orange
2. own the frame pointer
3. … (red is doing its stuff) …
4. store return value, if any, in eax
5. deallocate locals
- adding to esp
6. restore any callee-save registers
70
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
return addr
orange’s ebp %ebpand
%esp
![Page 71: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/71.jpg)
When red attains control,
1. return address has already been pushed onto stack by orange
2. own the frame pointer
3. … (red is doing its stuff) …
4. store return value, if any, in eax
5. deallocate locals
- adding to esp
6. restore any callee-save registers
7. restore orange’s frame pointer
- pop %ebp
71
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
return addr
%ebp
%esp
![Page 72: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/72.jpg)
When red attains control,
1. return address has already been pushed onto stack by orange
2. own the frame pointer
3. … (red is doing its stuff) …
4. store return value, if any, in eax
5. deallocate locals
- adding to esp
6. restore any callee-save registers
7. restore orange’s frame pointer
- pop %ebp
8. return control to orange
- ret
- pops return address from stack and jumps there
72
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
%ebp
%esp
![Page 73: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/73.jpg)
When orange regains control,
73
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
caller-save
buf
c
%ebp
%esp
![Page 74: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/74.jpg)
When orange regains control,
1. clean up arguments to red
- adding to esp
2. restore any caller-save registers
- pops
3. …
74
…
b
a
return addr
caller’s ebp
callee-save
locals(buf, c, d ≥ 24 bytes if stored
on stack)
%ebp
%esp
![Page 75: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/75.jpg)
Terminology
• Function Prologue – instructions to set up stack space and save callee saved registers
– Typical sequence: push ebpebp = espesp = esp - <frame space>
• Function Epilogue- instructions to clean up stack space and restore callee saved registers
– Typical Sequence:leave // esp = ebp, pop ebpret // pop and jump to ret addr
75
![Page 76: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/76.jpg)
cdecl – One Convention
76
Action Notes
caller saves: eax, edx, ecx push (old), or mov if espalready adjustedarguments pushed right-to-left
linkage data starts new frame call pushes return addr
callee saves: ebx, esi, edi, ebp, esp ebp often used to derefargs and local vars
return value pass back using eax
argument cleanup caller’s responsibility
![Page 77: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/77.jpg)
• Why do we need calling conventions?
• Does the callee always have to save callee-saved registers?
• How do you think varargs works (va_start, va_arg, etc)?
void myprintf(const char *fmt, ...){}
Q&A
77
![Page 78: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/78.jpg)
Today’s Key Concepts
• Compiler workflow
• Register to register moves
– Register mnemonics
• Register/memory
– mov and addressing modes for common codes
• Control flow
– EFLAGS
• Program Memory Organization
– Stack grows down
• Functions
– Pass arguments, callee and caller saved, stack frame78
![Page 79: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/79.jpg)
For more information
• Overall machine model: Computer Systems, a Programmer’s Perspectiveby Bryant and O’Hallaron
• Calling Conventions:
– http://en.wikipedia.org/wiki/X86_calling_conventions
79
![Page 80: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/80.jpg)
80
Questions?
![Page 81: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/81.jpg)
END
![Page 82: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/82.jpg)
Backup slides here.
• Titled cherries because they are for the pickin. (credit due to maverick for wit)
82
![Page 83: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/83.jpg)
83
CompilationSource Language
TargetLanguage
Input
Output
“Compiled Code”
VS
Interpretation
Source Language
Input
Output
“Interpreted Code”
![Page 84: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/84.jpg)
Stencils
84
ABC ABC
ABC ABC
ABC ABC
ABC
ABC
ABC
ABCABC
ABC
ABC
![Page 85: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/85.jpg)
Other Colors from Adobe Kuler
ABC ABC
ABC ABC ABC ABC ABC
ABC ABC ABC ABC ABC
Mac application for Adobe Kuler:http://www.lithoglyph.com/mondrianum/http://kuler.adobe.com/
85
Don’t use these unless absolutely necessary. We are not making skittles, so there is no rainbow of colorsnecessary.
![Page 86: Compilers: From Programming to Execution - Carnegie ...dbrumley/courses/18487-f13/...#include void answer(char *name, int x){printf(“%s, the answer is: %d\n”, name,](https://reader031.fdocuments.net/reader031/viewer/2022030510/5aba5fc37f8b9a567c8b6fab/html5/thumbnails/86.jpg)
86
To answer the question
“Is this program safe?”
We need to know
“What will executingthis program do?”
Understanding the compiler and machine semantics are key.