第29讲：Linux系统HelloWorld（下）

# 将 hello.c 预处理为 hello.i
gcc -E hello.c -o hello.i -v

# 查看原始代码行数
wc -l hello.c
# 输出示例: 6 hello.c

# 查看预处理后行数
wc -l hello.i
# 输出示例: 842 hello.i

# linenum filename flags

# 1 "hello.c"       // 从 hello.c 第1行开始
# 1 "<built-in>"    // GCC 内置定义
# 1 "<command-line>"// 命令行定义
# 1 "/usr/include/stdio.h" 1 3 4  // 进入系统头文件
// ... stdio.h 的内容 ...
# 2 "hello.c" 2     // 返回 hello.c 第2行

// 预处理前
#define MAX 100
int arr[MAX];

// 预处理后
int arr[100];

# 带行标记（默认）
gcc -E hello.c -o hello_with_markers.i

# 去除行标记
gcc -E -P hello.c -o hello_clean.i

# 带行标记的预处理文件
head -5 hello_with_markers.i
# 输出:
# # 1 "hello.c"
# # 1 "<built-in>"
# ...

# 去除行标记的预处理文件
head -5 hello_clean.i
# 输出: 直接是代码内容，无 # 行标记

# 查看原始文件大小
ls -lh hello.c
# 输出示例: -rw-r--r-- 1 user user  85 Jul 22 10:00 hello.c

# 查看预处理后文件大小
ls -lh hello.i
# 输出示例: -rw-r--r-- 1 user user 23K Jul 22 10:01 hello.i

# 将 hello.i 编译为 hello.s（汇编文件）
gcc -S hello.i -o hello.s -v

#include <stdio.h>

int main(void) {
    printf("Hello, World!\n");
    return 0;
}

    .file   "hello.c"
    .text
    .section .rodata
.LC0:
    .string "Hello, World!"
    .text
    .globl  main
    .type   main, @function
main:
    pushq   %rbp              ; 保存栈帧指针
    movq    %rsp, %rbp        ; 设置新的栈帧
    leaq    .LC0(%rip), %rax  ; 加载字符串地址
    movq    %rax, %rdi        ; 第一个参数（字符串地址）
    call    puts@PLT          ; 调用 puts（gcc 优化 printf 为 puts）
    movl    $0, %eax          ; 返回值 0
    popq    %rbp              ; 恢复栈帧
    ret                       ; 返回
    .size   main, .-main

gcc -S -masm=intel hello.c -o hello_intel.s

    .file   "hello.c"
    .intel_syntax noprefix
    .text
    .section .rodata
.LC0:
    .string "Hello, World!"
    .text
    .globl  main
    .type   main, @function
main:
    push    rbp               ; 保存栈帧指针
    mov     rbp, rsp          ; 设置新的栈帧
    lea     rax, .LC0[rip]   ; 加载字符串地址
    mov     rdi, rax          ; 第一个参数
    call    puts@PLT
    mov     eax, 0            ; 返回值 0
    pop     rbp
    ret
    .size   main, .-main

# 生成不同优化级别的汇编文件
gcc -S -O0 hello.c -o hello_O0.s
gcc -S -O1 hello.c -o hello_O1.s
gcc -S -O2 hello.c -o hello_O2.s
gcc -S -O3 hello.c -o hello_O3.s

# 比较行数差异
wc -l hello_O*.s

# 以简单函数为例，不同优化级别的汇编对比
# -O0: 变量都在栈上，每次使用都从内存读写
# -O2: 变量优化到寄存器，减少内存访问
# -O3: 可能进行循环展开、函数内联等激进优化

# 将 hello.s 汇编为 hello.o（可重定位目标文件）
gcc -c hello.s -o hello.o -v

objdump -h hello.o

hello.o:     file format elf64-x86-64

Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         0000001e  0000000000000000  0000000000000000  00000040  2**0
                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
  1 .data         00000000  0000000000000000  0000000000000000  0000005e  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000000  0000000000000000  0000000000000000  0000005e  2**0
                  ALLOC
  3 .rodata       0000000d  0000000000000000  0000000000000000  0000005e  2**0
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  4 .comment      0000002c  0000000000000000  0000000000000000  0000006b  2**0
                  CONTENTS, READONLY
  5 .note.GNU-stack 00000000  0000000000000000  0000000000000000  00000097  2**0
                  CONTENTS, READONLY
  6 .eh_frame     00000038  0000000000000000  0000000000000000  00000098  2**3
                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, DATA

size hello.o

   text    data     bss     dec     hex filename
    169       0       0     169      a9 hello.o

nm hello.o

0000000000000000 T main
                 U puts

nm -n hello.o      # 按地址排序
nm -u hello.o      # 只显示未定义符号
nm -D /usr/lib/libc.so.6   # 显示共享库的动态符号

