计算机系统大作业：程序人生——Hello‘s P2P

"Hello" 程序的生命周期始于C语言源代码（hello.c），首先经历P2P（Program to Process）的编译阶段：通过预处理（处理宏、头文件和条件编译生成.i文件）、编译（转换为汇编代码.s文件）、汇编（生成可重定位目标文件.o）和链接（合并库文件生成可执行文件hello）；随后进入O2O（Zero to Zero）的执行阶段：由Shell通过fork()创建子进程并调用execve()加载hello程序，建立虚拟内存映射（段页式管理、TLB加速地址转换），最终通过系统调用（如write()）实现IO交互，程序结束后由内核回收资源，完成从源码到进程再到终止的全生命周期。

P2P（编译阶段）：

预处理阶段：预处理器执行宏展开（如#define替换）、头文件包含（递归处理#include指令）和条件编译（处理#ifdef等指令），生成扩展后的.i中间文件。此阶段会添加行标记（#line）供调试使用，并删除所有注释。

编译阶段：编译器进行词法/语法分析（生成AST）、语义检查（类型校验）和优化（如常量传播），将高级语言转换为平台相关的汇编代码.s文件。现代编译器如GCC会在此阶段应用SSA优化和循环展开。

汇编阶段：汇编器解析指令助记符（如mov）、处理伪指令（如.data段），生成包含重定位信息的.o目标文件。ELF格式文件中会包含.text代码段、.data数据段和符号表（全局变量/函数地址）。

链接阶段：链接器进行符号解析（匹配声明与定义）和重定位（修正偏移地址），包括静态链接（合并.lib/.a库）和动态链接（生成PLT/GOT表）。最终生成的可执行文件会包含程序头（描述段加载信息）和入口点（_start）。

O2O（执行阶段）：

进程创建：Shell通过fork()系统调用创建子进程，采用写时复制（COW）技术复制父进程的页表。内核会分配新的PID，并初始化task_struct结构体维护进程状态。

程序加载：execve()系统调用触发ELF加载器，解析程序头表（Program Header）建立内存映射。.text段设为只读可执行（开启NX位），.data段设为可读写。动态链接器（ld.so）会处理共享库依赖。

内存管理：MMU通过多级页表（x86-64采用4级页表）转换虚拟地址，TLB缓存最近访问的页表项。发生缺页时触发Page Fault，内核可能执行按需分页（Demand Paging）或写时复制处理。SMAP机制保护内核空间不被用户程序访问。

IO交互：write()系统调用陷入内核后，VFS层通过文件描述符找到对应的file_operations结构体。字符设备驱动最终调用uart_write()等硬件操作，期间可能经过行缓冲（Line Discipline）处理。现代设备可能通过DMA直接传输数据。

1.2 环境与工具

硬件环境：12th Gen Intel(R) Core(TM) i7-12700H 2.30 GHz，RAM 16.0 GB

软件环境：Windows 11 64位；Ubuntu 20.04 LTS 64；

开发工具：GCC，vscode，GDB，objdump

1.3 中间结果

文件名称	作用描述	补充说明
hello.c	hello 程序的 C 语言源代码文件，包含程序逻辑和函数定义。	通常包含 #include 头文件、main() 函数等，是编译的起点。
hello.i	由 hello.c 预处理生成的文本文件，包含宏展开、头文件插入和条件编译处理后的代码。	可通过 gcc -E hello.c -o hello.i 生成，用于检查预处理结果（如宏替换是否正确）。
hello.s	由 hello.i 编译生成的汇编语言文件，包含平台相关的汇编指令。	通过 gcc -S hello.i -o hello.s 生成，可手动优化汇编代码或分析编译器优化策略（如 -O2 优化效果）。
hello.o	由 hello.s 汇编生成的可重定位目标文件，包含机器码和符号表。	采用 ELF 格式，尚未完成最终地址分配，需链接器处理。可通过 objdump -d hello.o 查看机器码和符号信息。
elf.txt	使用 readelf 工具生成的 hello.o 的 ELF 格式解析文件，描述节区头、符号表等元数据。	包含 .text（代码段）、.data（数据段）、.symtab（符号表）等详细信息，用于分析目标文件结构。
hello	由 hello.o 链接生成的可执行目标文件，包含完整的程序代码、库函数和运行时信息。	通过 gcc hello.o -o hello 生成，动态链接时依赖 ld.so 加载共享库（如 libc.so）。
hello1.elf	使用 readelf 工具生成的 hello 可执行文件的 ELF 解析文件，描述程序头、动态链接信息等。	包含程序入口地址（Entry point）、段加载信息（LOAD）、动态库依赖（.dynamic 节）等，用于分析可执行文件布局。
hello.dis	包含 hello 可执行文件的反汇编代码，用于逆向分析或调试。	通过 objdump -d hello > hello.dis 生成，可结合 -j .text 指定节区，分析函数调用逻辑或编译器优化后的指令流。

1.4 本章小结

本章通过分析"Hello"程序的生命周期，系统阐述了从源代码到进程执行的完整转换过程（P2P）以及从程序加载到运行终止的完整执行过程（O2O）。研究涵盖了程序运行所需的软硬件支持体系，完整记录了编译过程中生成的中间文件及其功能说明。

第2章预处理

2.1 预处理的概念与作用

预处理是编译流程的初始阶段，由预处理器处理源代码中以#开头的指令（如宏定义、文件包含和条件编译），通过文本替换、代码插入和条件筛选生成扩展后的中间文件（.i），为后续编译提供标准化输入。该阶段不涉及语法分析，仅完成代码文本的转换和整理。

2.2在Ubuntu下预处理的命令

gcc -m64 -no-pie -fno-PIC -E hello.c -o hello.i

图2.2 预处理命令及预处理后文件列表展示

2.3 Hello的预处理结果解析

在预处理阶段，预处理器（cpp）对源代码中以#开头的指令进行解析和处理。对于标准库头文件<stdio.h>、<unistd.h>和<stdlib.h>，cpp会通过Linux系统的环境变量定位这些文件，并将其内容直接插入到源文件中。由于这些头文件内部可能包含嵌套的#include指令、宏定义（如#define）和条件编译（如#ifdef`），预处理器会递归展开所有嵌套内容，最终生成的.i文件中不再保留原始的#define等指令，仅保留展开后的实际代码。注释被完全删除，预处理后的.i文件体积显著增大，因为头文件内容被逐层展开。这一阶段的输出是纯文本文件，可直接用于后续的编译阶段。

图2.3 Hello的预处理结果解析

2.4 本章小结

