The document describes the compilation process from source code to executable program. It involves preprocessing the source code, compiling it, assembling the assembly code, and linking object files together along with libraries. The preprocessor handles includes and macros. The compiler parses and analyzes the code to generate an abstract syntax tree and then machine instructions. Object files are linked together and libraries are used to modularize reusable code. Modern compilers like Clang aim to be more modular and expose compiler internals through APIs to enable integration with other tools.

1. The Compilation Process
From Source to Silicon

2. How do we go from this?

3. TO THIS???

4. Compilation + Linking = Building

5. The Pipeline

6. Source program
preprocessing ¯
Source program
compiling ¯
Assembly program
assembling ¯
Machine instructions
linking ¯
Executable code
Lots of stuff
happens here
Loader, processes, OS,
Stacks and Heaps,
Runtimes, exceptions,
CRASH!
Programming..
Xcode, Eclipse,
Sublime Text etc..

7. Compiling C with GCC
The GNU Compiler Collection originally written as the compiler for the GNU OS. The GNU system was developed to be 100% free
software, free in the sense that it “respects the user’s freedom”. - Richard Stallman
Although originally a compiler for only C, Frontends were developed for a number of languages like C, C++, Obj-C, Fortran, Java, Ada,
Go, etc..
Many processor architectures can be targeted by GCC’s backend. In fact, it supports more build targets than LLVM.
"Once GNU is written, everyone will be able to obtain good
system software free, just like air."

8. RAW C FILE contains…
Defines, includes (elements preceded by a
pound character), comments, and others will
be processed by the preprocessor.
Preprocessor directives can be used to
achieve a many where the common
principle is first stage text substituton and
manipulation.
After this step, the compilation stages that
follow except pure and valid C code.

9. “Afunc” function declaration
will be “included” in main.c,
allowing reference to it in main
()’s body.
aFunc’s definition is defined in
aFunc.c. (also compiled
alongside main.c)

10. “gcc -E main.c -o main.i”
GCC’s Preprocessor replaces Include with our
function declaration, removes comments and
performs other text processing tasks. The scope of
what the preprocessor can do expands to many
topics such as enabling debug printing to
determining the target OS to allow conditional code
sections.
E.G.
#if TARGET_OS_IPHONE
@import UIKit;
#else
@import AppKit;
#endif
~#MACROS_also_Useful ( )

12. Tokens and Lexical Analysis

13. Code Generation (in a gigantic nutshell)
After the lexer turns individual lexemes into tokens, the parser performs its language specific
transformation into Abstract Syntax Trees (AST) which are then semantically analyzed and possibly
optimized depending on what flags are set. The parsing stage verifies these syntax trees to check if the
sequence of lexical elements if correct with respect to the grammar of the language. Next, the compiler
either interprets the AST on the fly such as in the case of an interpreted language (Python, Javascript), or
a machine platform is targeted for native code generation.
Typically, interpreted languages allow more platform indifference as an interpreter program which IS
compiled into the machine’s native machine code convert say an “+” operator into the native machines
“Add(i,j)” machine instruction. This results in a potentially very high overhead and therefore a truly
compiled language is typically much faster. In addition, because a fully compiled language sees more of
the program at once, it has the ability to apply more powerful and deep optimizations on the initial code
before compiling down to assembly. With the addition of the notions of bytecode and Virtual machines,
the distinction between interpretation and compilation gets even more complicated...

14. “gcc -S main.i -o main.s”

16. “gcc -c main.s -o main.o”
This Object File contains machine code produced by the GCC assembler from the ‘.s’
assembly file. Multiple .o files can be linked by the linker along with static and shared
libraries to produce the final executable image.

17. “gcc main.o aFunc.o”
Alongside these slides, “aFunc.c” has also been processed in an analogous manner resulting in
aFunc.o. This file, “a.out”, is the executable produced by GCC’s linker program linking these
two object files together into one unit.

18. Shared Vs. Static Libraries

19. Comparing Static and Shared Libraries
If every C program required the C standard library in the form of a static library
than the executables would consume a lot of unnecessary disk space , if every
executable has a copy of printf and fopen for example.. If a library is statically
linked, the code representing the library is compiled into the executable via a
library mechanism. (.a on mac, .lib on windows)
Shared libraries modularize these reusable components and allow multiple
program binaries to link against them at runtime. Shared libraries not only
decrease the size of the dependent program on disk, but allow these programs
which link against them to benefit from improvements made to the shared library.

20. Modern Compilers and You

21. LLVM

22. Some interesting facts about Clang
- Clang is designed as an API from its inception, allowing it to be reused by source analysis tools, refactoring, IDEs (etc)
as well as for code generation. GCC is built as a monolithic static compiler, which makes it extremely difficult to use
as an API and integrate into other tools. Further, its historic design and current policy makes it difficult to decouple
the front-end from the rest of the compiler.
- Clang does not implicitly simplify code as it parses it like GCC does. Doing so causes many problems for
source analysis tools: as one simple example, if you write "x-x" in your source code, the GCC AST will
contain "0", with no mention of 'x'. This is extremely bad for a refactoring tool that wants to rename 'x'.