From Source to Binaries: The journey of a C++ program
Tags: cpp, programming, compilers
Published: 2020-10-15 18:18:04

---
title: From Source to Binaries: The journey of a C++ program
published: true
description: Precursor to developing a compiler is understanding it
tags: CPP, Programming, Compilers
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/kbx7bzemz1nkyyrldl6w.jpg
---

If you couldn't already tell, I love Bjarne, and by extension, I love C++. In this article, I go over how C++ compiles a program to binaries, and why I love C++. This is partially to understand how C++ works. Documentation helps me understand.
>There are only two kinds of languages: the ones people complain about and the ones nobody uses.
― Bjarne Stroustrup, The C++ Programming Language

I got pretty inspired by HaoranWang's <u><a href="https://github.com/onehr/crust">CRUST</a></u> and thus wanted to write my own Compiler for C. I'll probably stick to Rust. Also, shoutout <u><a href="https://github.com/ShivamSarodia/ShivyC">ShivyC</a></u>, that's where I got this idea from.

Let's get started with the compilation pipeline!

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/o3jqrm6f4c4ehgn41hhk.JPG)
 
What you see above is the compilation flow taken from <u><a href = "https://nerdyelectronics.com">NerdyElectronics.com</a></u>. 

For the purpose of this article, we will use a simple addition problem with predefined values.
```cpp
//a.cpp program
#include <iostream>
using namespace std;

int main()
{
    int firstNumber = 2, secondNumber =4, sumOfTwoNumbers;

    // sum of two numbers in stored in variable sumOfTwoNumbers
    sumOfTwoNumbers = firstNumber + secondNumber;

    // Prints sum 
    cout << firstNumber << " + " <<  secondNumber << " = " << sumOfTwoNumbers;     

    return 0;
}
```

If you go back to the diagram, you can see we are presently on the preprocessing stage. Let's have a quick look at the <u>[Translation Unit](https://en.wikipedia.org/wiki/Translation_unit)</u>. Translation Units is the input you give to the compiler, after it includes header files and expands macros.

You can get your Translation unit dump using the following command
```shell
g++ <filename>.cpp -E
```

The dump looks something like this
```c
# 1 "a.cpp"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "a.cpp"
# 1 "c:\\mingw\\lib\\gcc\\mingw32\\8.2.0\\include\\c++\\iostream" 1 3
# 36 "c:\\mingw\\lib\\gcc\\mingw32\\8.2.0\\include\\c++\\iostream" 3
       
# 37 "c:\\mingw\\lib\\gcc\\mingw32\\8.2.0\\include\\c++\\iostream" 3

# 1 "c:\\mingw\\lib\\gcc\\mingw32\\8.2.0\\include\\c++\\mingw32\\bits\\c++config.h" 1 3
# 236 "c:\\mingw\\lib\\gcc\\mingw32\\8.2.0\\include\\c++\\mingw32\\bits\\c++config.h" 3

# 236 "c:\\mingw\\lib\\gcc\\mingw32\\8.2.0\\include\\c++\\mingw32\\bits\\c++config.h" 3
namespace std
{
  typedef unsigned int size_t;
  typedef int ptrdiff_t;

```

It's too damn long to post here (because it literally adds stdio header file, that's like 1k lines of code), but run it on your system if you're curious.

## Assembly Code
Detouring for a bit, There's this grapevine that the closer you are to the hardware, the faster you will be. While there is a modicum of truth to this, often "slower" languages like Python are slow because they're interpreted or are memory hogs due to dynamic typing. There are plenty of Python-to-C/C++ compilers and there are plenty of projects that help you do Python "faster". Don't, for the love of God, develop something in a certain language because it is "closer to the hardware".

Anyway, now run this on the a.cpp file we had

```shell
gpp a.cpp -S
```

Now you'll have something like this