本章详细说明了预处理的核心作用，并通过具体示例展示了预处理过程：使用gcc命令`gcc -m64 -no-pie -fno-PIC -E hello.c -o hello.i`对源文件进行预处理，其中预处理器(cpp)会解析hello.c中的所有预处理指令，特别是将#include指定的系统头文件（如stdio.h等）内容完整插入源代码，同时展开所有宏定义并移除注释，最终生成经过纯文本处理的中间文件hello.i，该文件保留了完整的C语言语法结构但不再包含任何预处理指令，为后续编译阶段做好准备。

第3章编译

3.1 编译的概念与作用

编译阶段将预处理后的.i文件转换为汇编代码(.s文件)，编译器依次执行词法分析（识别token）、语法分析（构建AST）、语义分析（类型检查）和代码优化（如指令调度），将高级编程语言（如 C、C++）编写的源代码转换为与目标架构匹配的低级机器语言（汇编或机器码）。该过程保留符号信息供后续链接使用，同时应用平台特定的ABI规范和指令集优化。

3.2 在Ubuntu下编译的命令

gcc -m64 -no-pie -fno-PIC -S hello.i -o hello.s

图3.2 编译命令以及编译后文件列表展示

3.3 Hello的编译结果解析

图3.3 Hello的编译结果

3.3.1 数据存储与访问机制

1.常量处理

整型常量：如循环计数器初始化i=0，编译器直接生成movl $0, -4(%rbp)指令将立即数0存入栈帧。

图3.3.1.1.1 立即数0存入栈帧

比较操作i<10被优化为i≤9。

图3.3.1.1.2 i≤9的反汇编代码

字符串常量：如格式字符串"Hello %s %s %s\n"存储在.rodata段，通过lea .LC0(%rip), %rdi指令引用其地址。错误提示字符串则直接嵌入调用printf的指令中。

图3.3.1.1.3 字符串

2.变量存储

局部变量：argc和i存储在栈中，分别通过-20(%rbp)和-4(%rbp)偏移量访问。

图3.3.1.2.1 argc存储在栈中

i是4字节整型局部变量。

图3.3.1.2.2 i存储在栈中

3.3.2 运算符的汇编映射

赋值操作 i=0对应movl $0, -4(%rbp)，体现直接栈操作。

图3.3.2.1 赋值操作

指针赋值如argv[4]通过以下方式实现参数传递（见下图黄框）。

图3.3.2.2 指针赋值

算术运算 i++编译为addl $1, -4(%rbp)。

图3.3.2.3 算术运算

atoi(argv[4])的字符串转整型调用atoi。

图3.3.2.4 字符串转整型调用atoi

关系运算 argc!=5生成cmpl $5, -20(%rbp)，利用标志寄存器ZF判断跳转。循环条件i<10优化为i<=9的比较，比较栈上的 i（-4(%rbp)）和立即数 9。

图3.3.2.5 关系运算

3.3.3 控制流实现

分支结构 if(argc!=5)转换为je跳转至错误处理模块，否则顺序执行循环体。编译器通过调整跳转目标地址（如.L2）实现逻辑分流。

图3.3.3.1 分支结构

循环结构 for循环被拆解为：

初始化：movl $0, -4(%rbp)

图3.3.3.2 循环结构

条件检查：cmpl $9, -4(%rbp); jle .L4

图3.3.3.2 条件检查

增量步：addl $1, -4(%rbp) 形成典型的"条件-跳转-增量"三段式结构。

图3.3.3.3 增量步

3.3.4 函数调用规范

参数传递 printf调用遵循System V ABI：

格式字符串地址存入%edi；argv[1]~[3]依次存入%rsi, %rdx, %rcx；movl $0, %eax表明无浮点参数。

图3.3.4.1 printf调用

系统调用 sleep(atoi(argv[4]))的处理流程：

argv[4]字符串通过%rdi传递至atoi，返回值经%eax转存至%edi作为sleep参数。

图3.3.4.2 sleep调用

3.3.5 内存管理

栈帧管理：函数入口pushq %rbp保存基址指针，subq $32, %rsp分配局部变量空间，体现典型的栈内存分配模式。

图3.3.5 栈内存分配

3.4 本章小结

本章深入解析了从预处理文件hello.i到汇编文件hello.s的转换过程，系统阐述了编译器进行词法分析、语法分析、语义检查和代码优化的完整流程。通过对hello.s中数据类型（整型、浮点型、字符型等）和操作指令（算术运算、逻辑运算、数据传输等）的详细解读，揭示了高级语言到汇编语言的映射关系。这一转换过程既保留了高级语言的逻辑结构，又实现了对机器指令的精确控制。

第4章汇编

4.1 汇编的概念与作用

汇编是将汇编代码(.s)转换为机器码(.o)的关键步骤，汇编器将助记符指令逐条翻译为二进制机器码，同时生成包含符号表、重定位信息等元数据的ELF格式目标文件，为后续链接阶段做好准备。

其核心作用包括：通过汇编器将助记符指令（如mov、add）精确翻译为二进制机器码；生成包含符号表和重定位信息的ELF格式目标文件，支持多模块链接；进行基础指令优化（如消除冗余指令）和语法校验。该过程既保留了汇编层的可读性（通过.s文件），又实现了机器级的可执行性（生成.o文件），为链接阶段提供标准化输入。

4.2 在Ubuntu下汇编的命令

gcc -m64 -no-pie -fno-PIC -c hello.s -o hello.o

图4.2 在Ubuntu下汇编的命令以及文件列表

4.3 可重定位目标elf格式

4.3.1 ELF文件头结构

ELF文件起始部分包含固定格式的头部信息，用于描述文件的基本特征：

文件类型标识：指明是可执行文件、共享库或目标文件

平台架构信息：记录目标机器架构（如x86-64）

元数据定位：包含程序头表和节头表的起始位置、条目大小及数量

版本控制：标识ELF格式版本号

图4.3.1 elf头

4.3.2 节区头表解析

节区头表作为ELF文件的目录结构，包含以下关键信息：

节区映射：记录各节区在文件中的偏移量和大小

内存属性：定义节区加载时的读写执行权限

特殊节区：

.text：存储机器指令

.data：已初始化全局变量

.rodata：只读数据（如格式字符串）

.bss：未初始化数据区

图4.3.2 节头部表

4.3.3 重定位信息分析

重定位节区记录需要链接时修正的地址引用：

.rel.text：标记.text节中需要重定位的函数调用

外部函数引用：printf、exit等库函数

相对地址修正：循环跳转目标

.rel.data：处理全局变量的跨模块引用

数据地址重定位：如字符串常量指针

图4.3.3 rel.text和.rel.data

