Object files — .o - .obj, symbol table, relocation entries

WHAT is an object file?

WHY does it exist? So we can compile each source file separately (separate compilation) and only re-link when needed. Change one .c, recompile one .o, relink. Fast.

The pipeline (WHERE the .o sits)

file.c --[preprocessor]--> file.i --[compiler]--> file.s --[assembler]--> file.o --[linker]--> a.out

The Symbol Table

HOW to inspect it:

$ nm file.o          # symbol table
$ readelf -s file.o  # detailed ELF symbols
$ readelf -r file.o  # relocation entries
$ objdump -d file.o  # disassembly (shows placeholder addrs)

In nm output, a capital letter = global, lowercase = local: T/t = text(code), D/d = data, B/b = bss, U = undefined.

Relocation Entries — the heart of it

Deriving the relocation formula from first principles

WHY a formula at all? Because the value to write depends on whether the reference is absolute (write the actual address) or PC-relative (write a distance from the patched instruction).

Let:

• $S$ = final address chosen for the symbol,
• $A$ = the addend (a constant stored in the reloc, e.g. -4),
• $P$ = the address of the place being patched (the slot itself).

HOW we got $S+A-P$: A PC-relative branch on x86-64 computes its destination as $\text{dest} = P_{\text{next}} + \text{disp},$ where $P_{\text{next}}$ is the byte just after the displacement field. We want $\text{dest} = S$ (plus any addend). The addend is precisely set so that $A = -(\text{distance from }P\text{ to }P_{\text{next}})$. Solving for the displacement we must store: $\text{disp} = S + A - P.$ That is why the assembler emits addend = -4 for a 4-byte field: the 4 bytes between the patch slot $P$ and the end of the instruction.

Worked Example 1 — a global variable reference (absolute)

Source:

int g;          // defined here (goes to .bss)
int *p = &g;    // p is in .data, needs address of g

The bytes of p in .data must contain &g. But g's final address is unknown at compile time.

Worked Example 2 — calling an external function (PC-relative)

Source main.c:

extern int add(int,int);
int main(){ return add(2,3); }

Why this step (5)? The CPU adds the stored displacement to the address of the next instruction; the -4 addend accounts for the 4 displacement bytes between $P$ and that next instruction, so the jump lands exactly on add.

Worked Example 3 — .bss saves disk space

int big[1000000];   // uninitialised global

This is 1 MB of zeros. Why doesn't the .o grow by 1 MB? Because big goes into .bss, which records only a size, not actual bytes. The OS zero-fills it at load time. Why this matters: initialised data (.data) costs file space; zero-init (.bss) costs none.

Common Mistakes

Flashcards

Connections

• Linker — symbol resolution and relocation
• ELF and COFF file formats
• Static vs Dynamic Linking
• Compilation Pipeline — preprocess, compile, assemble, link
• Sections — .text .data .bss .rodata
• PC-relative addressing in x86-64
• Name mangling in C++

Concept Map

Hinglish (regional understanding)