The C Compiler

Last modified Friday, 20-Jan-2023 17:41:29 UTC.

The C Compilation Model
- The Preprocessor
  - We will study this part of the compilation process in greater detail later
  - Removes comments
  - Interprets special preprocessor directives denoted by #.
    - #include - includes contents of a named file. Files usually called header files. E.g.,
```
#include <math.h>
#include <stdio.h>
                    
```
    - #define - defines a symbolic name or constant. Macro substitution. E.g.,
```
#define MAX_ARRAY_SIZE 100
                    
```
  - Run the compiler with the -E option to see the preprocessor output.
- C Compiler
  - The C compiler translates source to assembly code.
  - The source code is received from the preprocessor.
  - Run the compiler with the -S option to leave the assembler output in a .s file.
- Assembler
  - The assembler creates object code.
  - Run the compiler with the -c option to leave the object code in a .o file.
- Link Editor
  - Takes one or more object files (.o) and library files (.a and .so) and creates an executable.
  - If a source file references library functions or functions defined in other object files the link editor combines these functions (with main())
  - External variable references resolved here also.
- Compiler options to control the phases
  -E
  Run just the preprocessor
  -S
  Stop after producing assembler code in a .s file.
  -c
  Suppress the linking process and produce a .o file for each source file listed. Several can be subsequently linked by the gcc command, for example:
```
prompt> gcc  file1.o file2.o ...... -o executable
               
```
Some Useful Compiler Options
-Wall
Do serious checking of the code, kinda like lint.
-o file
Send the compiled output to file rather than the default a.out.
-O level
Optimize the compiled code to level, which is in the range 0 to ... (depends on compiler).
-I directory
Add pathname to the list of directories in which to search for #include files with relative filenames. The preprocessor first searches for #include files in directories named with -I options (if any), and then in /usr/include. So to include header files stored in /home/myname/myheaders you would do:
```
prompt> gcc  prog.c -I /home/myname/myheaders 
```
-l library
Link with object libraries. This option must follow the source file arguments. The object libraries are archived and can be standard, third party or user created libraries. Probably the most commonly used library is the math library. You must link in this library explicitly if you wish to use the maths functions (don't forget to #include <math.h>). For example:
```
prompt> gcc  calc.c -o calc -lm 
```
-L directory
Add directory to the list of directories containing libraries. The linker always looks for standard and other system libraries in /lib and /usr/lib. If you want to link in libraries that you have created or installed yourself (unless you have certain privileges and get the libraries installed in /usr/lib) you have to specify where you files are stored, For example:
```
prompt> gcc  prog.c -L /home/myname/mylibs  -lmystuff 
```
-g
Invoke debugging option. This instructs the compiler to produce additional symbol table information that is used by a variety of debugging utilities.
-D
Define symbols either as identifiers (-D identifer) or as values (-D symbol=value) in a similar fashion as the #define preprocessor command.

Exercises

Enter, compile and run the following program:

int main(void) { 

    int i;

    printf("\t Number \t\t Square of Number\n\n");

    for (i=0; i<=25;++i)
        printf("\t %d \t\t\t %d \n",i,i*i);

}

The following program uses the math library. Enter compile and run it correctly.

#include <math.h>

int main(void) {

    int i;

    printf("\t Number \t\t Square Root of Number\n\n");

    for (i=0; i<=360; ++i)
        printf("\t %d \t\t\t %d \n",i, sqrt((double) i));

}

Look in /lib and /usr/lib and see what libraries are available.
- Use the man command to get details of library functions
- Explore the libraries to see what each contains by running the command ar t libfile.
Look in /usr/include and see what header files are available.
- Use the less or cat commands to view these text files.
- Explore the header files to see what each contains, note the include, define, type definitions and function prototypes declared in them.
Suppose you have a C program whose main function is in main.c and has other functions in the files input.c and output.c:
- What command(s) would you use on your system to compile and link this program?
- How would you modify the above commands to link a library called process1 stored in the standard system library directory?
- How would you modify the above commands to link a library called process2 stored in your home directory?
- Some header files need to be read and have been found to be located in a header subdirectory of your home directory and also in the current working directory. How would you modify the compiler commands to account for this?

Exam Style Questions

What are the four processes in converting a C program to an executable program? What are the formats of each stage's input and output files?
What gcc flag is used to link a particular library into a C program? Give an example.
What gcc flag is used to specify directories where include files might be found?
What does the -D flag do when using gcc? What is an alternative to using the -D flag?