4.3.4 符号表结构详解

.symtab节区存储程序的符号信息，包含名称索引（指向字符串表的偏移），值（符号在节区内的偏移地址），大小（符号占用空间），函数符号，数据对象，节区引用，源文件信息，局部符号，全局可见符号。

图4.3.4 符号表

4.4 Hello.o的结果解析

反汇编结果如下：

图4.4.1 反汇编结果

图4.4.2反汇编结果

hello.s：

图4.3.3 hello.s

图4.3.4 hello.s

图4.3.5 hello.s

汇编文件中的movl $0, -4(%rbp)指令经过汇编器处理后，在反汇编结果中显示为机器码c7 45 fc 00 00 00 00，这实际上是该指令的二进制编码以十六进制形式呈现的结果。这种转换体现了从人类可读的助记符到机器可执行代码的映射关系。

在控制流处理方面，汇编文件使用.L2等符号标签标记跳转目标，这是为了方便程序员阅读和维护代码。而反汇编结果显示的是经过计算后的具体偏移量（如0e），反映了指令在内存中的实际布局。这种差异源于汇编器在生成目标文件时需要将符号地址解析为具体的数值。

对于函数调用，汇编文件中保留call printf这样的符号名称，使得代码更易理解。但在反汇编结果中，这些调用地址被替换为基于当前PC值的占位符，这是因为外部函数的实际地址需要在链接阶段才能确定。这种处理方式是可重定位目标文件的典型特征。

操作数的表示形式也存在明显差异。汇编文件中使用十进制立即数更符合人类阅读习惯，而反汇编结果则统一采用十六进制表示，这是为了准确反映指令的二进制编码形式。这种转换是编译器将高级语言常量转换为机器指令的必经步骤。

4.5 本章小结

本章系统分析了程序从汇编到可执行的完整转换过程：首先通过逆向分析hello.s与hello.c的对应关系，阐明高级语言到汇编指令的转换机制；其次解析hello.s生成的ELF文件结构，包括文件头和节区等关键信息；然后对比hello.s与hello.o的反汇编代码，详细说明汇编指令与机器码的对应关系；最后通过链接过程将hello.o转换为可执行文件，实现从源代码到可运行程序的完整转换。整个过程展现了程序从高级语言到底层机器码的完整编译流程。

第5章链接

5.1 链接的概念与作用

从 hello.o 目标文件生成 hello 可执行文件的链接过程，是将已编译的机器代码（hello.o）与系统标准库、用户自定义库以及其他关联的目标文件进行整合，通过符号解析（解决未定义引用）、地址重定位（分配运行时内存地址）以及节区合并等操作，最终生成符合操作系统格式要求（如ELF、PE）且可直接加载执行的二进制程序。该过程还涉及静态/动态链接的选择、调试信息的保留以及可选的代码优化等处理环节。

链接器的主要功能包括以下几个方面：

符号解析与绑定：在hello.o这样的目标文件中，存在对外部函数或变量的引用。链接器会将这些未定义的符号与标准库或其他目标文件中的实际定义进行匹配，并确定它们在内存中的最终地址，确保程序能够正确调用这些功能。

地址重定位：目标文件中的代码和数据通常使用相对地址或临时地址。链接器会根据最终可执行文件的内存布局，将这些相对地址转换为绝对地址，使程序在运行时能准确访问指令和数据。

段合并与内存布局：链接器会将不同目标文件中的同类段进行合并，并确定它们在可执行文件中的最终位置和大小，从而构建出完整的内存布局。

库函数整合：链接器会从库中提取所需的函数代码，并将其合并到最终的可执行文件中，避免开发者重复实现基础功能。这样，链接器最终生成一个完整的可执行文件，确保程序能正确运行。

5.2 在Ubuntu下链接的命令

ld -o hello -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 /usr/lib/x86_64-linux-gnu/libc.so /usr/lib/x86_64-linux-gnu/crtn.o

图5.2 在Ubuntu下链接的命令

5.3 可执行目标文件hello的格式

ELF头部分虽然保留了基本信息，但增加了程序入口点地址这个关键字段，指明了程序开始执行的第一条指令位置。同时，可执行文件中新增了程序头表，这个重要结构描述了文件内容如何映射到内存中。

图5.3.1 elf头部

链接过程中，原本分散在各个目标文件中的节被重新组织合并。比如所有.text节合并成代码段，.data和.bss节合并成数据段。这种合并不仅优化了空间利用率，更重要的是为每个符号确定了最终的内存地址。

图5.3.2 链接重定位

通过readelf工具查看节头表，可以看到每个节都有了明确的内存地址和大小信息，这与目标文件中仅包含偏移量的情况形成鲜明对比。

图5.3.3 节头表

图5.3.4 节头表

图5.3.5 节头表

程序头表详细描述了代码段和数据段的内存映射关系。代码段通常从0x00400000开始，具有可读可执行权限；数据段则具有可读可写权限。动态链接信息也记录在这里，指导运行时加载所需的共享库。通过pmap命令可以观察到进程实际的虚拟地址空间布局，验证了这些段确实按照程序头表的描述被映射到内存中。

图5.3.6 程序头表

图5.3.7 程序头表

在符号解析完成后，原先未定义的符号如printf、sleep等都被解析为动态库中的具体实现。值得注意的是，可执行文件中的重定位信息与目标文件中的有很大不同，这是链接器完成地址修正后的结果。通过对比链接前后的符号表，可以观察到符号类型和地址的变化过程.

图5.3.8 符号表

图5.3.9 符号表

5.4 hello的虚拟地址空间

使用edb调试器加载hello程序后，可以清晰地观察到进程的虚拟地址空间布局。通过pmap命令或edb的内存映射视图，可以看到代码段从0x00400000开始，具有r-xp（可读可执行私有）权限，这与程序头表中声明的LOAD段属性完全一致。数据段紧随代码段之后，权限为rw-p（可读写私有），用于存储全局变量和静态数据。通过对比5.3节中的程序头表描述，可以验证内核加载ELF时严格遵循了文件中的内存映射规范。

堆空间在运行时动态扩展，其地址高于数据段；而栈空间则向低地址方向增长，这种对立布局有效避免了内存冲突。环境变量和命令行参数存储在栈区的高端地址处。

图5.4 hello的虚拟地址空间

5.5 链接的重定位过程分析

通过objdump -dr对比hello.o与hello的反汇编结果，可以直观看到链接器完成的关键修改。在目标文件中，call printf被编译为e8 00 00 00 00的占位指令，后跟R_X86_64_PLT32重定位项；而在可执行文件中，该指令被替换为e8 cb fe ff ff，直接跳转到PLT表中的printf条目（0x4010a0）。