```assembly
	.file	"a.cpp"
	.text
	.section .rdata,"dr"
__ZStL19piecewise_construct:
	.space 1
.lcomm __ZStL8__ioinit,1,1
	.def	___main;	.scl	2;	.type	32;	.endef
LC0:
	.ascii " + \0"
LC1:
	.ascii " = \0"
	.text
	.globl	_main
	.def	_main;	.scl	2;	.type	32;	.endef
_main:
LFB1502:
	.cfi_startproc
	leal	4(%esp), %ecx
	.cfi_def_cfa 1, 0
	andl	$-16, %esp
	pushl	-4(%ecx)
	pushl	%ebp
	.cfi_escape 0x10,0x5,0x2,0x75,0
	movl	%esp, %ebp
	pushl	%ecx
	.cfi_escape 0xf,0x3,0x75,0x7c,0x6
	subl	$36, %esp
	call	___main
	movl	$2, -12(%ebp)
	movl	$4, -16(%ebp)
	movl	-12(%ebp), %edx
	movl	-16(%ebp), %eax
	addl	%edx, %eax
	movl	%eax, -20(%ebp)
	movl	-12(%ebp), %eax
	movl	%eax, (%esp)
	movl	$__ZSt4cout, %ecx
	call	__ZNSolsEi
	subl	$4, %esp
	movl	$LC0, 4(%esp)
	movl	%eax, (%esp)
	call	__ZStlsISt11char_
```
Again, too damn long, try it out on your own system! This will be built for your target architecture. Find out what is your system's architecture as an exercise! Now, Each architecture has a different Instruction Set that is understood by its processor and your compiler splits this into processes: 

1. Create an <u>[Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree)</u>
2. Generate architecture dependent instructions

Let's go over what that means.

## Abstract Syntax Trees

Abstract Syntax tree is well, abstract from the target architecture. However, that's not where the "abstract" part of the term comes from. According to the <u>[Wikipedia](https://en.wikipedia.org/wiki/Abstract_syntax_tree#Motivation)</u>, abstract refers to the fact that "it does not refer to every detail appearing in the real syntax, but rather just structural or content related details". ASTs are generated after syntax analysis. All programs can generate an AST. For our code, this is what the AST looks like
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/fbqp9ihwp1an23l7adve.png)

Here's how to do it yourself
```shell
g++ -fdump-tree-all-graph a.cpp -o a
dot -Tpng a.cpp.013t.cfg.dot -o a.png
```
This is built using GraphViz, install it for your command line. You can also copy paste the contents of `a.cpp.013t.cfg.dot`  on any online GraphViz visualizer.

## Object File and Linking

Object File has object code, that is essentially machine code (or some intermediate code). It is the "object" of compiling process, as you can see in this classic <u>[article](https://www.geeksforgeeks.org/phases-of-a-compiler/)</u>. The reason I didn't use that fancy "Phases of Compiling Process" chart is because it kind of abstracts the real process of compilation. In due time, we will talk about that too. Create your object (.o) file using this, before we go ahead.

```shell
g++ a.cpp -c
```

Now, let's look at linking, which you do after you create your object files. The object files are linked together to create another object file that is executable. For this, let me divide the program into a header and a main CPP file.
```c
//a.h
#include <stdio.h>
void printLinker()
{
    printf("Hello World");
}
```
Now, let's call that in another file
```c
#include "a.h"
int main()
{
    printLinker();
    return 0;
}
```

Finally, to show the linking, let's create another source file
```c
//We will name this a2.cpp
void printLinker();
```
Compiling a.cpp would give me a `Hello World`, as expected. But we need to see the linking, right?
```shell
g++ a.h -c
g++ a.cpp -c
g++ a2.cpp -c
```
Now, we are back to having a .obj and a .gch (precompiled header, if this is not found, the compiler looks for the header). Let's link!
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/27kceykouqzq1sy99tdd.jpg)

```shell
gcc a.o a2.o -o a2.exe
```

Nice, you see how we just called the two object files and compiled them? Now we need to just run a2.exe, it would have printed `Hello World`.
```shell
./a2.exe
Hello World
```

Perfect. If you want to see what lies inside these files, you use <b>nm</b> tool.
```shell
nm a.o
```

You get the following
```
00000000 b .bss
00000000 d .data
00000000 r .eh_frame
         U ___main
00000015 T _main
         U _printf
00000000 r .rdata
00000000 r .rdata$zzz
00000000 t .text
00000000 T __Z7print_av
```

You can do the same for the other object file! It is pretty clear what the files contain, it is well sectioned.

Whew, that was a lot, that's how a compiler compiles. Let me just conclude real quick.
* Preprocessing
* Compilation
* Assembly
* Linking

That's about it, folks! See you around in part 2, which I will update here.