Transcript Lec7 Machine Code

2010 R&E Computer System Education & Research
Lecture 7. Instructions and High-Level to
Machine Code
Prof. Taeweon Suh
Computer Science Education
Korea University
Instructions and Instruction Set
• If you want to talk to foreigners, you should be able to
speak their languages
 Likewise, to talk to a computer, you must speak its language
• The words of a computer’s language are called
instructions
• The collection of instructions is called instruction set
• Different CPUs have different instruction sets
 x86 has its own instruction set
 MIPS has its own instruction set
 But, they have many aspects in common
2
Korea Univ
MIPS Instruction examples in 2 forms
• Human-readable form
addi $2, $0, 5
sub $7, $7, $2
and $5, $3, $4
// $2 = $0 + 5
// $7 = $7 + $2
// $5 = $3 & $4
• Machine-readable form
0010 0000 0000 0010 0000 0000 0000 0101 = 0x20020005 // addi $2, $0, 5
0000 0000 1110 0010 0011 1000 0010 0010 = 0x00e23822 // sub $7, $7, $2
0000 0000 0110 0100 0010 1000 0010 0100 = 0x00642824 // and $5, $3, $4
3
Korea Univ
Instruction Set Examples
• MIPS
• x86
4
Korea Univ
MIPS and x86 Instruction Sets
• For more information on the complete instruction
sets of MIPS and x86, refer to the following links
 Intel:
http://www.intel.com/products/processor/manuals/
 MIPS:
• We are going to study in detail throughout this course
5
Korea Univ
High Level Code to Assembly to Executable
• What steps did you take to run your program after
writing your code “hello.c” on your Linux machine?
#include <stdio.h>
int main(void)
{
printf("Hello World!\n");
return 0;
}




%gcc hello.c -o hello”
%./hello
% Hello World!
%objdump –D hello
// hello is a machine code (binary or executable)
// it shows human-readable code
6
Korea Univ
Reality check: High Level Code to Assembly to
Executable
C program
preprocessor
cpp (C-preprocessor) in Linux GNU C
Expanded C program
compiler
gcc in Linux GNU C
assembly code
as in Linux GNU
assembler
Human-readable
assembly code
object code
library routines
linker
Machine code
ld in Linux GNU
executable
Linux kernel loads the
executable into memory
7
loader
memory
Korea Univ
Reality check: High Level Code to Assembly to
Executable (Cont)
• The command “gcc” hides all the details
• Try to compile hello.c with “gcc –v hello.c –o hello”
 You will see all the details of what gcc does for compilation
• Compilation goes through several steps to generate
machine code
#include <stdio.h>




Preprocessor
Compilation
Assembler
Linker
int main(void)
{
printf("Hello World!\n");
return 0;
}
8
Korea Univ
Reality check: High Level Code to Assembly to
Executable (Cont)
• Preprocessing
 Use to expand macros and header files included
 %cpp hello.c > hello.i
• open “hello.i” to see what you got
• Compilation
 Actual compilation of the preprocessed code to assembly
language for a specific processor
 %gcc -Wall -S hello.i
• Result will be stored in hello.s
• Open hello.s to see what you got
• Assembler
 Convert assembly language into machine code and generate an
object file
 %as hello.s -o hello.o
• The resulting file ‘hello.o’ contains the machine instructions for the Hello
World program, with an undefined reference to printf
9
Korea Univ
Reality check: High Level Code to Assembly to
Executable (Cont)
• Linker
 Final stage of compilation
 Linking object files to create an executable
 In practice, an executable requires many external functions from
system and C run-time (crt) libraries
 Consequently, the actual link commands used internally by GCC
are complicated.
 Example
• %ld -dynamic-linker /lib/ld-linux.so.2 /usr/lib/crt1.o /usr/lib/crti.o
/usr/lib/gcc/i386-redhat-linux/4.3.0/crtbegin.o -L/usr/lib/gcc/i386redhat-linux/4.3.0 hello.o -lgcc -lgcc_eh -lc -lgcc -lgcc_eh
/usr/lib/gcc/i386-redhat-linux/4.3.0/crtend.o /usr/lib/crtn.o -o hello
• Note that “i386-redhat-linux/4.3.0/” is dependent on your Linux version
• Now run your program
 %./hello
// Linux kernel loads the program into memory
 %Hello World! // output
10
Korea Univ
Stored Program Concept
Memory (DDR)
CPU
FSB
(Front-Side Bus)
Main
Memory
(DDR)
Address Bus
North
Bridge
DMI
(Direct Media I/F)
South
Bridge
CPU
Data Bus
•
•
•
•
Instructions are represented in binary, just like data
Instructions and data are stored in memory
CPU fetches instructions and data to execute
Programs can operate on programs
•
Binary compatibility allows compiled programs to work on
different computers