图5.5.1 call printf

重定位过程分为两个层面：

内部引用修正：如循环跳转指令jle .L4从相对偏移占位符变为具体值，这是通过计算.text段内符号的相对位置实现的。

图5.5.2 内部引用修正

外部引用绑定：动态库函数通过PLT/GOT机制延迟绑定。首次调用时，GOT表项指向PLT的解析逻辑；后续调用则直接跳转至库函数。

图5.5.3 外部引用绑定

5.6 hello的执行流程

通过调试工具跟踪hello程序的运行过程，可以清晰地看到程序从启动到退出的完整执行路径。程序启动后，首先进入0x4010f0地址处的_start函数，这是所有ELF程序的统一入口点。该函数完成基本的初始化工作后，会调用__libc_start_main函数来设置运行环境。

在初始化阶段，程序执行了两个关键操作：首先调用0x401120处的_dl_relocate_static_pie函数处理地址空间随机化（ASLR）相关事宜，这个安全特性使得程序每次加载时的内存布局都会发生变化；随后执行0x4011c0地址的__libc_csu_init函数，完成全局构造器的调用。

程序的核心逻辑位于0x401125处的main函数。这里首先检查命令行参数数量，如果不符合要求（argc!=5）就输出提示信息并调用0x4010d0处的exit@plt终止程序。当参数正确时，程序进入循环结构，反复调用0x4010a0处的printf@plt输出信息，并通过0x4010e0处的sleep@plt实现延时控制。用户输入则通过0x4010b0处的getchar@plt函数获取。

程序终止阶段，依次执行0x401230地址的__libc_csu_fini函数和0x401238处的_fini函数。这些函数负责调用全局析构器，释放资源，最终完成程序的优雅退出。特别值得注意的是，所有涉及库函数的调用都通过对应的PLT（过程链接表）条目实现，例如printf@plt、sleep@plt等，这是动态链接机制的关键实现方式。

程序名	程序地址
_start	0x4010f0
_libc_start_main	0x2f12271d
main	0x401125
_printf	0x4010a0
_sleep	0x4010e0
_getchar	0x4010b0
_exit	0x4010d0

图5.6 hello的执行流程

5.7 Hello的动态链接分析

通过edb查看.got.plt段（0x403ff0），初始状态所有表项均为0。

图5.7.1

动态链接的关键阶段包括：

初始化前：GOT表项指向PLT解析代码,x/gx 0x403ff0显示全零.

图5.7.2

_init调用后：

图5.7.3 init调用后got

程序在链接过程中采用了不同的地址修正策略来处理不同类型的符号引用。对于程序中定义的变量和函数，链接器利用代码段和数据段在内存中的固定相对位置来计算最终地址。这种基于相对偏移的定位方式，使得程序在加载到不同内存地址时仍能保持正确的引用关系。

而对于标准库函数的调用，则采用了更为复杂的动态链接机制。程序中的过程链接表（PLT）包含了一系列特殊的跳转指令。在初始状态下，这些指令会跳转到全局偏移量表（GOT）中预设的地址，这个地址指向的是动态链接器的解析例程。当第一次调用某个库函数时，动态链接器会介入工作，找到该函数在内存中的实际地址，并将这个地址回填到GOT的对应表项中。

这样设计的巧妙之处在于，后续对该库函数的调用就可以直接通过PLT跳转到正确的函数入口，无需再次经过动态链接器的解析过程。这种延迟绑定（lazy binding）机制既保证了程序的启动速度，又实现了库函数的动态加载。整个过程对程序员完全透明，只需要按照常规方式调用函数即可，所有的重定位工作都由链接器和加载器自动完成。

5.8 本章小结

本章深入探讨了程序链接的核心机制及其实现原理。链接作为程序构建的关键环节，主要负责将多个编译生成的目标文件与所需的库文件整合为最终的可执行程序。在这个过程中，链接器需要解决不同模块间的符号引用问题，确保程序能够作为一个完整的整体运行。

通过分析ELF文件格式的具体实现，我们可以清楚地看到链接器如何处理代码段、数据段等不同部分的合并与重组。链接器会按照既定的规则对各个目标文件中的代码和数据段进行重新排布，同时完成符号解析和地址重定位等核心操作。这些操作直接影响了程序在内存中的布局方式，以及各个函数和变量最终的访问地址。

动态链接机制的实现展现了现代操作系统的精巧设计。通过PLT和GOT的配合，程序能够在运行时动态加载所需的共享库函数。这种延迟绑定的策略既保证了程序启动的效率，又实现了库函数的灵活加载。整个过程对开发者完全透明，使得程序能够在不重新编译的情况下使用不同版本的库函数。

第6章 hello进程管理

6.1 进程的概念与作用

概念：进程是操作系统进行资源分配和调度的基本单位，代表一个正在执行的程序实例。它不仅包含程序代码和数据，还涉及运行时所需的堆栈、寄存器状态、打开的文件等资源，并由操作系统通过进程控制块（PCB）来管理和维护其执行状态。

作用：进程为程序运行提供了一个独立的执行环境，使得每个程序在运行时都仿佛独占整个计算机资源。

虚拟化CPU：进程通过时间片轮转等调度机制，让用户感觉程序在连续、无间断地执行，而实际上 CPU 是在多个进程间快速切换。

虚拟化内存：每个进程都拥有自己的地址空间，使得程序在运行时似乎独占了系统的全部内存，而操作系统实际通过内存管理机制（如分页、分段）隔离和保护不同进程的内存空间。

资源抽象：进程隐藏了底层硬件和资源的共享细节，让开发者只需关注程序本身的逻辑，无需直接处理多任务竞争的问题。通过进程机制，操作系统实现了多任务的并行执行，提高了资源利用率，同时确保了程序运行的隔离性和安全性。

6.2 简述壳Shell-bash的作用与处理流程

作用：Shell 作为用户与操作系统之间的桥梁，主要功能包括：

程序调用与数据传递：能够解析并执行用户输入的命令，向目标程序传递参数，并获取其执行结果。

数据流管道：支持通过管道或重定向等方式，将一个程序的输出作为另一个程序的输入，实现多程序协作的复杂数据处理流程。

可被调用的自动化工具：Shell 脚本本身可作为可执行对象，由其他程序或定时任务触发，满足批量处理、自动化运维等需求。

处理流程：

