The different phases examined below are:
More information and examples using some of these tools to examine .o and a.out files (hexdump, strings, objdump, gdb).
// simple.c:
#include <unistd.h>
#define MAX 10
int foo(int y);
main() {
int x, i;
char buf[10];
for(i=0; i < MAX; i++) {
x = foo(i);
// a crazy way to print to stdout
sprintf(buf, "%d", x);
write(0, buf, strlen(buf));
buf[0] = '\n';
write(0, buf, 1);
}
}
int foo(int y) {
return y*y;
}
# the C source file: # $ file simple.c simple.c: ASCII C program text # the object file: produces relocatable machine code # ELF: stands for Executable and Linking Format, and is the format for # .o, a.out, and .so files produced by gcc. The format is necessary # so that programs that process these files, and the OS, know how # to find different parts of the code and data in this file # Intel 80386: is the target architecture # not stripped: means that this .o file includes a symbol table # $ file simple.o simple.o: ELF 32-bit LSB relocatable, Intel 80386, version 1 (SYSV), not stripped # the executable file: # $ file simple simple: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), for GNU/Linux 2.6.8, dynamically linked (uses shared libs), not stripped # a shared object file (dynamically linked library): # $ file /lib/libc-2.7.so /lib/libc-2.7.so: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), for GNU/Linux 2.6.8, stripped
# run cpp: $ cpp simple.c | less # run just the preprocessor part of gcc: $gcc -E simple.c | less # look at the output to see what happens to #includes and #defines from simple.chere is a very detailed reference about the pre-processor.
This phase does the bulk of the compilation work, translating a program written in the C high-level programming language to low-level instructions for a specific instruction set architecture (ISA). A processor microarchitecture that implments this ISA can execute these instructions. For example, both Intel and AMD have processors that can execute the IA32 ISA.
Use the -S option to gcc to produce a .s file:
$ gcc -S simple.cThis creates a text file, simple.s, of the C to assembly code translation. The simple.s file can be viewed using a text editor:
$ vim simple.s
Use the -c option to gcc to produce a .o file:
$ gcc -c simple.cYou can see the assembly code in simple.o using either objdump or gdb (all addresses are listed in hexidecimal (base 16)):
$ objdump -d simple.o ... 00000000: 0: 8d 4c 24 04 lea 0x4(%esp),%ecx 4: 83 e4 f0 and $0xfffffff0,%esp 7: ff 71 fc pushl -0x4(%ecx) a: 55 push %ebp b: 89 e5 mov %esp,%ebp d: 51 push %ecx e: 83 ec 34 sub $0x34,%esp 11: 65 a1 14 00 00 00 mov %gs:0x14,%eax 17: 89 45 f8 mov %eax,-0x8(%ebp) 1a: 31 c0 xor %eax,%eax ...
$ gdb simple.o (gdb) disass main (gdb) disass foo (gdb) quit
# create an executable file from simple.o and some standard libraries that gcc automatically links in: gcc -o simple simple.o