objdump -d hello.o

# 将 hello.o 链接为可执行文件 hello
gcc hello.o -o hello -v

ld --verbose

GNU ld (GNU Binutils) ...
  .text           :
  {
    *(.text.unlikely .text.*_unlikely .text.unlikely.*)
    *(.text.exit .text.exit.*)
    *(.text.startup .text.startup.*)
    *(.text.hot .text.hot.*)
    *(SORT_BY_NAME(.text.sorted.*))
    *(.text .stub .text.* .gnu.linkonce.t.*)
    ...
  }

# 直接用 ld 链接（需要手动指定所有库和启动文件）
ld -dynamic-linker /lib64/ld-linux-x86-64.so.2 \
   /usr/lib/x86_64-linux-gnu/crt1.o \
   /usr/lib/x86_64-linux-gnu/crti.o \
   hello.o \
   -lc \
   /usr/lib/x86_64-linux-gnu/crtn.o \
   -o hello

/usr/lib/gcc/x86_64-linux-gnu/11/collect2 \
  -plugin ...                          # LTO 插件
  -plugin-opt=...                      #
  -m elf_x86_64                        # 目标平台：ELF64 x86-64
  -dynamic-linker                      # 指定动态链接器路径
    /lib64/ld-linux-x86-64.so.2       #
  -o hello                             # 输出文件名
  /usr/lib/x86_64-linux-gnu/crt1.o    # 启动文件1
  /usr/lib/x86_64-linux-gnu/crti.o    # 启动文件2
  /usr/lib/gcc/x86_64-linux-gnu/11/crtbegin.o  # 构造/析构函数支持
  -L/usr/lib/gcc/x86_64-linux-gnu/11  # 库搜索路径
  -L/usr/lib/x86_64-linux-gnu         #
  hello.o                              # 用户的目标文件
  -lgcc                                # GCC 运行时库
  -lgcc_s                              # GCC 共享运行时库
  -lc                                  # 标准C库 (libc)
  -lgcc                                # 再次链接（解决循环依赖）
  -lgcc_s                              #
  /usr/lib/gcc/x86_64-linux-gnu/11/crtend.o    # 构造/析构结束
  /usr/lib/x86_64-linux-gnu/crtn.o    # 启动文件3

gcc hello.o -o hello -Wl,<ld-option>

gcc hello.o -o hello -Wl,-Map=output.map,-verbose

# 生成链接 map 文件（查看内存布局）
gcc hello.c -o hello -Wl,-Map=hello.map

# 查看 map 文件
less hello.map
# 包含：段的内存地址分配、符号地址、库文件列表等

# 指定链接脚本
gcc hello.c -o hello -Wl,-T,custom.ld

# 去除未使用的代码段（gc-sections）
gcc -ffunction-sections -fdata-sections hello.c \
    -o hello -Wl,--gc-sections

gcc hello.c -o hello -v

① cc1        → 预处理 + 编译   (hello.c → hello.s)
② as         → 汇编           (hello.s → hello.o)
③ collect2   → 链接           (hello.o + crt*.o → hello)

Target: x86_64-linux-gnu
Configured with: ../src/configure ...
Thread model: posix
Supported LTO compression algorithms: zlib zstd
gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04)

COLLECT_GCC_OPTIONS='-o' 'hello' '-v' '-mtune=generic' '-march=x86-64'

/usr/lib/gcc/x86_64-linux-gnu/11/cc1 -quiet -v -imultiarch x86_64-linux-gnu hello.c -quiet -dumpbase hello.c -dumpbase-ext .c -mtune=generic -march=x86-64 -version -o /tmp/ccXXXXXX.s

as -v --64 -o /tmp/ccXXXXXX.o /tmp/ccXXXXXX.s

/usr/lib/gcc/x86_64-linux-gnu/11/collect2 ... -o hello ...

# 动态链接（默认）
gcc hello.c -o hello
ls -lh hello
# -rwxr-xr-x 1 fire fire 8.2K ... hello

# 静态链接
gcc hello.c -o hello_static -static
ls -lh hello_static
# -rwxr-xr-x 1 fire fire 825K ... hello_static

ldd hello

linux-vdso.so.1 (0x00007ffd4b3f5000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8a4c000000)
/lib64/ld-linux-x86-64.so.2 (0x00007f8a4c3e0000)

readelf -l hello | grep interpreter
# 输出: [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]

# 临时添加自定义库搜索路径
export LD_LIBRARY_PATH=/home/user/mylibs:$LD_LIBRARY_PATH
./myprogram

# 查看缓存的库列表
ldconfig -p | grep libcurl

# 更新缓存（需要 root）
sudo ldconfig

gcc hello.c -o hello_static -static -v 2>&1 | grep "\.a"