等待输入： Shell 在终端显示提示符，进入交互式等待状态，实时监听用户入的命令。
命令解析：对输入的命令行进行词法分析，拆解为命令名和参数列表，并构建成execve()所需的参数数组（argv）。处理特殊符号（如管道、重定向），预先规划数据流方向。
内置命令判断：若命令是 Shell 内置功能，则直接在当前 Shell 进程中执行，无需创建子进程。
创建子进程：对于外部程序命令，通过fork()复制当前 Shell 进程生成子进程，子进程继承父进程的环境变量和文件描述符。
执行目标程序：子进程调用execve()加载目标程序代码，替换自身内存空间，并传入解析好的参数执行。若命令包含管道或重定向，子进程会先调整标准输入/输出流后再执行程序。
作业控制：前台作业（无&后缀）则Shell 调用waitpid()阻塞自身，等待子进程执行完毕后再恢复提示符，确保用户与作业同步交互。后台作业（以&结尾）则 Shell 不等待子进程结束，立即返回提示符继续接收新命令，子进程在后台异步运行（通过SIGCHLD信号通知父进程其状态变化）。

6.3 Hello的fork进程创建过程

当用户在Shell中输入hello命令后，Shell（父进程）发现这不是内置命令，便通过fork()系统调用创建子进程。子进程会获得父进程用户空间的一个独立副本，包含代码段、数据段、堆、共享库和用户栈等，但采用写时复制机制优化性能。子进程会继承父进程打开的所有文件描述符，使得二者都能操作相同的文件资源。父子进程最本质的区别在于它们拥有不同的进程ID（PID）。fork()调用在父进程中返回子进程的PID，而在子进程中返回0，这个差异让二者能执行不同逻辑。虽然子进程从fork()返回处开始执行，与父进程共享相同的执行起点，但后续可以通过检查返回值来区分身份并执行不同操作。整个过程体现了操作系统高效管理进程的能力，既保证了进程间的独立性，又通过资源共享机制提升了性能。

6.4 Hello的execve过程

当执行execve时，系统会先验证目标文件的可执行权限和ELF格式。随后，当前进程的原有内存布局（包括代码、数据和堆栈）会被完全清除，替换为hello程序的代码段（.text）和初始化数据（.data/.bss）。内核会重新构建用户态堆栈，将命令行参数和环境变量按规范压入栈中，并重置所有寄存器状态。值得注意的是，虽然程序内容被彻底替换，但进程的PID和已打开的文件描述符（除非显式设置FD_CLOEXEC）仍然保留。若加载成功，进程将从hello的main函数开始全新执行；失败则返回错误码并保持原状态。整个过程通过高效的内存映射机制实现，在保持进程外壳不变的情况下，完成了程序内容的"脱胎换骨"。这种设计既确保了进程资源的合理继承，又实现了程序切换的原子性操作。

6.5 Hello的进程执行

进程调度是操作系统在多任务环境下分配CPU资源的核心机制，主要通过时间片轮转和优先级策略实现。其本质是在就绪进程间高效切换CPU控制权，包含几个关键环节：

当进程的时间片（如10ms）耗尽时，时钟中断会触发调度器介入。此时系统首先会保存当前进程的完整执行现场：不仅包括用户态的寄存器状态（如通用寄存器和指令指针），更重要的是将进程控制块（PCB）中的内存映射、文件描述表等核心信息存入内核数据结构。这相当于给进程拍了个"快照"。

调度器随后会根据既定策略（如CFS公平调度算法）从就绪队列精选下一个执行进程。选择时需综合评估进程优先级、历史运行时间等因素，同时校验目标进程的内存上下文等关键数据是否就绪。

完成选择后，系统会精心恢复新进程的运行环境：不仅加载寄存器状态，更重要的是切换内存地址空间（通过更新CR3寄存器），最后通过特殊指令完成从内核态到用户态的优雅切换。新进程由此获得CPU控制权，从其上次中断点继续执行，直到下一个调度时机到来。

用户态与内核态的转换如同特制电梯，进程可通过系统调用主动"搭乘"（如发起文件操作），也可能被硬件中断强制"运送"（如时钟中断）。转换时CPU会自动完成栈指针切换和关键寄存器保存，内核态执行结束后再通过专用指令精准恢复用户现场。这种精巧的权限隔离机制既保障了系统安全，又维持了运行效率。

6.6 hello的异常与信号处理

异常有以下四种。

异常类型	触发原因	同步性	后续执行行为
中断	外部设备信号（如键盘输入）	异步触发	继续执行下一条指令
陷阱	程序主动触发（如系统调用）	同步触发	继续执行后续指令
故障	可恢复错误（如缺页异常）	同步触发	可能重试当前指令
终止	不可恢复错误（如硬件损坏）	同步触发	终止当前进程

信号有如下几种。

信号名称	信号编号	触发原因	默认行为
SIGSEGV	11	非法内存访问（如空指针解引用、越界访问）	终止并生成core文件
SIGILL	4	执行非法指令（如代码段损坏或CPU不支持的指令）	终止并生成core文件
SIGFPE	8	算术异常（如除零、整数溢出）	终止并生成core文件
SIGABRT	6	程序主动调用abort()或断言失败	终止并生成core文件
SIGINT	2	用户按下Ctrl+C中断程序	终止进程
SIGTERM	15	系统终止请求（如kill命令默认发送的信号）	终止进程
SIGKILL	9	强制终止（不可被捕获或忽略）	立即终止
SIGPIPE	13	向无读端的管道写入数据（如printf后管道关闭）	终止进程
SIGBUS	7	内存对齐错误（如访问未对齐的地址）	终止并生成core文件

1. 正常执行情况

程序启动后会连续打印10条问候信息，每次间隔用户指定的秒数。完成所有输出后，等待用户按下回车键结束程序。整个过程顺利执行完毕后，系统会自动回收进程资源。

图6.6.1

2. 中断操作测试

Ctrl+C中断：在程序运行期间按下这个组合键，会立即终止程序运行。

图6.6.2.1

Ctrl+Z暂停：按下后会暂停程序运行，终端显示"已停止"状态。此时程序并未退出，而是转入后台挂起状态。

图6.6.2.2

3. 进程管理操作

查看挂起进程：使用jobs命令可以查看被挂起的程序，显示其作业编号为1。ps命令能查看到该进程仍在进程列表中，状态显示为"T"（暂停）。

图6.6.3.1

进程树查看：通过pstree命令可以直观看到当前系统中所有进程的层级关系，我们的测试程序作为子进程显示在终端进程之下。

图6.6.3.2

图6.6.3.3

图6.6.3.4

图6.6.3.5

恢复执行：使用kill -CONT命令配合进程ID，可以让暂停的程序恢复运行。程序会从暂停的位置继续执行，完成剩余的输出任务后正常退出。

