// main.c
int sum(int *a, int n);       // khai báo hàm từ file khác
int array[2] = {1, 2};

int main() {
    int val = sum(array, 2);
    return val;
}

// sum.c
int sum(int *a, int n) {
    int i, s = 0;
    for (i = 0; i < n; i++) {
        s += a[i];
    }
    return s;
}

gcc -o prog main.c sum.c
./prog

┌─────────────────────────┐
│       ELF Header        │  ← word size, byte order, loại file, kiến trúc máy
├─────────────────────────┤
│  Segment header table   │  ← page size, địa chỉ ảo các segment (chỉ cần với executables)
├─────────────────────────┤
│       .text             │  ← Machine code (phần code thực thi)
├─────────────────────────┤
│       .rodata           │  ← Dữ liệu chỉ đọc (jump tables, string literals...)
├─────────────────────────┤
│       .data             │  ← Biến toàn cục đã khởi tạo giá trị
├─────────────────────────┤
│       .bss              │  ← Biến toàn cục chưa khởi tạo (không chiếm không gian file)
├─────────────────────────┤
│       .symtab           │  ← Symbol table (hàm, biến toàn cục, static)
├─────────────────────────┤
│      .rel.text          │  ← Relocation info cho .text
├─────────────────────────┤
│      .rel.data          │  ← Relocation info cho .data
├─────────────────────────┤
│       .debug            │  ← Debug info (khi biên dịch với gcc -g)
├─────────────────────────┤
│  Section header table   │  ← Offset và kích thước từng section
└─────────────────────────┘

void swap() { … }     // định nghĩa symbol swap
swap();               // tham chiếu symbol swap
int *xp = &x;         // định nghĩa symbol xp, tham chiếu symbol x

// p1.c
int foo = 5;   // STRONG (đã khởi tạo)
void p1() {}   // STRONG (hàm)

// p2.c
int foo;       // WEAK (chưa khởi tạo)
void p2() {}   // STRONG (hàm)

// Trường hợp 1 – Lỗi (Rule 1: 2 strong symbol p1)
// p1.c: int x; void p1(){}
// p2.c: int x; void p1(){}   ← LỖI! p1 định nghĩa 2 lần

// Trường hợp 2 – Nguy hiểm ngầm (Rule 3)
// p1.c: int x; int y; void p1(){}
// p2.c: double x;    void p2(){}
// → x trong p1.c là int (4 bytes), x trong p2.c là double (8 bytes)
// → Ghi vào x ở p2 có thể tràn sang vùng nhớ của y! RẤT NGUY HIỂM!

// Trường hợp 3 – An toàn (Rule 2)
// p1.c: int x=7; int y=5; void p1(){}
// p2.c: double x;         void p2(){}
// → x trong p1 là strong → luôn tham chiếu đến x=7

// main.c
int buf[2] = {1, 2};
int main() {
    swap();
    return 0;
}

// swap.c
extern int buf[];
int *bufp0 = &buf[0];
int *bufp1;
void swap() {
    int temp;
    bufp1 = &buf[1];
    temp = *bufp0;
    *bufp0 = *bufp1;
    *bufp1 = temp;
}

// Module 1
int main() { ... }

// Module 2
int main;
int p2() { ... }

// Module 1
void main() { ... }

// Module 2
int main = 1;
int p2() { ... }

int f() {
    static int x = 0;  // local symbol x.1 trong .data
    return x;
}

int g() {
    static int x = 1;  // local symbol x.2 trong .data
    return x;
}

0000000000000000 <main>:
   0:  48 83 ec 08    sub  $0x8,%rsp
   4:  be 02 00 00 00 mov  $0x2,%esi
   9:  bf 00 00 00 00 mov  $0x0,%edi       # &array = 0x0 (chưa biết!)
                    a: R_X86_64_32 array   # Relocation entry: cần điền địa chỉ array
   e:  e8 00 00 00 00 callq 13 <main+0x13> # sum() = 0x0 (chưa biết!)
                    f: R_X86_64_PC32 sum-0x4 # Relocation entry: cần điền địa chỉ sum

00000000004004d0 <main>:
  4004d0:  48 83 ec 08    sub  $0x8,%rsp
  4004d4:  be 02 00 00 00 mov  $0x2,%esi
  4004d9:  bf 18 10 60 00 mov  $0x601018,%edi  # &array = 0x601018 ✓
  4004de:  e8 05 00 00 00 callq 4004e8 <sum>   # sum() tại 0x4004e8 ✓
  4004e3:  48 83 c4 08    add  $0x8,%rsp
  4004e7:  c3             retq

Địa chỉ cao
┌────────────────────────┐
│    Kernel virtual mem  │  ← Không thể truy cập từ user code
├────────────────────────┤
│    User stack          │  ← Tạo lúc runtime, %rsp trỏ vào đây
│    (tăng xuống dưới)   │
├────────────────────────┤
│    ...                 │
├────────────────────────┤
│  Memory-mapped region  │  ← Shared libraries (.so)
├────────────────────────┤
│    Run-time heap       │  ← malloc/free, tăng lên trên (brk)
├────────────────────────┤
│  Read/write segment    │  ← .data, .bss
├────────────────────────┤
│  Read-only segment     │  ← .init, .text, .rodata  (load từ file)
└────────────────────────┘  ← 0x400000
Địa chỉ thấp

# Biên dịch từng file thành .o
gcc -c addvec.c multvec.c

# Đóng gói thành archive
ar rs libvector.a addvec.o multvec.o

# Link chương trình với static library
gcc -o prog2c main2.c -L. -lvector

# Tạo shared library
gcc -shared -fPIC -o libvector.so addvec.c multvec.c

# Link chương trình (chỉ ghi thông tin, không nhúng code thật)
gcc -o prog2l main2.c -L. -lvector

#include <dlfcn.h>

// Mở shared library lúc runtime
void *handle = dlopen("./libvector.so", RTLD_LAZY);

// Lấy con trỏ hàm
void (*addvec)(int*, int*, int*, int) = dlsym(handle, "addvec");

// Gọi hàm như bình thường
addvec(x, y, z, 2);

// Đóng library khi xong
dlclose(handle);

// main.c
void fib(int n);          // khai báo ngoài
int main(int argc, char** argv) {
    int n = 0;
    fib(n);
}

// fib.c
#define N 16
static unsigned int ring[3][N];         // biến static toàn cục
static void print_bignat(unsigned int* a) { ... }  // hàm static
void fib(int n) { ... }                 // hàm public
int carry;                              // biến toàn cục chưa khởi tạo