131 Week 9 - Compilation

Question 1

What are the 4 stages for creating an executable file

Answer 1

1. Pre-processor
2. Compiler
3. Assembler
4. Linker

Question 2

Role of the pre-processor

Answer 2

Identify all lines with a # (e.g., #include or #define) and resolve them to be in C e.g., pre-processor copy the headers to the program for an #include.
Results in “pure” c code as a .i file.

Question 3

Role of compiler

Answer 3

Transforms pure C from the pre-processor into assembly code.
Assembly code is not machine code but is still human readable.
Assembly code is dependent on machine architecture.

Question 4

Role of the assembler

Answer 4

Creates machine code from assembly code.
Stored in a .o file.

Question 5

Role of the linker

Answer 5

Combine several object files together into 1 executable.

Question 6

Main formats of object files

Answer 6

ELF: Executable and Linking Format (Linux)
COFF: Common Object-File Format (Windows)
Mach-O: Mac OS X (Mach Kernel)

Question 7

ELF Object file

Answer 7

A file that contains machine code. Has the following sections:
“text” section - machine code of program
“data” section - store constants and metadata. Split into .data and .rodata (read-only data)
“bss” - block starting symbol. Stores required space for uninitialized data e.g., variables.
- symbol tables (location of functions)
- relocation information (what to modify when linking)

Question 8

Symbol table

Answer 8

Stores information e.g., headers of all the functions within the object file.

Question 9

Relocation information

Answer 9

Stores information about functions that are not in the object file (e.g., from libraries or other object files) and need to have their addresses resolved and added to the object file.

Question 10

Examine object files

Answer 10

gcc -c filename.c to create an object file from the .c file. (-c means compile (first 3 stages) so linker is not used resulting in .o not .exe)
nm filename.o to inspect the object file (nm = name mangling)

Question 11

Linker

Answer 11

Links object files and libraries. Uses relocation information to resolve all addresses in an object file. Combines symbol table and relocation information to result in a final executable file.

Question 12

What are the 2 types of linking

Answer 12

Static linking and dynamic linking.

Question 13

Static linking

Answer 13

When a function is needed from a library, the entire library is combined with the program at linking time.
The binding between program and library is fixed so if library is updated, it needs to be re-linked to use the new library.
Static linkers link against archives of objects (.a files).

Question 14

Pros and cons of static linking

Answer 14

+ When you compile your program, you know what library is used and when you copying programs, you know that everything is present.
- Takes up more disk space and often more memory space.

Question 15

Dynamic linking

Answer 15

Requires a 5th stage of compilation called the loader.
Embeds which libraries are depended on and their locations in the executable file instead of copying the library. These addresses are then resolved at runtime by the loader.
Dynamic linkers link against shared objects (.so files).

Question 16

Pros and cons of dynamic linking

Answer 16

+ Small file size on disk. Library can be upgraded and the executable will not need to be re-linked. Programs can share libraries in memory with memory management.
- Impacts of changing libraries is not always clear.

Question 17

Examine executables

Answer 17

gcc -o exeFileName fileName.c to compile to executable
nm exeFileName | more to inspect the executable
use | more so that it will be easier to read - creates pages you can scroll through.

Question 18

Examine dynamic linker files

Answer 18

ldd exeFileName
ldd stands for list dynamic dependencies and will display the shared objects the executable is dynamically linked to.

Question 19

Why is the linker separate from the compiler

Answer 19

Compiler creates object files and the linker combines them into an executable. By keeping the linker separate from the compiler, a file can be changed and re-compiled and the files can be re-linked without every single file needing to be re-compiled.
Very important for large projects with lots of files.

Question 20

Loader

Answer 20

During runtime, the loader will find the actual address of a needed function found by the dynamic linker and resolve it in the executable so the necessary information can be found.

Question 21

Creating an executable in CODAL

Answer 21

Very similar to creating an executable normally. Differences:
Preprocessor is prompted to include MicroBit.h by #include “MicroBit.h”
Object file (main.cpp.obj) is linked with 3 libraries to create the .hex file.
Compiled using C compiler for ARM architecture.

Question 22

MICROBIT.hex linking and loading

Answer 22

Only static linking is supported for MICROBIT.hex.
MICROBIT.hex does not need a loader.