图6.6.3.6

图6.6.3.7

4. 异常输入测试

在程序运行期间随意输入字符（包括回车、空格等），这些输入会被暂存在缓冲区。当程序执行到getchar()时，会读取第一个换行符之前的所有输入。多余的输入内容会在程序结束后被shell当作命令解释执行。测试表明，这些随机输入不会影响程序的正常输出流程，程序仍能完整输出10条信息。

图6.6.4

5. 进程终止操作

使用kill命令可以直接终止指定的进程。在测试中，我们先用Ctrl+Z暂停程序，然后用kill命令结束该进程，系统会显示进程已终止的确认信息。

图6.6.5

6.7本章小结

本章详细剖析了 hello 进程从诞生到结束的完整生命周期。当用户在终端输入运行命令后，系统首先通过 fork 系统调用创建子进程，该子进程继承父进程的虚拟地址空间副本，包含独立的代码段、数据段等核心内存区域。

在加载阶段，子进程通过 execve 系统调用完成关键转型：操作系统解析可执行文件格式，建立内存映射关系，并初始化进程运行环境，将 hello 程序的指令和数据准确载入预定内存空间。进程运行期间，操作系统调度器根据时间片轮转和优先级策略，动态执行进程上下文切换，实现 CPU 资源的合理分配。

异常处理机制是进程生命周期的重要环节。当 hello 进程遭遇硬件中断、系统调用或程序错误时，内核会触发对应的异常处理流程。不同类型的信号（如 SIGINT、SIGSEGV 等）会引发差异化的处理响应——可能立即终止进程并生成 core dump，或进入暂停状态等待恢复。这些处理逻辑共同决定了进程的最终退出状态，直至其生命周期正式结束。

第7章 hello的存储管理

7.1 hello的存储器地址空间

1. 逻辑地址

在hello程序的编译阶段，编译器会为代码中的每个函数和变量分配逻辑地址。这些地址是相对于程序代码段或数据段的偏移量。在C语言中，通过&操作符获取的指针值就是逻辑地址的表现形式。逻辑地址需要结合段基址（存储在CS/DS等寄存器中）才能转换为线性地址。不过在现代操作系统中，分段机制通常被简化为平坦模式，段基址默认为0，使得逻辑地址直接等同于线性地址。

2. 线性地址

当hello程序运行时，CPU的分段单元（如果启用）会将逻辑地址转换为线性地址。在x86架构中，线性地址空间是连续的4GB范围（32位系统），但现代Linux系统通过平坦内存模型绕过分段机制，线性地址实际上就是逻辑地址加上0值段基址的结果。这种设计简化了地址转换流程，使线性地址直接作为分页机制的输入。

3. 虚拟地址

hello进程运行时使用的地址都是虚拟地址。虚拟地址是进程视角中的连续内存空间，与实际物理内存布局无关。操作系统通过多级页表（如x86的四级页表PML4、PDPT、PD、PT）将虚拟地址映射到物理地址。当hello程序访问argv[1]等数据时，MMU会查询页表完成转换。如果目标页未加载（如首次访问），会触发缺页异常，由操作系统从磁盘调入内存。

4. 物理地址

最终，hello程序的指令和数据需要通过物理地址在内存芯片上存取。物理地址是CPU地址总线上的实际信号，直接对应DRAM的存储单元。在hello的进程上下文切换时，TLB（转换后备缓冲器）会缓存常用页表条目，加速虚拟到物理地址的转换。若TLB未命中，则需要完整的页表遍历，这会增加约100ns的延迟。

7.2 Intel逻辑地址到线性地址的变换-段式管理

在计算机系统中，程序运行时使用的地址需要经过多级转换才能最终访问物理内存。以hello程序为例，我们来看看Intel处理器是如何通过段式管理实现地址转换的。

当hello程序被加载执行时，系统会为它建立独立的内存视图。程序中的每个地址首先表现为逻辑地址，由两部分组成：段选择符和段内偏移量。段选择符是一个16位的数值，其中高13位用于索引段描述符表，低3位包含特权级等信息。系统维护着两种描述符表：全局描述符表（GDT）和局部描述符表（LDT）。GDT是系统级的，包含操作系统核心代码段、数据段等关键信息；而每个程序如hello都有自己的LDT，记录着程序私有的代码段、数据段等描述符。当hello程序访问内存时，CPU会根据当前段寄存器（如CS、DS）的值，从相应的描述符表中找到段基址，再加上指令中给出的偏移量，就得到了线性地址。

现代操作系统通常采用平坦内存模型，将段基址设为0，使得逻辑地址直接等同于线性地址。这种设计简化了地址转换流程，让程序可以专注于业务逻辑的实现。在hello程序中，无论是调用printf函数还是访问全局变量，都只需要关心线性地址空间中的位置，而不用考虑底层的段式管理细节。通过这种分层的地址转换机制，系统既保证了各个程序的内存隔离，又提供了灵活的内存访问方式。hello程序可以安全地使用自己的内存空间，不会干扰其他程序的运行，这正是现代操作系统稳定性的重要保障。

7.3 Hello的线性地址到物理地址的变换-页式管理

计算机系统使用虚拟内存技术来管理程序的内存访问。当hello程序运行时，它看到的是一个连续的虚拟地址空间，但实际上这些内存可能分散在物理内存和磁盘上。

系统将虚拟内存划分为固定大小的页（通常4KB），物理内存也按同样大小分页。每个程序都有一张页表，记录虚拟页和物理页的对应关系。页表中的每个条目包含两个关键信息：一个标记位表示该页是否在内存中，另一个字段记录物理页的位置（如果在内存中）。

当hello程序访问某个内存地址时，CPU的内存管理单元（MMU）会自动查询页表进行地址转换。如果目标页已在内存（标记位有效），就直接访问对应的物理页；如果不在内存（标记位无效），则触发缺页异常，操作系统会从磁盘加载该页到内存，并更新页表，然后重新执行被中断的指令。

这种机制使得hello程序可以使用比实际物理内存更大的地址空间，而且不同程序的内存相互隔离。操作系统通过智能的页面调度算法，确保最常用的页保留在内存中，较少使用的页暂存磁盘，从而优化整体性能。

7.4 TLB与四级页表支持下的VA到PA的变换

现代处理器通过多级页表机制实现高效的虚拟地址转换。以Core i7为例，当程序访问内存时，CPU生成的虚拟地址首先被送到内存管理单元（MMU）进行处理。MMU会先检查TLB（转换后备缓冲器），这是一个专门缓存最近使用过的页表项的高速缓存。