ar t /usr/lib/x86_64-linux-gnu/libc.a | head -20
# 输出示例:
# init-first.o
# libc-start.o
# sysdep.o
# version.o
# ...

# 实际文件
libc.so.6           # 真正的库文件（或符号链接）
libc-2.35.so        # 带版本号的库文件

# 符号链接（编译时使用）
libc.so -> libc.so.6

# 编译为位置无关代码（Position Independent Code）
gcc -fPIC -c mylib.c -o mylib.o

# 创建共享库
gcc -shared -o libmylib.so mylib.o

# 使用共享库
gcc program.c -L. -lmylib -o program

# 运行时需要设置库搜索路径
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./program

_start:
    xorl    %ebp, %ebp        ; 标记最外层栈帧
    movq    %rdx, %r9         ; rtld_fini（动态链接器清理函数）
    popq    %rsi              ; argc
    movq    %rsp, %rdx        ; argv
    andq    $-16, %rsp        ; 对齐栈
    pushq   %rax              ; 占位
    pushq   %rsp              ; 栈地址

    ; __libc_csu_init: 初始化函数
    ; __libc_csu_fini: 清理函数
    movq    $__libc_csu_init, %r8
    movq    $__libc_csu_fini, %rcx
    movq    $main, %rdi       ; main 函数地址
    call    __libc_start_main

    hlt                       ; 永远不会执行到这里

crti.o     → _init 的序言
其他 .o   → 各个模块的初始化代码（构造函数）
crtn.o     → _init 的尾声

# 查找 Scrt1.o 位置
find /usr/lib -name "Scrt1.o" 2>/dev/null
# /usr/lib/x86_64-linux-gnu/Scrt1.o

内核 execve() 系统调用
    |
    v
动态链接器 (ld-linux.so) 或直接跳转（静态链接）
    |
    v
_start (crt1.o / Scrt1.o)
    |
    ├── 设置栈帧、对齐栈
    ├── 准备参数（argc, argv, environ）
    ├── 调用 __libc_csu_init (初始化全局变量、调用 C++ 构造函数)
    v
__libc_start_main (libc)
    |
    ├── 设置线程局部存储（TLS）
    ├── 设置栈保护（stack canary）
    ├── 注册 __libc_csu_fini (通过 atexit)
    ├── 调用 __libc_csu_init (再次确认初始化)
    ├── 调用 main(argc, argv, environ)
    |       |
    |       └── printf("Hello, World!\n")
    |       └── return 0
    |
    └── exit(main的返回值)
        |
        ├── 调用通过 atexit 注册的函数
        ├── 调用 C++ 全局析构函数
        ├── 刷新并关闭所有 stdio 流
        └── _exit() 系统调用 (进程终止)

# 方法1: readelf 查看 ELF 头中的入口点
readelf -h hello | grep Entry
# Entry point address: 0x401040

# 方法2: objdump 查看符号
objdump -t hello | grep _start
# 0000000000401040 g     F .text  000000000000002e _start

# 方法3: nm 查看
nm hello | grep _start
# 0000000000401040 T _start

# 创建测试程序
cat > hello.c << 'EOF'
#include <stdio.h>
int main(void) {
    printf("Hello, World!\n");
    return 0;
}
EOF

# 完整编译并查看详细信息
gcc hello.c -o hello -v 2>&1 | tee compile_verbose.log

# 关键观察点：
# 1. Target 配置
# 2. cc1 调用的参数（头文件搜索路径等）
# 3. as 调用的参数
# 4. collect2 调用的完整参数链（启动文件、库文件顺序）

#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/gcc/x86_64-linux-gnu/11/include
 /usr/local/include
 /usr/include/x86_64-linux-gnu
 /usr/include
End of search list.

# 第一步：预处理
gcc -E hello.c -o hello.i
echo "=== hello.i 行数和大小 ==="
wc -l hello.i
ls -lh hello.i
echo ""
echo "=== hello.i 前20行（观察行标记） ==="
head -20 hello.i

# 对比：去除行标记的预处理
gcc -E -P hello.c -o hello_clean.i
echo ""
echo "=== 去除行标记后前20行 ==="
head -20 hello_clean.i

# 第二步：编译（生成汇编）
gcc -S hello.i -o hello.s
echo ""
echo "=== hello.s 内容（AT&T 语法） ==="
cat hello.s

# Intel 语法对比
gcc -S -masm=intel hello.c -o hello_intel.s
echo ""
echo "=== hello_intel.s 内容（Intel 语法） ==="
cat hello_intel.s

# 第三步：汇编
gcc -c hello.s -o hello.o
echo ""
echo "=== hello.o 文件类型 ==="
file hello.o

# 第四步：链接
gcc hello.o -o hello
echo ""
echo "=== 可执行文件类型 ==="
file hello
./hello

