第28讲：Linux系统HelloWorld（上）

① 编写C源文件
    └── main -> printf -> puts -> 串口驱动
② 使用IDE（Keil/ADS1.2）编译
    └── IDE封装了底层编译细节，一键编译
③ 烧录到芯片
    └── 常见芯片：STC89、STM32、S3C2440
    └── IDE中一键烧录
④ 运行程序

#include <stdio.h>
int main() {
    printf("hello world\n");
    return 0;
}

# 分步编译命令
gcc -E hello.c -o hello.i      # ①预处理
gcc -S hello.i -o hello.s      # ②编译
gcc -c hello.s -o hello.o      # ③汇编
gcc hello.o -o hello           # ④链接

# 方式1：生成 .i 文件后查看
gcc -E hello.c -o hello.i
wc -l hello.i          # 查看预处理后多少行（通常几百到几千行）
less hello.i           # 翻阅 .i 文件

# 方式2：直接输出到终端（管道分页）
gcc -E hello.c | less

#include <stdio.h>     # 尖括号：只搜索系统头文件目录
#include "myheader.h"  # 双引号：先搜当前目录，再搜系统目录

# 查看 C 头文件的默认搜索路径
gcc -xc -E -v - </dev/null 2>&1 | grep "^ "
# 典型输出包含：
#   /usr/include
#   /usr/local/include
#   /usr/lib/gcc/x86_64-linux-gnu/9/include

gcc -I ./include -I /path/to/headers hello.c -o hello

# 等价于在代码中写 #define DEBUG
gcc -DDEBUG hello.c -o hello

# 定义带值的宏
gcc -DBUFFER_SIZE=1024 hello.c -o hello

# 定义宏值为字符串
gcc -DVERSION=\"1.0.0\" hello.c -o hello

#ifdef DEBUG
    printf("Debug: x = %d\n", x);
#endif

# 调试版本
gcc -DDEBUG -g hello.c -o hello_debug

# 发布版本
gcc -O2 hello.c -o hello_release

# 生成汇编文件
gcc -S hello.i -o hello.s
# 或直接从 .c 生成
gcc -S hello.c -o hello.s

# 查看汇编代码
cat hello.s

    .section    .rodata
.LC0:
    .string "hello world"
    .text
    .globl  main
    .type   main, @function
main:
    pushq   %rbp
    movq    %rsp, %rbp
    leaq    .LC0(%rip), %rdi
    call    puts@PLT
    movl    $0, %eax
    popq    %rbp
    ret

# 对比不同优化级别的汇编输出
gcc -S -O0 hello.c -o hello_O0.s
gcc -S -O2 hello.c -o hello_O2.s
diff hello_O0.s hello_O2.s    # 对比差异

+---------------------+
|    ELF Header       |  魔数、架构、入口地址等基本信息
+---------------------+
|  Program Header     |  运行时需要的段信息（可执行文件才有）
|    Table            |
+---------------------+
|  .text (代码段)      |  编译后的机器指令
|  .rodata (只读数据)   |  字符串常量等
|  .data (已初始化数据)  |  已初始化的全局/静态变量
|  .bss (未初始化数据)   |  未初始化的全局变量（不占文件空间）
|  .symtab (符号表)    |  函数名、全局变量名等符号信息
|  .strtab (字符串表)   |  符号名称的字符串
|  .rel.text           |  代码段重定位信息
|  .rel.data           |  数据段重定位信息
+---------------------+
|  Section Header     |  节的描述信息
|    Table            |
+---------------------+

# 生成 .o 文件
gcc -c hello.s -o hello.o

# 反汇编 .o 文件，查看机器码和汇编的对应关系
objdump -d hello.o

# 查看全部信息（符号表、段信息等）
objdump -d -t -r hello.o

0000000000000000 <main>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   48 8d 3d 00 00 00 00    lea    0x0(%rip),%rdi
   b:   e8 00 00 00 00          callq  10 <main+0x10>
  10:   b8 00 00 00 00          mov    $0x0,%eax
  15:   5d                      pop    %rbp
  16:   c3                      retq

