// 一个简单的程序 hello.c
#include <stdio.h>

int main() {
    printf("hello, world\n");
    return 0;
}

源代码 hello.c
    │
    ▼ [预处理器 cpp]
预处理文件 hello.cpp.c（文本）
    │
    ▼ [编译器 cc1]
汇编文件 hello.s（文本）
    │
    ▼ [汇编器 as]
可重定位目标文件 hello.o（二进制）
    │
    ▼ [链接器 ld]
可执行目标文件 hello（二进制）

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

/* main.c - 主程序 */
int sum(int a[], int n);

int array[2] = {1, 2};

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

ELF头（ELF Header）
├── 魔数：0x7F 'E' 'L' 'F'
├── 文件类别（可重定位/可执行/共享）
├── 机器类型（x86/x86-64/ARM等）
├── 入口点地址
└── 段头表偏移

节头表（Section Header Table）
├── .text    - 代码段
├── .rodata  - 只读数据段
├── .data    - 已初始化数据段
├── .bss     - 未初始化数据段
├── .symtab  - 符号表
├── .rel.text - 重定位信息
├── .strtab  - 字符串表
└── ...

# 查看所有节的信息
readelf -S hello.o

# 查看符号表
readelf -s hello.o

# 查看重定位信息
readelf -r hello.o

# 反汇编代码段
objdump -d hello.o

int global_var = 10;       // 全局符号，其他文件可用 extern 引用
void public_func(void) {}  // 全局符号

extern int external_var;         // 外部符号，在其他文件中定义
extern void external_func(void); // 外部符号

static int local_var = 5;        // 局部符号
static void local_func(void) {}  // 局部符号

/* 文件1 */
int x = 10;  // 强符号

/* 文件2 */
int x = 20;  // 强符号 → 链接错误：multiple definition of 'x'

/* 文件1 */
int x;  // 弱符号（未初始化）

/* 文件2 */
int x = 10;  // 强符号 → 选择文件2的定义，x = 10

/* 文件1 */
int x;  // 弱符号

/* 文件2 */
int x;  // 弱符号 → 选择占用空间最大的，这里都是4字节，取第一个

# 创建 addvec.c 和 multvec.c 的目标文件
gcc -c addvec.c multvec.c

# 将目标文件打包为静态库
ar rcs libvector.a addvec.o multvec.o

# 使用静态库链接程序
gcc -o main main.c ./libvector.a
# 或者使用 -L 和 -l 选项
gcc -o main main.c -L. -lvector

# 正确：libm 在依赖它的文件之后
gcc -o prog main.c -L. -lmylib -lm

# 错误：libm 在依赖它的文件之前，可能导致未解析的数学函数
gcc -o prog main.c -lm -L. -lmylib

typedef struct {
    long offset;      // 需要修改的位置的偏移
    long type:32;     // 重定位类型
    long symbol:32;   // 相关的符号表索引
    long addend;      // 常数加数
} Elf64_Rela;

/* main.c */
extern int sum(int[], int);
int array[2] = {1, 2};

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

call sum    # e8 00 00 00 00（地址尚未确定，使用占位值0）

0x0000000000400000 ┌─────────────────────┐
                   │      ELF头           │
                   ├─────────────────────┤
                   │    .text 段（代码）    │
                   ├─────────────────────┤
                   │   .rodata 段（只读）   │
                   ├─────────────────────┤
                   │    .data 段（已初始化） │
                   ├─────────────────────┤
                   │    .bss 段（未初始化）  │
                   ├─────────────────────┤
                   │    堆（向上增长）      │
                   │      ↑               │
                   │      │               │
                   │      ↓               │
                   │    栈（向下增长）      │
                   ├─────────────────────┤
                   │  内核虚拟内存映射     │
                   ├─────────────────────┤
0xFFFFFFFFFFFFFFFF └─────────────────────┘

/* 简化的 _start 函数伪代码 */
void _start(void) {
    __libc_start_main(main, argc, argv, ...);
}

# 创建位置无关代码的目标文件
gcc -c -fPIC addvec.c multvec.c

# 创建共享库
gcc -shared -o libvector.so addvec.o multvec.o

# 使用共享库链接程序
gcc -o main main.c -L. -lvector

# 运行时指定共享库搜索路径
LD_LIBRARY_PATH=. ./main

; 不使用PIC（绝对地址引用）
mov eax, [global_var]    ; 直接引用绝对地址

; 使用PIC（通过GOT间接引用）
mov rbx, [rbx + global_var@GOTPCREL]  ; 通过GOT间接引用
mov eax, [rbx]

; PLT条目
plt_func:
    jmp *GOT_entry      ; 第一次调用时跳转到解析器
    push index          ; 推送符号索引
    jmp plt_resolver    ; 跳转到动态链接器的解析函数

/* main.c */
#include <stdio.h>

