Explain the action how C program works

1. Write a basic C program which prints a message on the screen, Hello World!-style -- something like this:

        #include <stdio.h>

       int main() {
           printf("Hello World!\n");
       }

2. Compile the program using the GCC compiler. Include these compiler options (refer to the gcc manpage for details):

-g               # enable debugging information
-O0              # do not optimize (that's a capital letter and then the digit zero)
-fno-builtin     # do not use builtin function optimizations

3. The resulting binary is an ELF (Executable and Linkable Format) file, which contains multiple sections. These sections may contain object code, link tables, debugging symbols, program data (such as constants and the initial values of variables), metadata about the program and ELF sections, and comments.
Examine the binary produced by the previous step using the objdump program. These options may be useful -- see the manpage for objdump for other options:

-f          # display header information for the entire file
-s          # display per-section summary information
-d          # disassemble sections containing code
--source    # (implies -d) show source code, if available, along with disassembly

4. Try to gain a basic understanding of what the compiled code is doing.
5. Recompile the code with these changes:
(1) Add the compiler option -static. Note and explain the change in size, section headers, and the function call.
 files' size of compiling originally:


the files' size of compiling with -static:




We can see the per-section summary information, disassemble sections and source code for static one are much more than original one.

 The static one include all the libraries in the compiled file, section headers 

are much bigger than original one. 

Function call for original:

function call for -static:

we can see the static directly call function from IO, because it includes everything it need.

(2) Remove the compiler option -fno-builtin. Note and explain the change in the function call.
original function call:

remove no-builtin:





We can see when remove no-builtin, the function call is optimized and directly call the 'puts' which is the parent of printf when you don't add any parameters.

(3) Remove the compiler option -g. Note and explain the change in size, section headers, and disassembly output.
original files size:


remove -g:
 

We can see when remove the -g, the pre-section info is smaller, because it doesn't include debug information any more.

(4) Add additional arguments to the printf() function in your program. Note which register each argument is placed in. (Tip: Use sequential integer arguments after the first string argument. Go up to 10 arguments and note the pattern).
 
 We can see the integer arguments is place in the registers one by one together. And they are moved backward. Here we can also find how stack works in the when compiler is working with registers.

(5) Move the printf() call to a separate function, and call that function from main(). Explain the changes in the object code.
original code:




When separate function:


We can see when separate the printf to another function, it will go to the function first, and then call printf.

(6) Remove -O0 and add -O3 to the gcc options. Note and explain the difference in the compiled code.
 when add -o3 optimization,






the code goes to the front, and the section info become inline.

Thats it.