# 默认是动态链接
gcc hello.c -o hello

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

# 对比文件大小
ls -lh hello hello_static
# hello:        约 16KB
# hello_static: 约 800KB~2MB

file hello
# 输出: hello: ELF 64-bit LSB executable, x86-64, dynamically linked, ...
file hello.o
# 输出: hello.o: ELF 64-bit LSB relocatable, x86-64, ...

ldd hello
# 输出示例:
#   linux-vdso.so.1 (0x00007ffe3f3e1000)
#   libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8b3c000000)
#   /lib64/ld-linux-x86-64.so.2 (0x00007f8b3c200000)

readelf -d hello
# 输出包含:
#  NEEDED   libc.so.6          # 需要 libc.so.6
#  NEEDED   ld-linux-x86-64.so.2
#  ...

nm hello.o
# 输出示例:
#                  U _GLOBAL_OFFSET_TABLE_
# 0000000000000000 T main           # T = .text 段，已定义
#                  U printf         # U = Undefined，引用外部符号
#                  U puts           # GCC 可能将 printf 优化为 puts

nm hello | grep printf
# 链接后，printf 不再显示为 U（Undefined），因为已解析

objdump -d hello | grep -A 15 '<main>:'
# 对比 .o 阶段的反汇编，call 指令的操作数不再是 00 00 00 00
# 而是被重定位为 puts 的 PLT 入口地址

# 终端输入
./hello

pid_t pid = fork();
if (pid == 0) {
    // 子进程
} else if (pid > 0) {
    // 父进程
} else {
    // fork 失败
}

execve("/path/to/hello", argv, envp);
// 执行成功后不会返回（原进程已经被替换）
// 失败时返回 -1

1. Shell 读取用户输入 "./hello"
2. Shell 调用 fork() 创建子进程
3. 父进程（Shell）等待子进程结束（waitpid）
4. 子进程调用 execve("./hello", ...) 替换自身为 hello 程序
5. 内核开始加载并执行 hello（见第三部分）

execve()
  +-- sys_execve （系统调用入口）
        +-- do_execve
              +-- load_elf_binary （加载ELF文件）
                    |-- 从文件系统加载Hello程序到内存
                    |-- [分支1] 静态链接程序
                    |     +-- 直接执行 _start 入口
                    +-- [分支2] 动态链接程序
                          +-- 动态链接器加载库文件
                                +-- 建立程序与库的链接
                                      +-- 执行 _start 入口

      高地址
    +---------------+
    |    栈 (Stack)   |  <- 局部变量、函数调用帧。向低地址增长。
    |       v       |
    |       ...     |
    +---------------+
    |               |  <- 内存映射区域（mmap）：动态库 .so 文件映射在此
    |               |
    +---------------+
    |    堆 (Heap)    |  <- malloc 分配的内存。向高地址增长。
    |       ^       |
    +---------------+
    |   .bss 段      |  <- 未初始化的全局/静态变量（运行时清零）
    +---------------+
    |   .data 段     |  <- 已初始化的全局/静态变量
    +---------------+
    |   .text 段     |  <- 代码（机器指令），只读
    +---------------+
      低地址

  进程A的虚拟地址空间          物理内存              进程B的虚拟地址空间
  +--------------+          +--------+          +--------------+
  | 0x7fff... (栈)|  --->   | 物理页1 |  <---    | 0x7fff... (栈)|
  | 0x6000...(堆) |  --->   | 物理页2 |          | 0x6000...(堆) |
  | 0x4000...(.text)|  -->  | 物理页3 |  <---    | 0x4000...(.text)| (共享)
  |  ...         |          |  ...   |          |  ...         |
  +--------------+          +--------+          +--------------+

# 先让 hello 程序在后台运行（需要添加 sleep）
# 或者用 cat /proc/self/maps 查看当前命令的映射
cat /proc/self/maps