# 动态链接
gcc hello.c -o hello_dynamic

# 静态链接
gcc hello.c -o hello_static -static

# 查看大小
echo "=== 文件大小对比 ==="
ls -lh hello_dynamic hello_static

# 查看段大小
echo ""
echo "=== 动态链接段大小 ==="
size hello_dynamic

echo ""
echo "=== 静态链接段大小 ==="
size hello_static

# 计算倍数
DYNAMIC_SIZE=$(stat -c%s hello_dynamic)
STATIC_SIZE=$(stat -c%s hello_static)
echo ""
echo "静态链接是动态链接的 $((STATIC_SIZE / DYNAMIC_SIZE)) 倍"

# 查看依赖
echo ""
echo "=== 动态链接依赖 ==="
ldd hello_dynamic

echo ""
echo "=== 静态链接依赖（应为 'not a dynamic executable'） ==="
ldd hello_static

# 4.1 查看 ELF 文件头
echo "=== ELF 文件头 ==="
readelf -h hello

# 4.2 查看节区头部
echo ""
echo "=== 节区头部列表 ==="
readelf -S hello

# 4.3 查看程序头（段信息）
echo ""
echo "=== 程序头 ==="
readelf -l hello

# 4.4 查看符号表
echo ""
echo "=== 符号表（前20个） ==="
readelf -s hello | head -20

# 4.5 查看动态段
echo ""
echo "=== 动态段（动态链接版本） ==="
readelf -d hello

# 4.6 objdump 反汇编 main 函数
echo ""
echo "=== main 函数反汇编 ==="
objdump -d hello | sed -n '/<main>:/,/^$/p'

# 4.7 objdump 查看段信息
echo ""
echo "=== 段信息 ==="
objdump -h hello

# 4.8 nm 查看符号
echo ""
echo "=== 符号扫描 ==="
nm hello | grep -E 'main|puts|printf|_start'

# 4.9 strings 查看嵌入字符串
echo ""
echo "=== 嵌入字符串 ==="
strings hello | grep -i hello

# 4.10 strip 去除符号表（减小文件体积）
cp hello hello_with_symbols
strip hello_with_symbols -o hello_stripped
echo ""
echo "=== strip 前后对比 ==="
ls -lh hello hello_stripped

# 查看动态链接器路径
echo "=== 程序的动态链接器 ==="
readelf -l hello | grep interpreter

# 查看动态链接库的搜索路径
echo ""
echo "=== 动态库搜索路径 ==="
ldconfig -v 2>/dev/null | head -30

# 查看 ldd 的详细输出
echo ""
echo "=== ldd 详细模式 ==="
ldd -v hello

# 模拟链接器行为：查看会加载哪些库
echo ""
echo "=== LD_DEBUG 追踪动态链接过程 ==="
LD_DEBUG=libs ./hello 2>&1 | head -50

# 创建一个稍复杂的测试函数
cat > test_opt.c << 'EOF'
#include <stdio.h>

int sum(int n) {
    int result = 0;
    for (int i = 1; i <= n; i++) {
        result += i;
    }
    return result;
}

int main(void) {
    printf("Sum: %d\n", sum(100));
    return 0;
}
EOF

# 生成不同优化级别的汇编
for level in 0 1 2 3 s; do
    gcc -S -O$level test_opt.c -o test_O$level.s
    echo "O$level: $(wc -l < test_O$level.s) lines"
done

# 重点对比 sum 函数的汇编
echo ""
echo "=== O0 的 sum 函数（无优化） ==="
sed -n '/sum:/,/\.cfi_endproc/p' test_O0.s

echo ""
echo "=== O2 的 sum 函数（标准优化） ==="
sed -n '/sum:/,/\.cfi_endproc/p' test_O2.s

echo ""
echo "=== O3 的 sum 函数（激进优化） ==="
sed -n '/sum:/,/\.cfi_endproc/p' test_O3.s

# 创建库源码
cat > mymath.c << 'EOF'
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
EOF

cat > mymath.h << 'EOF'
#ifndef MYMATH_H
#define MYMATH_H
int add(int a, int b);
int sub(int a, int b);
#endif
EOF

cat > use_math.c << 'EOF'
#include <stdio.h>
#include "mymath.h"
int main(void) {
    printf("1 + 2 = %d\n", add(1, 2));
    printf("5 - 3 = %d\n", sub(5, 3));
    return 0;
}
EOF

# 编译为共享库
gcc -fPIC -shared mymath.c -o libmymath.so

# 使用共享库编译程序
gcc use_math.c -L. -lmymath -o use_math

# 运行前设置库路径
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./use_math

# 对比静态链接
gcc use_math.c mymath.c -o use_math_static
echo ""
echo "=== 动态和静态大小对比 ==="
ls -lh use_math use_math_static