e.g., compilers, linkers, …

Standardized ISAs
11
Hello World Binary
(machine code)
01101000
11100111
10100000
11110011
01100000 00110011
00110000 01010101
00011111 11100111
11000011 00110011
11100101
11000011
00011110
01010101
C compiler
(machine code)
“Hello World” Source
code in C
Korea Univ
Cross Compiler
• Hmmm, sound good so far
• But, wait! We are talking about MIPS (not x86). Then, How to
generate the MIPS machine code without a MIPS machine?
• You are still able to generate MIPS binaries on an x86 machine…
 How? Use a cross-compiler!!!
x86 machine code
Normal
compilation
int main()
{
int a, b, c;
a = 3;
b = 9;
c = a + b;
return c;
}
int main()
{
int a, b, c;
a = 3;
b = 9;
c = a + b;
return c;
}
x86-based laptop
compile
a = 3;
c7 45 f0 03 00 00 00
b = 9;
c7 45 f4 09 00 00 00
c = a + b;
8b 55 f4
8b 45 f0
01 d0
89 45 f8
movl $0x3,-0x10(%ebp)
movl $0x9,-0xc(%ebp)
mov -0xc(%ebp),%edx
mov -0x10(%ebp),%eax
add %edx,%eax
mov %eax,-0x8(%ebp)
MIPS machine code
MIPS-based laptop
(if present!)
compile
12
a = 3;
24020003
afc20008
b = 9;
24020009
afc20004
c = a + b;
8fc30008
8fc20004
00000000
00621021
afc20000
li
sw
v0,3
v0,8(s8)
li
sw
v0,9
v0,4(s8)
lw
lw
nop
addu
sw
v1,8(s8)
v0,4(s8)
v0,v1,v0
v0,0(s8)
Korea Univ
Cross Compiler (Cont.)
• A cross compiler is a compiler capable of creating
executable code for a platform other than the one
on which the compiler is run -- Wiki
x86 machine code
x86-based laptop
int main()
{
int a, b, c;
a = 3;
b = 9;
c = a + b;
return c;
}
a = 3;
c7 45 f0 03 00 00 00
b = 9;
c7 45 f4 09 00 00 00
c = a + b;
8b 55 f4
8b 45 f0
01 d0
89 45 f8
compile
cross-compile
13
movl $0x3,-0x10(%ebp)
movl $0x9,-0xc(%ebp)
mov -0xc(%ebp),%edx
mov -0x10(%ebp),%eax
add %edx,%eax
mov %eax,-0x8(%ebp)
MIPS machine code
a = 3;
24020003
afc20008
b = 9;
24020009
afc20004
c = a + b;
8fc30008
8fc20004
00000000
00621021
afc20000
li
sw
v0,3
v0,8(s8)
li
sw
v0,9
v0,4(s8)
lw
lw
nop
addu
sw
v1,8(s8)
v0,4(s8)
v0,v1,v0
v0,0(s8)
Korea Univ
MIPS Cross Compiler
• Check out the class web for instructions on how to build
the MIPS cross-compiler on x86-based Linux
• Test-generate binary from the MIPS assembly program
with assembler
add
sub
lw
sw
$t0, $s1, $s2 # $t0 <= $s1 + $s2
$t2, $s3, $s4 # $t2 <= $s3 - $s4
$t0, 24($s3) #load (read) word from memory
# $t0 <= [$s3 + 24]
$t2, 8($s3)
# store(write) word to memory
# [$s3 + 8] <= $t2
0x0232
0x0274
0x8E68
assembler
0xAE6A
4020
5022
0018
0008
Don’t worry. We are going to talk deep about this!
Address Bus
MIPS
CPU
Memory (DDR)
0x0232
0x0274
0x8E68
0xAE6A
4020
5022
0018
0008
Data Bus
14
Korea Univ
This Course …
• In this course, you need to write some (or many) MIPS assembly
code
• Then, use MIPS assembler to assemble your (assembly) program
and a linker to generate executable (binary)
 We don’t use preprocessor and compiler to generate assembly code
because we don’t do high-level programming here
• Finally, run your code in the MIPS simulator called SPIM
 Then, run your code on the CPU you’ll design later!!!
• The compiler course (COMP417) hopefully covers details about
preprocessor and compiler (and assembler, linker, and loader)
• Let’s go over MIPS instructions in a great detail from the next class
15
Korea Univ