_start（链接器指定的程序入口）
  +-- __libc_start_main（初始化运行环境）
        |-- 设置栈、环境变量
        |-- 调用 atexit 注册的函数
        |-- 初始化线程本地存储（TLS）
        |-- 初始化信号处理
        |-- 初始化标准 I/O（stdin/stdout/stderr）
        +-- main(argc, argv, envp)  <- 用户程序入口
              +-- printf("hello world\n")
                    +-- exit(0) 或 return 0
                          |-- 调用 atexit 注册的清理函数
                          |-- 刷新并关闭所有 stdio 流（fflush）
                          |-- 调用 _exit 系统调用
                          +-- 内核回收进程资源

objdump -d /usr/lib/x86_64-linux-gnu/crt1.o | grep -A 10 '^<start>:'

exit(status)
  |-- atexit 注册的函数被逆序调用
  |-- stdio 缓冲区被刷新（fflush(NULL)）
  |-- 所有打开的流被关闭（fclose）
  |-- 临时文件被删除（tmpfile 创建的）
  +-- _exit(status) 系统调用
        |-- 内核关闭所有文件描述符
        |-- 释放所有内存映射
        |-- 向父进程发送 SIGCHLD 信号
        +-- 进程状态变为僵尸（zombie），等待父进程 wait

# 1. 创建 hello.c
cat > hello.c << 'EOF'
#include <stdio.h>
#define GREETING "hello world"
int main() {
    printf("%s\n", GREETING);
    return 0;
}
EOF

# 2. 预处理：观察宏展开和头文件包含
gcc -E hello.c -o hello.i
echo "预处理后行数："
wc -l hello.i
echo "文件末尾（你的 main 函数）："
tail -20 hello.i

# 3. 编译：生成汇编代码
gcc -S hello.i -o hello.s
echo "汇编代码："
cat hello.s

# 4. 汇编：生成目标文件
gcc -c hello.s -o hello.o

# 5. 链接：生成可执行文件
gcc hello.o -o hello

# 6. 运行
./hello

# file：确认文件类型
file hello
file hello.o

# ldd：查看动态库依赖
ldd hello

# readelf：查看 ELF 头部和段信息
readelf -h hello          # ELF 头部
readelf -S hello          # 段（Section）信息
readelf -l hello          # 程序头（运行时需要的段）
readelf -d hello          # 动态链接信息

# objdump：反汇编
objdump -d hello | head -50

# nm：符号表
nm hello.o                # 注意 printf 标记为 U（Undefined）
nm hello                  # 链接后 printf 不再是 U

# size：查看各段大小
size hello
size hello.o

# strings：提取可执行文件中的可打印字符串
strings hello | grep hello

# 动态链接（默认）
gcc hello.c -o hello_dynamic

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

# 对比文件大小
ls -lh hello_dynamic hello_static

# 对比符号数量
echo "动态链接符号数："
nm hello_dynamic | wc -l
echo "静态链接符号数："
nm hello_static | wc -l

# 检查动态链接文件依赖
echo "动态链接依赖："
ldd hello_dynamic
echo "静态链接依赖："
ldd hello_static          # 输出: not a dynamic executable

# 对比运行时的系统调用
echo "动态链接程序系统调用："
strace -c ./hello_dynamic 2>&1
echo "静态链接程序系统调用："
strace -c ./hello_static 2>&1

# 创建一个会在运行时暂停的程序
cat > hello_wait.c << 'EOF'
#include <stdio.h>
#include <unistd.h>
int main() {
    printf("PID: %d\n", getpid());
    printf("Press Enter to exit...\n");
    getchar();
    return 0;
}
EOF

gcc hello_wait.c -o hello_wait

# 在一个终端运行它
./hello_wait &
PID=$!

# 查看该进程的内存映射
cat /proc/$PID/maps

# 查看命令行
cat /proc/$PID/cmdline

# 清理
kill $PID 2>/dev/null