如果TLB中存有该地址对应的页表项，就能立即获得物理地址。如果TLB中没有找到对应的页表项，MMU就会启动完整的四级页表查询过程。这个过程从CR3寄存器保存的顶级页表基址开始，依次使用虚拟地址中的四个索引字段（VPN1到VPN4）逐级查找。每一级页表项都指向下一级页表的物理地址，最终在第四级页表中找到实际的物理页号。这个物理页号与虚拟地址中的页内偏移量组合，就得到了完整的物理地址。

为了提高性能，新转换的地址会被存入TLB，以备后续快速访问。这种分层查询机制既节省了内存空间（不需要为整个地址空间维护页表），又通过TLB保证了常用地址的快速转换。操作系统负责维护页表内容，确保不同进程的地址空间相互隔离，同时通过缺页异常处理实现按需调页和页面置换。

7.5 三级Cache支持下的物理内存访问

现代计算机系统采用多级缓存结构来提升数据访问效率。当处理器执行指令需要访问数据时，会首先查询速度最快的一级缓存（L1 Cache）。如果所需数据正好存储在L1中，处理器可以在几个时钟周期内完成操作，这是最理想的情况。

若L1缓存中没有找到目标数据，处理器会继续查询容量较大的二级缓存（L2 Cache）。L2的访问速度虽然比L1稍慢，但仍远快于访问主内存。当数据在L2中找到时，系统会将其调入L1缓存，同时提供给处理器使用。

对于L2缓存也未命中的情况，处理器会查询共享的三级缓存（L3 Cache）。L3缓存容量更大，访问延迟也更高。命中L3的数据会被逐级加载到L2和L1缓存中。

当数据在所有缓存层级都未能找到时，处理器才需要访问主内存。这时会产生较大的性能开销，数据从内存读取后会依次填充到L3、L2和L1缓存，以便后续快速访问。在数据写入方面，系统采用写回策略，修改后的数据会暂时保留在缓存中，直到需要替换缓存行时才写回主内存，这样可以减少不必要的内存写入操作。

7.6 hello进程fork时的内存映射

当程序调用fork()创建新进程时，内核会为新进程建立运行环境。系统首先为新进程分配唯一的进程ID（PID），然后复制父进程的内存管理结构，包括内存描述符、内存区域映射和页表。

此时，父子进程共享相同的物理内存页，但这些内存页都被标记为只读。当任一进程尝试修改内存时，会触发页错误异常。内核捕获异常后，才会为修改进程复制对应的内存页，建立独立的物理内存映射。

这种写时复制机制实现了两个重要特性：

初始阶段父子进程高效共享内存，避免不必要的复制开销
操作时自动创建私有内存页，确保进程间内存隔离这种设计使得fork()调用既快速又节省内存，同时严格保持了进程间的内存独立性。

7.7 hello进程execve时的内存映射

当程序执行execve系统调用时，内核会重新初始化当前进程的内存空间，加载并运行新的可执行程序。这个过程主要分为以下几个步骤：

首先，内核会清除当前进程原有的用户空间内存映射，释放所有已分配的用户态内存区域。接着，内核会为新程序建立私有的内存映射区域：代码段（.text）和数据段（.data）直接映射到可执行文件的对应部分；.bss段则映射到匿名内存区域，初始化为全零；栈和堆空间同样初始化为零，初始大小为零。

对于动态链接的程序，内核还会将共享库（如libc.so）映射到进程的共享内存区域。这些共享库的代码段会被多个进程共享，而数据段则采用写时复制机制，确保各进程的数据隔离。

最后，内核会设置进程的程序计数器（PC），使其指向新程序的入口点（通常是_start符号）。这样，当系统调用返回时，进程就开始执行新的程序代码，而原来的程序映像已被完全替换。整个过程保证了新程序在一个干净的内存环境中启动，同时充分利用了共享库和写时复制等优化机制。

7.8 缺页故障与缺页中断处理

当程序运行过程中发生缺页异常时，操作系统会启动缺页中断处理流程。首先会检查引发缺页的虚拟地址是否属于进程合法的地址空间范围，如果地址越界就会直接终止进程并报告段错误。对于合法的地址，系统还会验证当前进程是否具备访问该内存页的权限，包括读写权限和执行权限，如果权限不足同样会导致进程异常终止。

通过上述安全检查后，系统会选择一个合适的物理页帧作为置换目标。如果被替换的页帧内容发生过修改，系统会先将它写入交换分区以保存数据。接着从磁盘加载所需的页面内容到内存，并更新页表建立新的映射关系。完成这些操作后，系统会重新执行之前触发缺页的那条指令，此时由于所需页面已加载到内存，指令可以正常执行下去。整个过程对应用程序完全透明，确保了程序在有限物理内存条件下仍能正确运行。

7.9动态存储分配管理

程序运行时的内存管理是一个复杂而精密的系统。以printf函数为例，当它处理复杂格式化输出时，可能会在背后悄悄调用malloc来申请临时缓冲区，这种隐式的内存分配对程序员来说是透明的，但却实实在在地影响着程序的性能表现。

内存分配器采用多种策略来平衡效率和空间利用率。首次适应算法简单高效，它从堆内存中找到第一个足够大的空闲块就直接分配，虽然速度快但容易留下内存碎片。最佳适应算法则更为精细，它会遍历整个空闲链表寻找大小最接近需求的块，虽然减少了内存浪费，但搜索成本明显增加。最差适应算法反其道而行，总是选择最大的空闲块进行分割，这种策略在特定场景下反而能取得意想不到的效果。

内存碎片化是困扰动态分配的主要问题。内部碎片源于内存对齐和分配粒度，那些因四舍五入而浪费的空间看似不大，累积起来却相当可观。外部碎片则像散落在沙滩上的贝壳，单个看都很完整，却难以拼凑出需要的形状。聪明的内存管理器采用合并相邻空闲块的策略，在free操作时自动将相邻的空闲区域合并成更大的块。对于特别频繁的小内存申请，预分配的内存池技术能显著提升性能。

在多线程环境下，内存分配还要考虑并发安全。像glibc这样的现代内存管理器引入了arena机制，让不同线程可以在各自的内存分区中分配，既保证了线程安全，又减少了锁竞争。内存泄漏是另一个常见陷阱，特别是那些隐藏在库函数内部的分配行为，更需要开发者保持警惕。

这些复杂机制最终都服务于一个目标：让程序员可以简单地使用内存，而不必操心背后的实现细节。从ptmalloc到jemalloc，现代内存管理器不断进化，通过混合策略和智能启发式算法，在速度、空间利用率和通用性之间寻找最佳平衡点。这种精妙的工程设计，正是计算机系统优雅之处的体现。