void helper(void);

int main() {
    helper();
    return 0;
}

$ gcc -o main main.c
/tmp/ccXXXXXX.o: In function `main':
main.c:(.text+0x12): undefined reference to `helper'
collect2: error: ld returned 1 exit status

/* a.c */
int x = 10;

/* b.c */
int x = 20;

$ gcc a.c b.c
/tmp/ccXXXXXX.o:(.data+0x0): multiple definition of `x'

/* main.c */
extern void foo(void);
extern void bar(void);
int main() { foo(); bar(); return 0; }

/* foo.c */
extern void bar(void);
void foo(void) { bar(); }

/* bar.c */
void bar(void) { printf("bar\n"); }

# 错误：foo依赖bar，但libfoo在libbar之后扫描
$ gcc main.c -L. -lbar -lfoo
# foo中的bar引用未被解析

# 正确：被依赖的库放在后面
$ gcc main.c -L. -lfoo -lbar

$ objdump -h main.o

$ readelf -s main.o

# 查看归档文件的索引
ar t libvector.a
# 输出：
# addvec.o
# multvec.o

# 重建索引
ranlib libvector.a

# 查看程序依赖的共享库
ldd ./main

# 更新共享库缓存
sudo ldconfig

# 查看共享库的详细信息
readelf -d libvector.so

libvector.so      → 链接时使用的名称（符号链接）
libvector.so.1    → 主版本号（符号链接）
libvector.so.1.0  → 实际的库文件

高地址
┌──────────────────────────┐ 0xFFFFFFFFFFFFFFFF
│        内核空间           │
├──────────────────────────┤
│        栈               │ ← 向下增长
│         ↓               │
│                         │
│         ↑               │
│        堆               │ ← 向上增长
├──────────────────────────┤
│     共享库映射区          │
├──────────────────────────┤
│      .bss（未初始化数据）  │
├──────────────────────────┤
│      .data（已初始化数据） │
├──────────────────────────┤
│      .rodata（只读数据）   │
├──────────────────────────┤
│      .text（代码）        │
├──────────────────────────┤ 0x00400000（默认加载地址）
│      保留区域             │
└──────────────────────────┘ 0x0000000000000000
低地址

# 查看ASLR状态
cat /proc/sys/kernel/randomize_va_space

# 临时关闭ASLR（调试用）
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space

/* 正确做法 */
/* header.h */
extern int global_count;

/* main.c */
int global_count = 0;  // 唯一定义

/* other.c */
#include "header.h"    // 使用extern声明引用

重定位后的值 = S + A - P

# 查看目标文件的所有信息
objdump -a main.o

# 反汇编代码段
objdump -d main.o

# 显示所有节头
objdump -h main.o

# 显示完整的符号表
objdump -t main.o

# 显示重定位信息
objdump -r main.o

# 混合显示源代码和汇编
objdump -d -S main.o

# 显示ELF头
readelf -h main.o

# 显示所有节头
readelf -S main.o

# 显示符号表
readelf -s main.o

# 显示重定位信息
readelf -r main.o

# 显示动态段信息
readelf -d ./main

# 显示程序头（段信息）
readelf -l ./main

/usr/bin/ld: main.o: in function `main':
main.c:(.text+0x12): undefined reference to `calculate'

/usr/bin/ld: a.o:(.data+0x0): multiple definition of `x'; b.o:(.data+0x0): first defined here

/usr/bin/ld: cannot find -lmylib

# 1. 创建多个源文件的目标文件
gcc -c math_ops.c string_ops.c io_ops.c

# 2. 打包为静态库
ar rcs libmyutils.a math_ops.o string_ops.o io_ops.o

# 3. 查看库内容
ar t libmyutils.a

# 4. 使用库
gcc -o myapp main.c -L. -lmyutils

# 5. 查看库的符号
nm libmyutils.a

# 1. 创建位置无关代码
gcc -c -fPIC -Wall math_ops.c string_ops.c

# 2. 创建共享库
gcc -shared -o libmyutils.so math_ops.o string_ops.o

# 3. 查看共享库信息
readelf -d libmyutils.so
objdump -p libmyutils.so

# 4. 链接程序
gcc -o myapp main.c -L. -lmyutils

# 5. 运行程序（指定库搜索路径）
LD_LIBRARY_PATH=. ./myapp

# 6. 或者将库安装到系统路径
sudo cp libmyutils.so /usr/local/lib/
sudo ldconfig

# CMakeLists.txt 示例
cmake_minimum_required(VERSION 3.10)
project(MyProject)

# 创建库
add_library(myutils STATIC
    src/math_ops.c
    src/string_ops.c
)

# 链接库
add_executable(myapp src/main.c)
target_link_libraries(myapp myutils)

# 设置包含目录
target_include_directories(myutils PUBLIC include/)