7.10本章小结

本章深入探讨了程序运行时的内存管理机制，以hello程序为例详细解析了现代计算机系统的内存管理体系。从最基础的地址空间概念出发，首先介绍了Intel处理器的段式管理机制，阐述了逻辑地址到线性地址的转换过程。虽然现代操作系统大多采用平坦内存模型简化了段式管理，但理解这一机制对把握程序内存访问的本质仍很重要。

在页式管理方面，本章以Intel Core i7处理器为具体环境，完整剖析了虚拟地址到物理地址的转换流程。通过四级页表结构（PML4、PDPT、PD、PT）的逐级查询，配合TLB缓存加速，系统实现了高效的内存地址转换。当发生缺页异常时，操作系统会启动精细的缺页处理流程，包括地址合法性检查、权限验证、页面置换等步骤，确保程序能正确访问所需内存。

通过hello程序的运行实例，本章具体分析了进程创建（fork）和程序加载（execve）时的内存映射机制。fork采用的写时复制技术既保证了进程隔离，又避免了不必要的内存拷贝；execve则通过重建地址空间、加载程序段、设置共享库映射等步骤，为程序运行准备全新的内存环境。

最后，本章探讨了动态存储分配管理的核心问题，分析了不同分配策略的优劣，以及内存碎片化的解决方案。这些知识不仅解释了hello程序中printf等函数的内存行为，也为理解更复杂的程序内存管理奠定了基础。整体而言，本章内容展现了现代操作系统如何通过精巧的设计，在保证安全隔离的前提下，为程序提供灵活高效的内存访问能力。

结论

Hello程序的系统级生命周期解析与思考：

源码创作阶段程序员使用文本编辑器编写符合C语言语法规范的源代码（hello.c），定义程序的主逻辑框架和外部接口。这个阶段体现了人类思维到机器指令的第一次抽象转换。
预处理转换阶段预处理器（cpp）执行宏替换和头文件包含等指令，生成展开后的中间文件（hello.i）。这个过程消除了源代码对编译环境的依赖，为后续编译阶段做好准备。
编译转换阶段编译器（gcc）通过词法分析、语法分析等步骤，将预处理后的C代码转换为汇编语言（hello.s）。这个阶段进行了多种优化，包括常量传播和死代码消除等。
汇编转换阶段汇编器（as）将汇编指令转换为机器码，生成包含可重定位目标代码的文件（hello.o）。该文件包含二进制指令和符号表等元数据，为链接阶段提供基础。
链接整合阶段链接器（ld）解析外部符号引用，合并多个目标文件和库文件，最终生成可执行文件（hello）。这个过程完成了虚拟地址空间的映射布局。
进程创建阶段 Shell通过fork()系统调用创建子进程，采用写时复制技术高效复制父进程的上下文环境，包括进程控制块和内存页表等关键数据结构。
程序加载阶段 execve()系统调用触发加载器工作，解析ELF文件格式，建立代码段、数据段等内存区域，并动态加载所需的共享库。
执行调度阶段内核调度器基于时间片轮转算法分配CPU资源，处理器通过多级缓存机制高效获取指令和数据，按照取指-译码-执行-写回的流水线模式运行程序。
异常处理阶段硬件中断和软件异常触发中断服务例程，系统根据中断向量表调用相应的处理程序，确保程序运行的稳定性和安全性。
资源回收阶段进程通过exit()终止后，父进程通过wait()回收资源，内核释放占用的虚拟内存空间，关闭打开的文件描述符，完成整个生命周期管理。

通过深入分析hello程序的生命周期，我对计算机系统设计有以下深刻认识：

编译链接机制使用gcc -no-pie选项编译时，可以清晰观察到重定位条目如何解析外部符号引用。特别是动态链接中的PLT/GOT延迟绑定机制，展现了高效的符号解析策略。
进程管理优化 fork()的写时复制技术实现了高效的进程创建，而execve()在重构地址空间时保留文件描述符的设计，体现了系统资源管理的精妙平衡。通过/proc文件系统可以验证内存区域的权限设置。
地址转换机制深入分析从线性地址到物理地址的转换过程，包括CR3寄存器的作用和多级页表的查询机制，理解了TLB缓存和缺页异常处理的完整流程。
调试方法论掌握objdump分析重定位信息、strace追踪系统调用、gdb调试寄存器状态等关键技术，形成了完整的系统级调试方法论。

Hello程序虽然简单，但是能够体现多方面的知识。动态链接器通过GOT表实现的重定位机制，是软件工程中的经典设计思想。这些深入理解将显著提升我的系统级编程能力和架构设计思维。

附件

文件名	作用描述
hello.c	程序的 C 语言源代码文件，包含 main() 函数及所需逻辑。
hello.i	预处理后的文本文件，展开所有宏、头文件，并删除注释，供编译器进一步处理。
hello.s	由 hello.i 编译生成的汇编代码文件，包含机器指令的文本表示。
hello.o	汇编器生成的可重定位目标文件（.o 文件），包含机器码但未完成最终地址绑定。
elf.txt	使用 readelf 工具分析 hello.o 的 ELF 格式信息，如节头、符号表等。
hello	链接器将 hello.o 与其他库（如 libc）合并后生成的可执行目标文件。
hello1.elf	使用 readelf 分析最终 hello 可执行文件的 ELF 结构，如程序头、入口地址等。

参考文献

[1] 林来兴. 空间控制技术[M]. 北京：中国宇航出版社，1992：25-42.

[2] 辛希孟. 信息技术与信息服务国际研讨会论文集：A集[C]. 北京：中国科学出版社，1999.

[3] 赵耀东. 新时代的工业工程师[M/OL]. 台北：天下文化出版社，1998 [1998-09-26]. http://www.ie.nthu.edu.tw/info/ie.newie.htm（Big5）.

[4] 谌颖. 空间交会控制理论与方法研究[D]. 哈尔滨：哈尔滨工业大学，1992：8-13.

[5] KANAMORI H. Shaking Without Quaking[J]. Science，1998，279（5359）：2063-2064.

[6] CHRISTINE M. Plant Physiology: Plant Biology in the Genome Era[J/OL]. Science，1998，281：331-332[1998-09-23]. http://www.sciencemag.org/cgi/ collection/anatmorp.

[7] Ubuntu 相关： http://forum.ubuntu.org.cn/

[8] C汇编Linux手册： http://docs.huihoo.com/c/linux-c-programming/

[9] gcc 使用： https://blog.csdn.net/weixin_50697073/article/details/123759516

转载自CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/BOSHIYu/article/details/147907419