[原创]一个 ELF 文件的运行-Android安全-看雪安全社区

# 一个 ELF 文件的运行

这篇文章会包含很多项目的源码阅读, 覆盖 `elf 的解析`, `elf 的加载`, `elf 的链接`, 一次说清楚. 并换一种风格, 只在代码关键地方做注释. 并不会直接总结一个 elf 包含了哪些信息, 然后去哪找云云, 只是纯粹的源码阅读的记录, 看看在实际生产中 elf 如何被使用的, 必要的地方做一些总结和提示, 仅仅如此, 这点您要做好心理准备.

所有注释, 总结, 补充说明都是我改过, 读过的, 放心食用.

## 源码

### linux(elf 加载)

```bash
wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.4.301.tar.xz
tar xvf linux-5.9.6.tar.xz

sudo apt install -y llvm clang clang++ lld git fakeroot build-essential ncurses-dev xz-utils libssl-dev bc flex libelf-dev bison

bear -- make CC=clang CXX=clang++ LLVM=1 defconfig -j$(nproc)
bear -- make CC=clang CXX=clang++ LLVM=1 -j$(nproc)
```

### binutils-gdb(readelf)

```bash
git clone git://sourceware.org/git/binutils-gdb.git
cd ~/binutils-gdb
sudo apt install -y build-essential flex bison texinfo libncurses5-dev python3-dev

mkdir build && cd build  
../configure CC=clang CXX=clang++ --disable-gdb --disable-werror

bear -- make -j$(nproc)
```
编译完能跳转了, 但是还是有红线, 不理会.

### glibc(Linux 的动态链接器)
这个我也写了, 实现的很乱, 各种历史的沉淀, 不好读, 就删了, 感兴趣可以自己看看, `glibc/elf/rtld.c` 中的 `_dl_start` 是入口函数.

编译也很快, 但是有红线, 推荐看网页版: <mark class="encrypted">d9cK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6W2L8r3W2^5K9i4u0Q4x3X3g2T1L8$3!0@1L8r3W2F1i4K6u0W2j5$3!0E0i4K6u0r3k6$3I4A6j5X3y4Q4x3V1k6Y4L8r3W2T1j5#2)9J5k6o6u0Q4x3X3f1K6x3W2)9J5c8Y4y4G2N6i4u0U0k6b7`.`.</mark>

### bionic(Android 的动态链接器)
不想编译 AOSP, 直接看网页版: <mark class="encrypted">262K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0M7#2)9J5k6h3q4F1k6s2u0G2K9h3c8Q4x3X3g2U0L8$3#2Q4x3V1k6S2L8X3c8J5L8$3W2V1i4K6u0r3M7r3I4S2N6r3k6G2M7X3#2Q4x3V1k6K6N6i4m8W2M7Y4m8J5L8$3A6W2j5%4c8Q4x3V1k6Q4x3V1u0Q4x3V1k6S2L8X3c8J5L8$3W2V1i4K6u0V1L8r3q4@1k6i4y4@1i4K6u0V1M7X3g2D9k6h3q4K6k6g2)9K6b7h3u0A6L8$3&6A6j5#2)9J5c8W2)9J5b7H3`.`.</mark> 个人观点" 代码比 glibc 中的好读一万倍, 代码写的非常好, 看着很舒服.

## binutils-gdb/binutils/readelf.c
 ![](upload/attach/202512/1025255_JV2YAA2P9FKGZ6V.webp)

`elf 的解析` 实现, 大而全, 很好读. 作为开胃菜, 让我们从这里开始.

### main
找到 main 函数:
```c
注释
int
main (int argc, char ** argv)
{
  int err;

#ifdef HAVE_LC_MESSAGES
  setlocale (LC_MESSAGES, "");
#endif
  setlocale (LC_CTYPE, "");
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

expandargv (&argc, &argv);

parse_args (& cmdline, argc, argv);

if (optind < (argc - 1))
    show_name = true;
  else if (optind >= argc)
    {
      do_checks = true;

warn (_("Nothing to do.\n"));
      usage (stderr);
    }

err = false;
  while (optind < argc)
    if (! process_file (argv[optind++]))
      err = true;

free (cmdline.dump_sects);

free (dump_ctf_symtab_name);
  free (dump_ctf_strtab_name);
  free (dump_ctf_parent_name);

return err ? EXIT_FAILURE : EXIT_SUCCESS;
}
```
前边就是在处理输入的参数, 然后调用 `process_file` 解析, 传入的参数 `argv[optind++]` 是一个个文件名, 跟进去:

### process_file
```c
static bool
process_file (char * file_name)
{
  Filedata * filedata = NULL;
  struct stat statbuf;
  char armag[SARMAG];
  bool ret = true;

// 调用 stat 系统调用获取文件元数据
  if (stat (file_name, &statbuf) < 0)
    {
      if (errno == ENOENT)
	error (_("'%s': No such file\n"), file_name);
      else
	error (_("Could not locate '%s'.  System error message: %s\n"),
	       file_name, strerror (errno));
      return false;
    }

// 验证文件类型是否为普通文件, 程序仅处理普通文件, 非普通文件直接返回错误
  if (! S_ISREG (statbuf.st_mode))
    {
      error (_("'%s' is not an ordinary file\n"), file_name);
      return false;
    }

filedata = calloc (1, sizeof * filedata);
  if (filedata == NULL)
    {
      error (_("Out of memory allocating file data structure\n"));
      return false;
    }

// 给 Filedata 结构体赋值, 保存文件名和文件句柄
  filedata->file_name = file_name;
  filedata->handle = fopen (file_name, "rb");
  if (filedata->handle == NULL)
    {
      error (_("Input file '%s' is not readable.\n"), file_name);
      free (filedata);
      return false;
    }

// 读取文件头部魔数

// fread(缓冲区, 每次读取大小, 读取次数, 文件句柄)
  if (fread (armag, SARMAG, 1, filedata->handle) != 1)
    {
      error (_("%s: Failed to read file's magic number\n"), file_name);
      fclose (filedata->handle);
      free (filedata);
      return false;
    }

// // 填充 Filedata 结构体的文件大小
  filedata->file_size = statbuf.st_size;
  filedata->is_separate = false;

// 根据魔数识别文件类型, 分发给对应处理函数

// 标准归档文件, 标准 .a: 「装满 .o 的压缩包」, 链接时直接用
  if (memcmp (armag, ARMAG, SARMAG) == 0)
    {
      if (! process_archive (filedata, false))
	ret = false;
    }
  // 精简归档文件, 精简 .a: 「记录 .o 地址的清单」, 链接时要找原始 .o
  else if (memcmp (armag, ARMAGT, SARMAG) == 0)
    {
      if ( ! process_archive (filedata, true))
	ret = false;
    }
  // 非归档文件, 视为普通目标文件, 如 .o 文件, 可执行文件, .so 文件等, 也就是咱们的目标
  else
    {
      if (do_archive_index && !check_all)
	error (_("File %s is not an archive so its index cannot be displayed.\n"),
	       file_name);

// 回退文件指针到开头
      rewind (filedata->handle);
      filedata->archive_file_size = filedata->archive_file_offset = 0;
      
      // 调用 process_object 解析
      if (! process_object (filedata))
	ret = false;
    }

// 释放资源, 清理状态

// 若打开了调试信息文件, 此处释放调试相关文件
  close_debug_file (filedata);

free (ba_cache.strtab);
  ba_cache.strtab = NULL;
  free (ba_cache.symtab);
  ba_cache.symtab = NULL;
  ba_cache.filedata = NULL;

return ret;
}
```
主要就是在根据魔数识别文件类型, 分发给对应处理函数, 我们继续跟入 `process_object`, 看看如何处理可执行文件的:

### process_object
```cpp
static bool
process_object (Filedata * filedata)
{
  bool have_separate_files;
  unsigned int i;
  bool res;

// 读取 ELF 文件头部
  if (! get_file_header (filedata))
    {
      error (_("%s: Failed to read file header\n"), filedata->file_name);
      return false;
    }

// 初始化

// 初始化版本信息数组
  for (i = ARRAY_SIZE (filedata->version_info); i--;)
    filedata->version_info[i] = 0;

// 初始化动态段信息数组
  for (i = ARRAY_SIZE (filedata->dynamic_info); i--;)
    filedata->dynamic_info[i] = 0;
  filedata->dynamic_info_DT_GNU_HASH = 0;
  filedata->dynamic_info_DT_MIPS_XHASH = 0;

if (show_name)
    printf (_("\nFile: %s\n"), filedata->file_name);

// 初始化待 dump 的节列表
  initialise_dump_sects (filedata);

// 预读取第一个节头
  get_section_headers (filedata, true);

// 处理 ELF 文件头部信息
  if (! process_file_header (filedata))
    {
      res = false;
      goto out;
    }

// 释放之前预读取的单个节头内存, 因为后续会完整读取所有节头, 避免重复内存占用, 此处释放并置空指针
  free (filedata->section_headers);
  filedata->section_headers = NULL;

// 处理所有节头
  if (! process_section_headers (filedata))
    {
      do_unwind = do_version = do_dump = do_arch = false;

if (! do_using_dynamic)
	do_syms = do_dyn_syms = do_reloc = false;
    }

// 处理节组
  if (! process_section_groups (filedata))
    do_unwind = false;

// 处理程序头
  process_program_headers (filedata);

// 处理动态段
  res = process_dynamic_section (filedata);

// 处理重定位表
  if (! process_relocs (filedata))
    res = false;

// 处理 unwind 信息, 用于异常处理和调试, 记录函数调用栈的展开规则
  if (! process_unwind (filedata))
    res = false;

// 处理符号表, 包含函数名, 变量名, 符号类型, 地址等信息
  if (! process_symbol_table (filedata))
    res = false;

// 处理 LTO 符号表, LTO 是编译优化技术, 会生成特殊的符号表
  if (! process_lto_symbol_tables (filedata))
    res = false;

// 处理符号信息扩展, 部分 ELF 文件包含 .syminfo 节, 存储符号的额外信息
  if (! process_syminfo (filedata))
    res = false;

// 处理版本节, 解析版本相关节, 记录符号版本和依赖库版本
  if (! process_version_sections (filedata))
    res = false;

// 加载调试信息文件
  if (might_need_separate_debug_info (filedata))
    have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
  else
    have_separate_files = false;

// 处理节内容
  if (! process_section_contents (filedata))
    res = false;

// 处理 GOT 节内容, Global Offset Table, 全局偏移表, 是动态链接中用于存储全局符号地址的表, 解析其内容可查看动态符号的地址映射
  if (! process_got_section_contents (filedata))
    res = false;

// 处理已加载的分离调试信息文件
  if (have_separate_files)
    {
      separate_info * d;

for (d = first_separate_info; d != NULL; d = d->next)
	{
	  initialise_dump_sects (d->handle);

if (process_links && ! process_file_header (d->handle))
	    res = false;
	  else if (! process_section_headers (d->handle))
	    res = false;
	  else if (! process_section_contents (d->handle))
	    res = false;
	  else if (process_links)
	    {
	      if (! process_section_groups (d->handle))
		res = false;
	      process_program_headers (d->handle);
	      if (! process_dynamic_section (d->handle))
		res = false;
	      if (! process_relocs (d->handle))
		res = false;
	      if (! process_unwind (d->handle))
		res = false;
	      if (! process_symbol_table (d->handle))
		res = false;
	      if (! process_lto_symbol_tables (d->handle))
		res = false;
	      if (! process_syminfo (d->handle))
		res = false;
	      if (! process_version_sections (d->handle))
		res = false;
	      if (! process_notes (d->handle))
		res = false;
	    }
	}

}

// 处理注释节, 注释节存储额外的文件信息, 如编译器版本, 调试器信息, 架构特定备注等
  if (! process_notes (filedata))
    res = false;

// 处理 GNU 库列表, 存储程序依赖的 GNU 库信息, 如库名称, 版本, 路径等
  if (! process_gnu_liblist (filedata))
    res = false;

// 处理架构特定信息, 针对特定 CPU 架构的专有节, 如 ARM 的 .ARM.exidx, x86 的 .eh_frame_hdr 等
  if (! process_arch_specific (filedata))
    res = false;

// 资源释放
 out:
  free_filedata (filedata);

free_debug_memory ();

return res;
}
```
这是是核心"地图", 顺着这个函数我们可以找到任何一个想要的功能, 虽然代码排版很奇怪, 但逻辑很明了, 从上大小一点点解析, 好了, 接下来我们看看这些函数了, 他们会非常多.

### get_file_header

```cpp
static bool
get_file_header (Filedata * filedata)
{
  // 读取 ELF 文件标识数组, 也就是前 EI_NIDENT(16) 字节
  if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
    return false;

// 根据 ELF 文件标识数组中的第 EI_DATA 字节判断大小端
  switch (filedata->file_header.e_ident[EI_DATA])
    {
    default:
    case ELFDATANONE:
    case ELFDATA2LSB:
      byte_get = byte_get_little_endian;
      byte_put = byte_put_little_endian;
      break;
    case ELFDATA2MSB:
      byte_get = byte_get_big_endian;
      byte_put = byte_put_big_endian;
      break;
    }

// 根据 ELF 文件标识数组中的第 EI_CLASS 字节判断是 32 位还是 64 位
  is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);

// 读取文件头剩余字段, 填充到 filedata 的文件头中
  if (is_32bit_elf)
    {
      Elf32_External_Ehdr ehdr32;

if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
	return false;

filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
      filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
      filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
      filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
      filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
      filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
      filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
      filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
      filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
      filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
      filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
      filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
      filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
    }
  else
    {
      Elf64_External_Ehdr ehdr64;

if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
	return false;

filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
      filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
      filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
      filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
      filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
      filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
      filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
      filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
      filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
      filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
      filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
      filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
      filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
    }

return true;
}
```
其中一些工具函数(`byte_get_little_endian`, `byte_put_little_endian` 等), 我们不再看, 大致流程就是根据前 16 字节确定大小端, 32 位还是 64 位, 然后用已有结构体读取文件头, 下面贴一下 `Elf32_External_Ehdr`, `Elf64_External_Ehdr`, 也就是程序头的结构体:
```c
typedef struct {
  unsigned char	e_ident[16];		/* ELF 魔数 */
  unsigned char	e_type[2];		/* 标识目标文件类型 */
  unsigned char	e_machine[2];		/* 指定所需的架构 */
  unsigned char	e_version[4];		/* 标识目标文件版本 */
  unsigned char	e_entry[4];		/* 程序入口点的虚拟地址 */
  unsigned char	e_phoff[4];		/* 程序头表在文件中的偏移量 */
  unsigned char	e_shoff[4];		/* 节头表在文件中的偏移量 */
  unsigned char	e_flags[4];		/* 处理器相关标志 */
  unsigned char	e_ehsize[2];		/* ELF 文件头本身的大小 */
  unsigned char	e_phentsize[2];		/* 程序头表中每个表项的大小 */
  unsigned char	e_phnum[2];		/* 程序头表的表项数量 */
  unsigned char	e_shentsize[2];		/* 节头表中每个表项的大小 */
  unsigned char	e_shnum[2];		/* 节头表的表项数量 */
  unsigned char	e_shstrndx[2];		/* 节头字符串表的索引 */
} Elf32_External_Ehdr;

typedef struct {
  unsigned char	e_ident[16];		/* ELF "magic number" */
  unsigned char	e_type[2];		/* Identifies object file type */
  unsigned char	e_machine[2];		/* Specifies required architecture */
  unsigned char	e_version[4];		/* Identifies object file version */
  unsigned char	e_entry[8];		/* Entry point virtual address */
  unsigned char	e_phoff[8];		/* Program header table file offset */
  unsigned char	e_shoff[8];		/* Section header table file offset */
  unsigned char	e_flags[4];		/* Processor-specific flags */
  unsigned char	e_ehsize[2];		/* ELF header size in bytes */
  unsigned char	e_phentsize[2];		/* Program header table entry size */
  unsigned char	e_phnum[2];		/* Program header table entry count */
  unsigned char	e_shentsize[2];		/* Section header table entry size */
  unsigned char	e_shnum[2];		/* Section header table entry count */
  unsigned char	e_shstrndx[2];		/* Section header string table index */
} Elf64_External_Ehdr;
```
保留了英文注释, 更原汁原味.

这个真是再熟悉不过了.

### get_section_headers
```c
static bool
get_section_headers (Filedata *filedata, bool probe)
{
  if (filedata->section_headers != NULL)
    return true;

if (is_32bit_elf)
    return get_32bit_section_headers (filedata, probe);
  else
    return get_64bit_section_headers (filedata, probe);
}
```
接着看看 `get_32bit_section_headers`, `get_64bit_section_headers`:
```c
static bool
get_32bit_section_headers (Filedata * filedata, bool probe)
{
  Elf32_External_Shdr * shdrs;
  Elf_Internal_Shdr *   internal;
  unsigned int          i;
  // 节头项大小
  unsigned int          size = filedata->file_header.e_shentsize;
  // probe 为 true 仅仅读取一个, false 读取全部
  unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;

// 一些检查
  if (size == 0 || num == 0)
    return false;

if (filedata->file_header.e_shoff == 0)
    return false;

if (size < sizeof * shdrs)
    {
      if (! probe)
	error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
      return false;
    }
  if (!probe && size > sizeof * shdrs)
    warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));

// 从文件读取节头数据
  shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
                                            size, num,
					    probe ? NULL : _("section headers"));
  if (shdrs == NULL)
    return false;
 
	// 为 filedata->section_headers 申请内存
  filedata->section_headers = (Elf_Internal_Shdr *)
    cmalloc (num, sizeof (Elf_Internal_Shdr));
  if (filedata->section_headers == NULL)
    {
      if (!probe)
	error (_("Out of memory reading %u section headers\n"), num);
      free (shdrs);
      return false;
    }
  // 遍历所有节头项, 填充到 filedata 节头表
  for (i = 0, internal = filedata->section_headers;
       i < num;
       i++, internal++)
    {
      internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
      internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
      internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
      internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
      internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
      internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
      internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
      internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
      internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
      internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
      if (!probe && internal->sh_link > num)
	warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
      if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
	warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
    }

free (shdrs);
  return true;
}

// 64 位与 32 位逻辑类似, 结构体不一样
static bool
get_64bit_section_headers (Filedata * filedata, bool probe)
{
  Elf64_External_Shdr *  shdrs;
  Elf_Internal_Shdr *    internal;
  unsigned int           i;
  unsigned int           size = filedata->file_header.e_shentsize;
  unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;

if (size == 0 || num == 0)
    return false;

if (filedata->file_header.e_shoff == 0)
    return false;

if (size < sizeof * shdrs)
    {
      if (! probe)
	error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
      return false;
    }

if (! probe && size > sizeof * shdrs)
    warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));

shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
					    filedata->file_header.e_shoff,
                                            size, num,
					    probe ? NULL : _("section headers"));
  if (shdrs == NULL)
    return false;

filedata->section_headers = (Elf_Internal_Shdr *)
    cmalloc (num, sizeof (Elf_Internal_Shdr));
  if (filedata->section_headers == NULL)
    {
      if (! probe)
	error (_("Out of memory reading %u section headers\n"), num);
      free (shdrs);
      return false;
    }

for (i = 0, internal = filedata->section_headers;
       i < num;
       i++, internal++)
    {
      internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
      internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
      internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
      internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
      internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
      internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
      internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
      internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
      internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
      internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
      if (!probe && internal->sh_link > num)
	warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
      if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
	warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
    }

free (shdrs);
  return true;
}
```
这一段就是根据之前读取的 ELF 文件头的记录的节头表偏移(e_shoff), 单个节头项大小(e_shentsize), 节头项总数(e_shnum)填充 `filedata` 的`section_headers` 字段, 节头表类似书的目录, 它记录了 ELF 文件中所有节(如代码段, 数据段, 符号表, 字符串表等)的关键信息(位置, 大小, 类型, 属性等), 后续解析文件内容时, 通过节头表就能快速定位到各个节的具体位置.

贴一下 `Elf32_External_Shdr` `Elf64_External_Shdr`, 节头表项:
```c
typedef struct {
  unsigned char	sh_name[4];		/* 名称, 对应字符串表中的索引 */
  unsigned char	sh_type[4];		/* 类型 */
  unsigned char	sh_flags[4];		/* 各类属性 */
  unsigned char	sh_addr[4];		/* 执行时节的虚拟地址 */
  unsigned char	sh_offset[4];		/* 在文件中的偏移量 */
  unsigned char	sh_size[4];		/* 总大小 */
  unsigned char	sh_link[4];		/* 关联节的索引 */
  unsigned char	sh_info[4];		/* 补充信息 */
  unsigned char	sh_addralign[4];	/* 内存对齐要求 */
  unsigned char	sh_entsize[4];		/* 若节为条目数组类型, 指单个条目的字节数, 非数组类节为 0 */
} Elf32_External_Shdr;

typedef struct {
  unsigned char	sh_name[4];		/* Section name, index in string tbl */
  unsigned char	sh_type[4];		/* Type of section */
  unsigned char	sh_flags[8];		/* Miscellaneous section attributes */
  unsigned char	sh_addr[8];		/* Section virtual addr at execution */
  unsigned char	sh_offset[8];		/* Section file offset */
  unsigned char	sh_size[8];		/* Size of section in bytes */
  unsigned char	sh_link[4];		/* Index of another section */
  unsigned char	sh_info[4];		/* Additional section information */
  unsigned char	sh_addralign[8];	/* Section alignment */
  unsigned char	sh_entsize[8];		/* Entry size if section holds table */
} Elf64_External_Shdr;
```
依旧原汁原味.

### process_file_header
```c
static bool
process_file_header (Filedata * filedata)
{
  Elf_Internal_Ehdr * header = & filedata->file_header;

// 验证 ELF 魔数, 4 字节(0x7f, 'E', 'L', 'F')
  if (! check_magic_number (filedata, header))
    return false;

if (! filedata->is_separate)
    init_dwarf_by_elf_machine_code (header->e_machine);

// 当启用 header 打印选项时, 打印 ELF 文件头信息
  if (do_header)
    {
      unsigned i;

if (filedata->is_separate)
	printf (_("ELF Header in linked file '%s':\n"),
		printable_string (filedata->file_name, 0));         // 打印文件名
      else
	printf (_("ELF Header:\n"));
      printf (_("  Magic:   "));
      for (i = 0; i < EI_NIDENT; i++)
	printf ("%2.2x ", header->e_ident[i]);                // 打印魔数字段, EI_NIDENT=16, ELF 标识字段总长度
      printf ("\n");
      printf (_("  Class:                             %s\n"),
	      get_elf_class (header->e_ident[EI_CLASS]));     // 32 位/ 64 位
      printf (_("  Data:                              %s\n"),
	      get_data_encoding (header->e_ident[EI_DATA]));  // 小端/大端
      printf (_("  Version:                           %d%s\n"),
	      header->e_ident[EI_VERSION],                    // 区分当前版本(EV_CURRENT), 无版本(EV_NONE)和未知版本
	      (header->e_ident[EI_VERSION] == EV_CURRENT
	       ? _(" (current)")
	       : (header->e_ident[EI_VERSION] != EV_NONE
		  ? _(" <unknown>")
		  : "")));
      printf (_("  OS/ABI:                            %s\n"),
	      get_osabi_name (filedata, header->e_ident[EI_OSABI]));    // 打印 OS/ABI 标识
      printf (_("  ABI Version:                       %d\n"), 
	      header->e_ident[EI_ABIVERSION]);                          // 打印 ABI 版本号
      printf (_("  Type:                              %s\n"),     
	      get_file_type (filedata));                                // 打印文件类型, 可执行文件、库文件、目标文件等
      printf (_("  Machine:                           %s\n"),
	      get_machine_name (header->e_machine));                    // 打印机器架构, x86、ARM、x86_64 等
      printf (_("  Version:                           0x%lx\n"),
	      header->e_version);                                       // 依旧版本

printf (_("  Entry point address:               "));
      print_vma (header->e_entry, PREFIX_HEX);                    // 打印入口点地址
      printf (_("\n  Start of program headers:          "));
      print_vma (header->e_phoff, DEC);                           // 打印程序头表在文件中的偏移量
      printf (_(" (bytes into file)\n  Start of section headers:          "));
      print_vma (header->e_shoff, DEC);                           // 打印节头表在文件中的偏移量
      printf (_(" (bytes into file)\n"));

printf (_("  Flags:                             0x%lx%s\n"),
	      header->e_flags,                                          // 打印处理器特定标志
	      get_machine_flags (filedata, header->e_flags, header->e_machine));
      printf (_("  Size of this header:               %u (bytes)\n"),
	      header->e_ehsize);                                        // 打印 ELF 文件头自身的大小
      printf (_("  Size of program headers:           %u (bytes)\n"),
	      header->e_phentsize);                                     // 打印每个程序头表项的大小
      printf (_("  Number of program headers:         %u"),
	      header->e_phnum);                                         // 打印程序头表项数量
      if (filedata->section_headers != NULL
	  && header->e_phnum == PN_XNUM       // 特殊处理: 当 e_phnum=PN_XNUM 时, 实际数量存储在节头表第 0 项的 sh_info 中
	  && filedata->section_headers[0].sh_info != 0)
	printf (" (%u)", filedata->section_headers[0].sh_info);
      putc ('\n', stdout);
      printf (_("  Size of section headers:           %u (bytes)\n"),   // 打印每个节头表项的大小
	      header->e_shentsize);
      printf (_("  Number of section headers:         %u"),             // 打印节头表项数量
	      header->e_shnum);
      if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)  
	{ // 特殊处理: 当 e_shnum=SHN_UNDEF 时, 实际数量存储在节头表第 0 项的 sh_size 中
	  header->e_shnum = filedata->section_headers[0].sh_size; 
	  printf (" (%u)", header->e_shnum);
	}
      putc ('\n', stdout);
      printf (_("  Section header string table index: %u"),
	      header->e_shstrndx);                                      // 打印节名字符串表的节头索引
      if (filedata->section_headers != NULL
	  && header->e_shstrndx == (SHN_XINDEX & 0xffff))
	{ // 特殊处理: 当 e_shstrndx=SHN_XINDEX 时, 实际索引存储在节头表第 0 项的 sh_link 中
	  header->e_shstrndx = filedata->section_headers[0].sh_link;
	  printf (" (%u)", header->e_shstrndx);
	}
      if (header->e_shstrndx != SHN_UNDEF
	  && header->e_shstrndx >= header->e_shnum)
	{
	  header->e_shstrndx = SHN_UNDEF; // 若索引超出节头数量范围, 则标记为无效
	  printf (_(" <corrupt: out of range>"));
	}
      putc ('\n', stdout);
    }

// 修正文件头字段
  if (filedata->section_headers != NULL)
    {
      if (header->e_phnum == PN_XNUM
	  && filedata->section_headers[0].sh_info != 0)
	{
	  free (filedata->program_headers);
	  filedata->program_headers = NULL;
	  header->e_phnum = filedata->section_headers[0].sh_info;
	}
      if (header->e_shnum == SHN_UNDEF)
	header->e_shnum = filedata->section_headers[0].sh_size;
      if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
	header->e_shstrndx = filedata->section_headers[0].sh_link;
      if (header->e_shstrndx >= header->e_shnum)
	header->e_shstrndx = SHN_UNDEF;
    }

return true;
}
```
将文件头的信息进行打印, 值得注意的是: 
- 在文件头中记录了程序头表和节头表的文件偏移, 项大小, 项个数. 程序头表描述了如何将文件加载到内存并执行, 节头表描述了文件的内部结构, 代码、数据、符号等.
- `e_shstrndx` 是节头表索引, 这个节对应的数据是一个字符串池, 然后里面存入各个节的名称, 方便用名称定位节, 当然这个是可以被去除的, 因为只需要索引就能定位节了, 可以不给你留名称信息.
- 这里看上去是修复了两次, 但 `do_header` 是可选的, 所以在后面还要修复一次.

### process_section_headers
该来的还是来了, 一个非常长的函数
```c
static bool
process_section_headers (Filedata * filedata)
{
	// ... 省略一些与主逻辑无关的代码

// get_section_headers 在上面看过了, 第二个 false 参数代表读取全部节
  if (!get_section_headers (filedata, false))
    return false;

// 加载节头字符串表(.shstrtab), 存到 filedata->string_table 中, 用于解析节名称
  if (filedata->string_table == NULL
      && filedata->file_header.e_shstrndx != SHN_UNDEF
      && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
    {
			// 根据 e_shstrndx 算出 .shstrtab 所在节
      section = filedata->section_headers + filedata->file_header.e_shstrndx;

if (section->sh_size != 0)
	{
		// 写入 filedata->string_table
	  filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
						      1, section->sh_size,
						      _("string table"));

filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
	}
    }

// 根据不同架构, 初始化异常处理的地址长度
  eh_addr_size = is_32bit_elf ? 4 : 8;
  switch (filedata->file_header.e_machine)
    {
    case EM_MIPS:
    case EM_MIPS_RS3_LE:
      if ((filedata->file_header.e_flags & EF_MIPS_ABI) == EF_MIPS_ABI_EABI64
	  && find_section (filedata, ".gcc_compiled_long32") == NULL)
	eh_addr_size = 8;
      break;

case EM_H8_300:
    case EM_H8_300H:
      switch (filedata->file_header.e_flags & EF_H8_MACH)
	{
	case E_H8_MACH_H8300:
	case E_H8_MACH_H8300HN:
	case E_H8_MACH_H8300SN:
	case E_H8_MACH_H8300SXN:
	  eh_addr_size = 2;
	  break;
	case E_H8_MACH_H8300H:
	case E_H8_MACH_H8300S:
	case E_H8_MACH_H8300SX:
	  eh_addr_size = 4;
	  break;
	}
      break;

case EM_M32C_OLD:
    case EM_M32C:
      switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
	{
	case EF_M32C_CPU_M16C:
	  eh_addr_size = 2;
	  break;
	}
      break;
    }

// 校验节表项大小(sh_entsize)的合法性 
#define CHECK_ENTSIZE_VALUES(section, i, size32, size64)		\
  do									\
    {									\
      uint64_t expected_entsize = is_32bit_elf ? size32 : size64;	\
      if (section->sh_entsize != expected_entsize)			\
	{								\
	  error (_("Section %d has invalid sh_entsize of %" PRIx64 "\n"), \
		 i, section->sh_entsize);				\
	  error (_("(Using the expected size of %" PRIx64 " for the rest of this dump)\n"), \
		 expected_entsize);					\
	  section->sh_entsize = expected_entsize;			\
	}								\
    }									\
  while (0)

#define CHECK_ENTSIZE(section, i, type)					\
  CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),	\
			sizeof (Elf64_External_##type))

// 遍历所有节头
  for (i = 0, section = filedata->section_headers;
       i < filedata->file_header.e_shnum;
       i++, section++)
    {
      // 获取当前节的可读名称, 从前面 filedata->string_table 中取, section->sh_name 为偏移
      const char *name = printable_section_name (filedata, section);

// 据节类型(sh_type)解析关键节 + 校验表项大小
      switch (section->sh_type)
	{
	case SHT_DYNSYM:  // 动态符号表节
	  if (filedata->dynamic_symbols != NULL)
	    {
	      error (_("File contains multiple dynamic symbol tables\n"));
	      continue;
	    }

CHECK_ENTSIZE (section, i, Sym);

// 记录到 filedata->dynamic_symbols
	  filedata->dynamic_symbols
	    = get_elf_symbols (filedata, section, &filedata->num_dynamic_syms);
	  filedata->dynamic_symtab_section = section;
	  break;

case SHT_STRTAB:  // 字符串表节
	  if (streq (name, ".dynstr"))
	    {
	      if (filedata->dynamic_strings != NULL)
		{
		  error (_("File contains multiple dynamic string tables\n"));
		  continue;
		}

// 记录到 filedata->dynamic_strings
	      filedata->dynamic_strings
		= (char *) get_data (NULL, filedata, section->sh_offset,
				     1, section->sh_size, _("dynamic strings"));
	      filedata->dynamic_strings_length
		= filedata->dynamic_strings == NULL ? 0 : section->sh_size;
	      filedata->dynamic_strtab_section = section;
	    }
	  break;

case SHT_SYMTAB_SHNDX:  // 符号表节索引扩展节, 处理符号节索引溢出
	  {
	    elf_section_list * entry = xmalloc (sizeof * entry);

entry->hdr = section;
	    entry->next = filedata->symtab_shndx_list;
	    filedata->symtab_shndx_list = entry;
	  }
	  break;

case SHT_SYMTAB:    // 静态符号表节
	  CHECK_ENTSIZE (section, i, Sym);
	  break;

case SHT_GROUP:     // 节组节, 用于分组关联的节
	  CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
	  break;

case SHT_REL:       // 重定位表节
	  CHECK_ENTSIZE (section, i, Rel);
	  if (do_checks && section->sh_size == 0)
	    warn (_("Section '%s': zero-sized relocation section\n"), name);
	  break;

case SHT_RELA:      // 重定位表节
	  CHECK_ENTSIZE (section, i, Rela);
	  if (do_checks && section->sh_size == 0)
	    warn (_("Section '%s': zero-sized relocation section\n"), name);
	  break;

case SHT_RELR:      // 简化重定位表节
	  CHECK_ENTSIZE (section, i, Relr);
	  break;

case SHT_NOTE:        // 备注信息节
	case SHT_PROGBITS:    // 程序数据节
	case SHT_GNU_SFRAME:  // GNU 栈帧节
	  if (do_checks && section->sh_size == 0)
	    warn (_("Section '%s': has a size of zero - is this intended ?\n"), name);
	  break;

default:
	  break;
	}

// 以下根据用户指定的调试选项, 标记需要 dump 的调试相关节

if ((do_debugging || do_debug_info || do_debug_abbrevs
	   || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
	   || do_debug_aranges || do_debug_frames || do_debug_macinfo
	   || do_debug_str || do_debug_str_offsets || do_debug_loc
	   || do_debug_ranges
	   || do_debug_addr || do_debug_cu_index || do_debug_links)
	  && (startswith (name, ".debug_")
	      || startswith (name, ".zdebug_")))
	{       // 跳过前缀统一匹配后续名称
          if (name[1] == 'z')
            name += sizeof (".zdebug_") - 1;
          else
            name += sizeof (".debug_") - 1;

// 根据用户启用的调试选项, 标记对应的节为需要dump
	  if (do_debugging
	      || (do_debug_info     && startswith (name, "info"))
	      || (do_debug_info     && startswith (name, "types"))
	      || (do_debug_abbrevs  && startswith (name, "abbrev"))
	      || (do_debug_lines    && strcmp (name, "line") == 0)
	      || (do_debug_lines    && startswith (name, "line."))
	      || (do_debug_pubnames && startswith (name, "pubnames"))
	      || (do_debug_pubtypes && startswith (name, "pubtypes"))
	      || (do_debug_pubnames && startswith (name, "gnu_pubnames"))
	      || (do_debug_pubtypes && startswith (name, "gnu_pubtypes"))
	      || (do_debug_aranges  && startswith (name, "aranges"))
	      || (do_debug_ranges   && startswith (name, "ranges"))
	      || (do_debug_ranges   && startswith (name, "rnglists"))
	      || (do_debug_frames   && startswith (name, "frame"))
	      || (do_debug_macinfo  && startswith (name, "macinfo"))
	      || (do_debug_macinfo  && startswith (name, "macro"))
	      || (do_debug_str      && startswith (name, "str"))
	      || (do_debug_links    && startswith (name, "sup"))
	      || (do_debug_str_offsets && startswith (name, "str_offsets"))
	      || (do_debug_loc      && startswith (name, "loc"))
	      || (do_debug_loc      && startswith (name, "loclists"))
	      || (do_debug_addr     && startswith (name, "addr"))
	      || (do_debug_cu_index && startswith (name, "cu_index"))
	      || (do_debug_cu_index && startswith (name, "tu_index"))
	      )
	    request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
	}
      else if ((do_debugging || do_debug_info)
	       && startswith (name, ".gnu.linkonce.wi."))
	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
      else if (do_debug_frames && streq (name, ".eh_frame"))
	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
      else if (do_debug_frames && streq (name, ".eh_frame_hdr"))
	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
      else if (do_gdb_index && (streq (name, ".gdb_index")
				|| streq (name, ".debug_names")))
	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
      else if ((do_debugging || do_trace_info || do_trace_abbrevs
                || do_trace_aranges)
	       && startswith (name, ".trace_"))
	{
          name += sizeof (".trace_") - 1;

if (do_debugging
	      || (do_trace_info     && streq (name, "info"))
	      || (do_trace_abbrevs  && streq (name, "abbrev"))
	      || (do_trace_aranges  && streq (name, "aranges"))
	      )
	    request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
	}
      else if ((do_debugging || do_debug_links)
	       && (startswith (name, ".gnu_debuglink")
		   || startswith (name, ".gnu_debugaltlink")))
	request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
    }

if (! do_sections)
    return true;

if (filedata->is_separate && ! process_links)
    return true;

// 打印节头表标题
  if (filedata->is_separate)
    printf (_("\nSection Headers in linked file '%s':\n"),
	    printable_string (filedata->file_name, 0));
  else if (filedata->file_header.e_shnum > 1)
    printf (_("\nSection Headers:\n"));
  else
    printf (_("\nSection Header:\n"));

// 打印节头表列标题
  if (is_32bit_elf)
    {
      if (do_section_details)
	{
	  printf (_("  [Nr] Name\n"));
	  printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
	}
      else
	printf
	  (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
    }
  else if (do_wide)
    {
      if (do_section_details)
	{
	  printf (_("  [Nr] Name\n"));
	  printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
	}
      else
	printf
	  (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
    }
  else
    {
      if (do_section_details)
	{
	  printf (_("  [Nr] Name\n"));
	  printf (_("       Type              Address          Offset            Link\n"));
	  printf (_("       Size              EntSize          Info              Align\n"));
	}
      else
	{
	  printf (_("  [Nr] Name              Type             Address           Offset\n"));
	  printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
	}
    }

if (do_section_details)
    printf (_("       Flags\n"));

// 遍历所有节头, 打印每个节的详细信息
  for (i = 0, section = filedata->section_headers;
       i < filedata->file_header.e_shnum;
       i++, section++)
    {

// 校验节头的 sh_link 字段, 关联节索引
      switch (section->sh_type)
	{
	case SHT_REL:
	case SHT_RELR:
	case SHT_RELA:
    // 动态重定位节(可执行/共享库)允许 sh_link=0
	  if (section->sh_link == 0
	      && (filedata->file_header.e_type == ET_EXEC
		  || filedata->file_header.e_type == ET_DYN))
	    break;
	case SHT_SYMTAB_SHNDX:
	case SHT_GROUP:
	case SHT_HASH:
	case SHT_GNU_HASH:
	case SHT_GNU_versym:
    // 校验: sh_link 必须是有效的符号表节索引(SHT_SYMTAB/SHT_DYNSYM)
	  if (section->sh_link == 0
	      || section->sh_link >= filedata->file_header.e_shnum
	      || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
		  && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
	    warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
		  i, section->sh_link);
	  break;

case SHT_DYNAMIC:
	case SHT_SYMTAB:
	case SHT_DYNSYM:
	case SHT_GNU_verneed:
	case SHT_GNU_verdef:
	case SHT_GNU_LIBLIST:
    // 校验: sh_link 必须是有效的字符串表节索引(SHT_STRTAB)
	  if (section->sh_link == 0
	      || section->sh_link >= filedata->file_header.e_shnum
	      || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
	    warn (_("[%2u]: Link field (%u) should index a string section.\n"),
		  i, section->sh_link);
	  break;

case SHT_INIT_ARRAY:
	case SHT_FINI_ARRAY:
	case SHT_PREINIT_ARRAY:
    // 校验: 非 OS 特定节的 sh_link 应为 0
	  if (section->sh_type < SHT_LOOS && section->sh_link != 0)
	    warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
		  i, section->sh_link);
	  break;

default:
#if 0 	  
#endif
	  break;
	}

// 校验节头的 sh_info 字段
      switch (section->sh_type)
	{
	case SHT_REL:
	case SHT_RELA:
    // 动态重定位节允许 sh_info=0
	  if (section->sh_info == 0
	      && (filedata->file_header.e_type == ET_EXEC
		  || filedata->file_header.e_type == ET_DYN))
	    break;
    // // 校验: sh_info 必须是有效的可重定位节索引
	  if (section->sh_info == 0
	      || section->sh_info >= filedata->file_header.e_shnum
	      || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
		  && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
		  && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
		  && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
		  && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
		  && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
		  /* FIXME: Are other section types valid ?  */
		  && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
	    warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
		  i, section->sh_info);
	  break;

case SHT_DYNAMIC:
	case SHT_HASH:
	case SHT_SYMTAB_SHNDX:
	case SHT_INIT_ARRAY:
	case SHT_FINI_ARRAY:
	case SHT_PREINIT_ARRAY:
    // 校验: sh_info 应为 0
	  if (section->sh_info != 0)
	    warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
		  i, section->sh_info);
	  break;

case SHT_GROUP:
	case SHT_SYMTAB:
	case SHT_DYNSYM:
	  break;

default:
	  if (section->sh_type == SHT_NOBITS)
	    ;
	  else if (section->sh_flags & SHF_INFO_LINK)
	    {
	      if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
		warn (_("[%2u]: Expected link to another section in info field"), i);
	    }
	  else if (section->sh_type < SHT_LOOS
		   && (section->sh_flags & SHF_GNU_MBIND) == 0
		   && section->sh_info != 0)
	    warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
		  i, section->sh_info);
	  break;
	}
      // 校验节大小
      if (section->sh_size > filedata->file_size
	  && section->sh_type != SHT_NOBITS
	  && section->sh_type != SHT_NULL
	  && section->sh_type < SHT_LOOS)
	warn (_("Size of section %u is larger than the entire file!\n"), i);

// 打印节头信息
      printf ("  [%2u] ", i);
      if (do_section_details)
	printf ("%s\n      ", printable_section_name (filedata, section));
      else
	print_symbol_name (-17, printable_section_name (filedata, section));

// 打印节类型
      printf (do_wide ? " %-15s " : " %-15.15s ",
	      get_section_type_name (filedata, section->sh_type));

// 32位 ELF 显示逻辑
      if (is_32bit_elf)
	{
	  const char * link_too_big = NULL;

// 节的内存地址
	  print_vma (section->sh_addr, LONG_HEX);

// 打印文件偏移, 节大小, 表项大小
	  printf ( " %6.6lx %6.6lx %2.2lx",
		   (unsigned long) section->sh_offset,
		   (unsigned long) section->sh_size,
		   (unsigned long) section->sh_entsize);

if (do_section_details)
	    fputs ("  ", stdout);
	  else
	    printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));  // 节标志

if (section->sh_link >= filedata->file_header.e_shnum)
	    {
	      link_too_big = "";
	      switch (filedata->file_header.e_machine)
		{
		case EM_386:
		case EM_IAMCU:
		case EM_X86_64:
		case EM_L1OM:
		case EM_K1OM:
		case EM_OLD_SPARCV9:
		case EM_SPARC32PLUS:
		case EM_SPARCV9:
		case EM_SPARC:
		  if (section->sh_link == (SHN_BEFORE & 0xffff))
		    link_too_big = "BEFORE";
		  else if (section->sh_link == (SHN_AFTER & 0xffff))
		    link_too_big = "AFTER";
		  break;
		default:
		  break;
		}
	    }

// 打印链接索引, 信息字段, 对齐要求
	  if (do_section_details)
	    {
	      if (link_too_big != NULL && * link_too_big)
		printf ("<%s> ", link_too_big);
	      else
		printf ("%2u ", section->sh_link);
	      printf ("%3u %2lu\n", section->sh_info,
		      (unsigned long) section->sh_addralign);
	    }
	  else
	    printf ("%2u %3u %2lu\n",
		    section->sh_link,
		    section->sh_info,
		    (unsigned long) section->sh_addralign);

if (link_too_big && ! * link_too_big)
	    warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
		  i, section->sh_link);
	}
      // 64位 ELF 宽显示模式
      else if (do_wide)
	{
	  print_vma (section->sh_addr, LONG_HEX);

if ((long) section->sh_offset == section->sh_offset)
	    printf (" %6.6lx", (unsigned long) section->sh_offset);
	  else
	    {
	      putchar (' ');
	      print_vma (section->sh_offset, LONG_HEX);
	    }

if ((unsigned long) section->sh_size == section->sh_size)
	    printf (" %6.6lx", (unsigned long) section->sh_size);
	  else
	    {
	      putchar (' ');
	      print_vma (section->sh_size, LONG_HEX);
	    }

if ((unsigned long) section->sh_entsize == section->sh_entsize)
	    printf (" %2.2lx", (unsigned long) section->sh_entsize);
	  else
	    {
	      putchar (' ');
	      print_vma (section->sh_entsize, LONG_HEX);
	    }

if (do_section_details)
	    fputs ("  ", stdout);
	  else
	    printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));

printf ("%2u %3u ", section->sh_link, section->sh_info);

if ((unsigned long) section->sh_addralign == section->sh_addralign)
	    printf ("%2lu\n", (unsigned long) section->sh_addralign);
	  else
	    {
	      print_vma (section->sh_addralign, DEC);
	      putchar ('\n');
	    }
	}
      // 64位 ELF 普通详细显示模式
      else if (do_section_details)
	{
	  putchar (' ');
	  print_vma (section->sh_addr, LONG_HEX);
	  if ((long) section->sh_offset == section->sh_offset)
	    printf ("  %16.16lx", (unsigned long) section->sh_offset);
	  else
	    {
	      printf ("  ");
	      print_vma (section->sh_offset, LONG_HEX);
	    }
	  printf ("  %u\n       ", section->sh_link);
	  print_vma (section->sh_size, LONG_HEX);
	  putchar (' ');
	  print_vma (section->sh_entsize, LONG_HEX);

printf ("  %-16u  %lu\n",
		  section->sh_info,
		  (unsigned long) section->sh_addralign);
	}
      else
	{
	  putchar (' ');
	  print_vma (section->sh_addr, LONG_HEX);
	  if ((long) section->sh_offset == section->sh_offset)
	    printf ("  %8.8lx", (unsigned long) section->sh_offset);
    // 64位 ELF 普通简洁显示模式
	  else
	    {
	      printf ("  ");
	      print_vma (section->sh_offset, LONG_HEX);
	    }
	  printf ("\n       ");
	  print_vma (section->sh_size, LONG_HEX);
	  printf ("  ");
	  print_vma (section->sh_entsize, LONG_HEX);

printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));

printf ("     %2u   %3u     %lu\n",
		  section->sh_link,
		  section->sh_info,
		  (unsigned long) section->sh_addralign);
	}

// 若为压缩节, 详细模式下补充打印节标志和压缩信息
      if (do_section_details)
	{
	  printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));

// 处理压缩节
	  if ((section->sh_flags & SHF_COMPRESSED) != 0)
	    {
	      unsigned char buf[24];

assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
	      if (get_data (&buf, filedata, section->sh_offset, 1,
			    sizeof (buf), _("compression header")))
		{
		  Elf_Internal_Chdr chdr;

// 解析压缩头部
		  if (get_compression_header (&chdr, buf, sizeof (buf)) == 0)
		    printf (_("       [<corrupt>]\n"));
		  else
		    {
		      if (chdr.ch_type == ch_compress_zlib)
			printf ("       ZLIB, ");
		      else if (chdr.ch_type == ch_compress_zstd)
			printf ("       ZSTD, ");
		      else
			printf (_("       [<unknown>: 0x%x], "),
				chdr.ch_type);
		      print_vma (chdr.ch_size, LONG_HEX);
		      printf (", %lu\n", (unsigned long) chdr.ch_addralign);
		    }
		}
	    }
	}
    }

// ... 省略一些与主逻辑无关的代码
  return true;
}
```
节头表中记录了一个个节以及他们对应的数据, 主要用于链接和调试, 告诉链接器如何把不同文件的节组合起来, 以及告诉调试器代码和数据在文件中的具体位置.

整体看下来就是对节头表的校验和打印后, 将信息存入 `filedata` 中, 值得一说的是, 每一个节头表项都有一个名字, 这个名字记录的是偏移, 在上边说的 `e_shstrndx` 中对应的 `.shstrtab` 节的字符串池中做偏移, 查找字符串.

其中调用了 `get_elf_symbols`, 解析符号表, 我们也来看看.

### get_elf_symbols
```c
static Elf_Internal_Sym *
get_elf_symbols (Filedata *filedata,
		 Elf_Internal_Shdr *section,
		 uint64_t *num_syms_return)
{
  if (is_32bit_elf)
    return get_32bit_elf_symbols (filedata, section, num_syms_return);
  else
    return get_64bit_elf_symbols (filedata, section, num_syms_return);
}
```
`get_32bit_elf_symbols` `get_64bit_elf_symbols`:
```c
static Elf_Internal_Sym *
get_32bit_elf_symbols (Filedata *filedata,
		       Elf_Internal_Shdr *section,
		       uint64_t *num_syms_return)
{
  uint64_t number = 0;
  Elf32_External_Sym * esyms = NULL;
  Elf_External_Sym_Shndx * shndx = NULL;
  Elf_Internal_Sym * isyms = NULL;
  Elf_Internal_Sym * psym;
  unsigned int j;
  elf_section_list * entry;

if (section->sh_size == 0)
    {
      if (num_syms_return != NULL)
	* num_syms_return = 0;
      return NULL;
    }

// 符号表有效性校验

// 项大小(sh_entsize)无效: 为 0 或大于节总大小
  if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
    {
      error (_("Section %s has an invalid sh_entsize of %#" PRIx64 "\n"),
	     printable_section_name (filedata, section),
	     section->sh_entsize);
      goto exit_point;
    }

// 符号表节大小超过文件总大小
  if (section->sh_size > filedata->file_size)
    {
      error (_("Section %s has an invalid sh_size of %#" PRIx64 "\n"),
	     printable_section_name (filedata, section),
	     section->sh_size);
      goto exit_point;
    }

// 符号总数: 节总大小 / 每个符号的大小
  number = section->sh_size / section->sh_entsize;

// 节大小不是项大小的整数倍, 符号表不完整, 文件损坏
  if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
    {
      error (_("Size (%#" PRIx64 ") of section %s "
	       "is not a multiple of its sh_entsize (%#" PRIx64 ")\n"),
	     section->sh_size,
	     printable_section_name (filedata, section),
	     section->sh_entsize);
      goto exit_point;
    }

// 读取原始符号表数据
  esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
                                           section->sh_size, _("symbols"));
  if (esyms == NULL)
    goto exit_point;

// 查找并读取关联的符号节索引扩展表(.shndx)
	// 当一个符号的节索引值非常大, 会使用 SHN_XINDEX 标记, 其真实的节索引值存储在一个单独的, 与符号表平行的 .shndx 节中
  shndx = NULL;
  for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
    {
			// 找到与当前处理的符号表节相匹配的 .shndx 节, sh_link 字段指向关联的符号节索引扩展表
      if (entry->hdr->sh_link != (size_t) (section - filedata->section_headers))
	continue;

// 一个符号表只能关联一个 .shndx 节, 发现多个则报错
      if (shndx != NULL)
	{
	  error (_("Multiple symbol table index sections associated with the same symbol section\n"));
	  free (shndx);
	}

// 读取 .shndx 节的数据
      shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
						   entry->hdr->sh_offset,
						   1, entry->hdr->sh_size,
						   _("symbol table section indices"));
      if (shndx == NULL)
	goto exit_point;

// 校验 .shndx 节的大小是否足够容纳所有符号的扩展索引, 它的条目数量应该至少与符号表的符号数量相等
      if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
	{
	  error (_("Index section %s has an sh_size of %#" PRIx64 " - expected %#" PRIx64 "\n"),
		 printable_section_name (filedata, entry->hdr),
		 entry->hdr->sh_size,
		 section->sh_size);
	  goto exit_point;
	}
    }

// 分配内存用于存储转换后的内部符号
  isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));

if (isyms == NULL)
    {
      error (_("Out of memory reading %" PRIu64 " symbols\n"), number);
      goto exit_point;
    }

// 将原始的, 字节序无关的外部符号转换为内部使用的符号格式
  for (j = 0, psym = isyms; j < number; j++, psym++)
    {
      psym->st_name  = BYTE_GET (esyms[j].st_name);
      psym->st_value = BYTE_GET (esyms[j].st_value);
      psym->st_size  = BYTE_GET (esyms[j].st_size);
      psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
			// 当 st_shndx 为 SHN_XINDEX 时, 从扩展表中读取真实索引
      if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
	psym->st_shndx
	  = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
			// SHN_LORESERVE 及以上是保留值, 需要调整偏移
      else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
	psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
      psym->st_info  = BYTE_GET (esyms[j].st_info);
      psym->st_other = BYTE_GET (esyms[j].st_other);
    }

exit_point:
  free (shndx);
  free (esyms);

if (num_syms_return != NULL)
    * num_syms_return = isyms == NULL ? 0 : number;

return isyms;
}

// 64 位逻辑相同, 结构体不一样
static Elf_Internal_Sym *
get_64bit_elf_symbols (Filedata *filedata,
		       Elf_Internal_Shdr *section,
		       uint64_t *num_syms_return)
{
  uint64_t number = 0;
  Elf64_External_Sym * esyms = NULL;
  Elf_External_Sym_Shndx * shndx = NULL;
  Elf_Internal_Sym * isyms = NULL;
  Elf_Internal_Sym * psym;
  unsigned int j;
  elf_section_list * entry;

if (section->sh_size == 0)
    {
      if (num_syms_return != NULL)
	* num_syms_return = 0;
      return NULL;
    }

if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
    {
      error (_("Section %s has an invalid sh_entsize of %#" PRIx64 "\n"),
	     printable_section_name (filedata, section),
	     section->sh_entsize);
      goto exit_point;
    }

if (section->sh_size > filedata->file_size)
    {
      error (_("Section %s has an invalid sh_size of %#" PRIx64 "\n"),
	     printable_section_name (filedata, section),
	     section->sh_size);
      goto exit_point;
    }

number = section->sh_size / section->sh_entsize;

if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
    {
      error (_("Size (%#" PRIx64 ") of section %s "
	       "is not a multiple of its sh_entsize (%#" PRIx64 ")\n"),
	     section->sh_size,
	     printable_section_name (filedata, section),
	     section->sh_entsize);
      goto exit_point;
    }

esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
                                           section->sh_size, _("symbols"));
  if (!esyms)
    goto exit_point;

shndx = NULL;
  for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
    {
      if (entry->hdr->sh_link != (size_t) (section - filedata->section_headers))
	continue;

if (shndx != NULL)
	{
	  error (_("Multiple symbol table index sections associated with the same symbol section\n"));
	  free (shndx);
	}

shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
						   entry->hdr->sh_offset,
						   1, entry->hdr->sh_size,
						   _("symbol table section indices"));
      if (shndx == NULL)
	goto exit_point;

if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
	{
	  error (_("Index section %s has an sh_size of %#" PRIx64 " - expected %#" PRIx64 "\n"),
		 printable_section_name (filedata, entry->hdr),
		 entry->hdr->sh_size,
		 section->sh_size);
	  goto exit_point;
	}
    }

isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));

if (isyms == NULL)
    {
      error (_("Out of memory reading %" PRIu64 " symbols\n"), number);
      goto exit_point;
    }

for (j = 0, psym = isyms; j < number; j++, psym++)
    {
      psym->st_name  = BYTE_GET (esyms[j].st_name);
      psym->st_info  = BYTE_GET (esyms[j].st_info);
      psym->st_other = BYTE_GET (esyms[j].st_other);
      psym->st_shndx = BYTE_GET (esyms[j].st_shndx);

if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
	psym->st_shndx
	  = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
      else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
	psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);

psym->st_value = BYTE_GET (esyms[j].st_value);
      psym->st_size  = BYTE_GET (esyms[j].st_size);
    }

exit_point:
  free (shndx);
  free (esyms);

if (num_syms_return != NULL)
    * num_syms_return = isyms == NULL ? 0 : number;

return isyms;
}
```
总结一下就是将符号表和扩展表的符号信息提取出来然后返回.

值得一提的是, 扩展表(.symtab_shndx 节)与符号表(.symtab 节), .symtab_shndx 节是 .symtab 节的辅助补充表, 核心作用是解决符号表中 `节索引字段位数不足` 的问题, ELF 符号表中每个符号都有 `st_shndx` 字段, 用于存储该符号所属的节索引, 当 `st_shndx` 溢出时就需要 .symtab_shndx 节来补充存储"超长节索引". 符号表与扩展表的关联通过节头的 sh_link 字段绑定, 扩展表的 sh_link 字段会存储其关联的符号表在节头表中的索引.

`Elf32_External_Sym`, `Elf64_External_Sym`, 符号表项结构体:
```c
typedef struct {
  unsigned char	st_name[4];		/* 符号名称, 字符串表中的索引 */
  unsigned char	st_value[4];		/* 符号的值 */
  unsigned char	st_size[4];		/* 符号大小, 函数符号为代码长度, 变量符号为占用字节数 */
  unsigned char	st_info[1];		/* 符号类型与绑定属性 */
  unsigned char	st_other[1];		/* 符号其他属性 */
  unsigned char	st_shndx[2];		/* 关联节索引 */
} Elf32_External_Sym;

typedef struct {
  unsigned char	st_name[4];		/* Symbol name, index in string tbl */
  unsigned char	st_info[1];		/* Type and binding attributes */
  unsigned char	st_other[1];		/* No defined meaning, 0 */
  unsigned char	st_shndx[2];		/* Associated section index */
  unsigned char	st_value[8];		/* Value of the symbol */
  unsigned char	st_size[8];		/* Associated symbol size */
} Elf64_External_Sym;
```
依旧贴出.

### process_program_headers
```c
static void
process_program_headers (Filedata * filedata)
{
  Elf_Internal_Phdr * segment;
  unsigned int i;
  Elf_Internal_Phdr * previous_load = NULL;

// ... 省略一些代码

// 需要打印段信息, 且不需要打印 ELF 文件头, 避免重复输出
  if (do_segments && !do_header)
    {
      if (filedata->is_separate)
	printf ("\nIn linked file '%s' the ELF file type is %s\n",
		printable_string (filedata->file_name, 0),
		get_file_type (filedata));
      else
	printf (_("\nElf file type is %s\n"), get_file_type (filedata));
      printf (_("Entry point 0x%" PRIx64 "\n"),
	      filedata->file_header.e_entry);								// 打印程序入口地址
      printf (ngettext ("There is %d program header,"
			" starting at offset %" PRIu64 "\n",
			"There are %d program headers,"
			" starting at offset %" PRIu64 "\n",
			filedata->file_header.e_phnum),				// 打印程序头数量和起始偏移量
	      filedata->file_header.e_phnum,
	      filedata->file_header.e_phoff);
    }

// 读取程序头表到 filedata->program_headers
  if (! get_program_headers (filedata))
    goto no_headers;

if (do_segments)
    {
      if (filedata->file_header.e_phnum > 1)
	printf (_("\nProgram Headers:\n"));
      else
	printf (_("\nProgram Headers:\n"));

// 打印表头
      if (is_32bit_elf)
	printf
	  (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
      else if (do_wide)
	printf
	  (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
      else
	{
	  printf
	    (_("  Type           Offset             VirtAddr           PhysAddr\n"));
	  printf
	    (_("                 FileSiz            MemSiz              Flags  Align\n"));
	}
    }

uint64_t dynamic_addr = 0;
  uint64_t dynamic_size = 0;

// 遍历所有程序头
  for (i = 0, segment = filedata->program_headers;
       i < filedata->file_header.e_phnum;
       i++, segment++)
    {
      if (do_segments)
	{
		// 打印段类型名称
	  printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));

// 32 位
	  if (is_32bit_elf)
	    {
	      printf ("0x%6.6lx ", (unsigned long) segment->p_offset);	// 段在文件中的偏移量
	      printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);		// 段的虚拟地址
	      printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);		// 段的物理地址
	      printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);	// 段在文件中的大小
	      printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);		// 段在内存中的大小
	      printf ("%c%c%c ",																				// 打印段权限标志
		      (segment->p_flags & PF_R ? 'R' : ' '),
		      (segment->p_flags & PF_W ? 'W' : ' '),
		      (segment->p_flags & PF_X ? 'E' : ' '));
	      printf ("%#lx", (unsigned long) segment->p_align);				// 段的对齐要求
	    }
		// 64 位宽格式打印
	  else if (do_wide)
	    {
	      if ((unsigned long) segment->p_offset == segment->p_offset)
		printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
	      else
		{
		  print_vma (segment->p_offset, FULL_HEX);
		  putchar (' ');
		}

print_vma (segment->p_vaddr, FULL_HEX);
	      putchar (' ');
	      print_vma (segment->p_paddr, FULL_HEX);
	      putchar (' ');

if ((unsigned long) segment->p_filesz == segment->p_filesz)
		printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
	      else
		{
		  print_vma (segment->p_filesz, FULL_HEX);
		  putchar (' ');
		}

if ((unsigned long) segment->p_memsz == segment->p_memsz)
		printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
				// 64 位标准格式打印
	      else
		{
		  print_vma (segment->p_memsz, FULL_HEX);
		}

printf (" %c%c%c ",
		      (segment->p_flags & PF_R ? 'R' : ' '),
		      (segment->p_flags & PF_W ? 'W' : ' '),
		      (segment->p_flags & PF_X ? 'E' : ' '));

if ((unsigned long) segment->p_align == segment->p_align)
		printf ("%#lx", (unsigned long) segment->p_align);
	      else
		{
		  print_vma (segment->p_align, PREFIX_HEX);
		}
	    }
	  else
	    {
	      print_vma (segment->p_offset, FULL_HEX);
	      putchar (' ');
	      print_vma (segment->p_vaddr, FULL_HEX);
	      putchar (' ');
	      print_vma (segment->p_paddr, FULL_HEX);
	      printf ("\n                 ");
	      print_vma (segment->p_filesz, FULL_HEX);
	      putchar (' ');
	      print_vma (segment->p_memsz, FULL_HEX);
	      printf ("  %c%c%c    ",
		      (segment->p_flags & PF_R ? 'R' : ' '),
		      (segment->p_flags & PF_W ? 'W' : ' '),
		      (segment->p_flags & PF_X ? 'E' : ' '));
	      print_vma (segment->p_align, PREFIX_HEX);
	    }

putc ('\n', stdout);
	}
			// 根据段类型(p_type)执行特定处理和合法性校验
      switch (segment->p_type)
	{
	// 可加载段: 程序运行时需要加载到内存的段
	case PT_LOAD:
#if 0 /* 不校验 PT_LOAD 段的顺序
        虽然 ELF 标准要求 PT_LOAD 段按虚拟地址递增排序, 但部分程序
        会使用非有序段, 因此禁用该校验以兼容实际场景 */
	  if (previous_load
	      && previous_load->p_vaddr > segment->p_vaddr)
	    error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
#endif
		// 段的文件大小不能大于内存大小
	  if (segment->p_memsz < segment->p_filesz)
	    error (_("the segment's file size is larger than its memory size\n"));
	  previous_load = segment;
	  break;

// 程序头表段: 存储程序头表本身的段
	case PT_PHDR:
	  if (i > 0 && previous_load != NULL)
	    error (_("the PHDR segment must occur before any LOAD segment\n"));

// 除 PARISC 架构外, PT_PHDR 段必须被某个 PT_LOAD 段覆盖, 以确保加载到内存
	  if (filedata->file_header.e_machine != EM_PARISC)
	    {
	      unsigned int j;

for (j = 1; j < filedata->file_header.e_phnum; j++)
		{
		  Elf_Internal_Phdr *load = filedata->program_headers + j;
		  if (load->p_type == PT_LOAD
		      && load->p_offset <= segment->p_offset
		      && (load->p_offset + load->p_filesz
			  >= segment->p_offset + segment->p_filesz)
		      && load->p_vaddr <= segment->p_vaddr
		      && (load->p_vaddr + load->p_filesz
			  >= segment->p_vaddr + segment->p_filesz))
		    break;
		}
	      if (j == filedata->file_header.e_phnum)
		error (_("the PHDR segment is not covered by a LOAD segment\n"));
	    }
	  break;

// 动态段: 存储动态链接相关信息
	case PT_DYNAMIC:
		// 校验: 一个 ELF 文件只能有一个动态段
	  if (dynamic_addr)
	    error (_("more than one dynamic segment\n"));

dynamic_addr = segment->p_offset;
	  dynamic_size = segment->p_filesz;

// 如果有节头表, 通过节头表精确查找 .dynamic 节
	  if (filedata->section_headers != NULL)
	    {
	      Elf_Internal_Shdr * sec;

sec = find_section (filedata, ".dynamic");
	      if (sec == NULL || sec->sh_size == 0)
		{
		  if (!is_ia64_vms (filedata))
		    error (_("no .dynamic section in the dynamic segment\n"));
		  break;
		}
				// 如果 .dynamic 节是 NOBITS 类型, 则其仅占内存, 无文件存储, 重置动态段信息
	      if (sec->sh_type == SHT_NOBITS)
		{
		  dynamic_addr = 0;
		  dynamic_size = 0;
		  break;
		}

dynamic_addr = sec->sh_offset;
	      dynamic_size = sec->sh_size;

// 校验: 动态段应与 .dynamic 节完全一致
	      if (do_checks
		  && (dynamic_addr != segment->p_offset
		      || dynamic_size != segment->p_filesz))
		warn (_("\
the .dynamic section is not the same as the dynamic segment\n"));
	    }

if (dynamic_addr > filedata->file_size
	      || (dynamic_size > filedata->file_size - dynamic_addr))
	    {
	      error (_("the dynamic segment offset + size exceeds the size of the file\n"));
	      dynamic_addr = 0;
	      dynamic_size = 0;
	    }
	  break;

// 解释器段: 存储动态链接器路径
	case PT_INTERP:
		// 校验: 解释器段的偏移量和大小是否在文件范围内, 且文件指针跳转成功
	  if (segment->p_offset >= filedata->file_size
	      || segment->p_filesz > filedata->file_size - segment->p_offset
	      || segment->p_filesz - 1 >= (size_t) -2
	      || fseek64 (filedata->handle,
			  filedata->archive_file_offset + segment->p_offset,
			  SEEK_SET))
	    error (_("Unable to find program interpreter name\n"));
	  else
	    {
	      size_t len = segment->p_filesz;
	      free (filedata->program_interpreter);
	      filedata->program_interpreter = xmalloc (len + 1);

// 从文件中读取解释器路径
	      len = fread (filedata->program_interpreter, 1, len,
			   filedata->handle);
	      filedata->program_interpreter[len] = 0;

// 如果需要打印段信息, 输出解释器路径
	      if (do_segments)
		printf (_("      [Requesting program interpreter: %s]\n"),
			printable_string (filedata->program_interpreter, 0));
	    }
	  break;
	}
    }

if (do_segments
      && filedata->section_headers != NULL
      && filedata->string_table != NULL)
    {
      printf (_("\n Section to Segment mapping:\n"));
      printf (_("  Segment Sections...\n"));

// 遍历每个段, 查找属于该段的所有节
      for (i = 0; i < filedata->file_header.e_phnum; i++)
	{
	  unsigned int j;
	  Elf_Internal_Shdr * section;

segment = filedata->program_headers + i;
	  section = filedata->section_headers + 1;	// 跳过第 0 个节, 通常是无效节

printf ("   %2.2d     ", i);

// 遍历所有节, 判断节是否属于当前段
	  for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
	    {
	      if (!ELF_TBSS_SPECIAL (section, segment)
		  && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
		printf ("%s ", printable_section_name (filedata, section));
	    }

putc ('\n',stdout);
	}
    }

// 保存动态段信息到文件数据结构
  filedata->dynamic_addr = dynamic_addr;
  filedata->dynamic_size = dynamic_size ? dynamic_size : 1;
  return;

no_headers:
  filedata->dynamic_addr = 0;
  filedata->dynamic_size = 1;
}
```
程序头表记录了一个个段, 他们描述了如何装载到内存中, 比如可执行代码段, 只读数据段, 可读写数据段等, 主要用于加载和运行, 告诉操作系统的加载器应该把文件的哪些部分映射到内存的哪个地址, 以及这些部分在内存中的访问权限.

解析和校验程序头表保存到 `filedata` 中, 都在代码中了, 我干了(狗头).

### get_program_headers
```c
static bool
get_program_headers (Filedata * filedata)
{
  Elf_Internal_Phdr * phdrs;

if (filedata->program_headers != NULL)
    return true;

if (filedata->file_header.e_phnum
      * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
      >= filedata->file_size)
    {
      error (_("Too many program headers - %#x - the file is not that big\n"),
	     filedata->file_header.e_phnum);
      return false;
    }

phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
					 sizeof (Elf_Internal_Phdr));
  if (phdrs == NULL)
    {
      error (_("Out of memory reading %u program headers\n"),
	     filedata->file_header.e_phnum);
      return false;
    }

if (is_32bit_elf
      ? get_32bit_program_headers (filedata, phdrs)
      : get_64bit_program_headers (filedata, phdrs))
    {
      filedata->program_headers = phdrs;
      return true;
    }

free (phdrs);
  return false;
}
```
不管前面的校验直接看 `get_32bit_program_headers` `get_64bit_program_headers`:
```c
static bool
get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
{
  Elf32_External_Phdr * phdrs;
  Elf32_External_Phdr * external;
  Elf_Internal_Phdr *   internal;
  unsigned int i;
  unsigned int size = filedata->file_header.e_phentsize;
  unsigned int num  = filedata->file_header.e_phnum;

if (size == 0 || num == 0)
    return false;
  if (size < sizeof * phdrs)
    {
      error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
      return false;
    }
  if (size > sizeof * phdrs)
    warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));

// 根据文件头记录的偏移和大小, 读取程序头表数据
  phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
                                            size, num, _("program headers"));
  if (phdrs == NULL)
    return false;

// 填充结构体
  for (i = 0, internal = pheaders, external = phdrs;
       i < filedata->file_header.e_phnum;
       i++, internal++, external++)
    {
      internal->p_type   = BYTE_GET (external->p_type);
      internal->p_offset = BYTE_GET (external->p_offset);
      internal->p_vaddr  = BYTE_GET (external->p_vaddr);
      internal->p_paddr  = BYTE_GET (external->p_paddr);
      internal->p_filesz = BYTE_GET (external->p_filesz);
      internal->p_memsz  = BYTE_GET (external->p_memsz);
      internal->p_flags  = BYTE_GET (external->p_flags);
      internal->p_align  = BYTE_GET (external->p_align);
    }

free (phdrs);
  return true;
}

// 同 32 位类似
static bool
get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
{
  Elf64_External_Phdr * phdrs;
  Elf64_External_Phdr * external;
  Elf_Internal_Phdr *   internal;
  unsigned int i;
  unsigned int size = filedata->file_header.e_phentsize;
  unsigned int num  = filedata->file_header.e_phnum;

phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
                                            size, num, _("program headers"));
  if (!phdrs)
    return false;

for (i = 0, internal = pheaders, external = phdrs;
       i < filedata->file_header.e_phnum;
       i++, internal++, external++)
    {
      internal->p_type   = BYTE_GET (external->p_type);
      internal->p_flags  = BYTE_GET (external->p_flags);
      internal->p_offset = BYTE_GET (external->p_offset);
      internal->p_vaddr  = BYTE_GET (external->p_vaddr);
      internal->p_paddr  = BYTE_GET (external->p_paddr);
      internal->p_filesz = BYTE_GET (external->p_filesz);
      internal->p_memsz  = BYTE_GET (external->p_memsz);
      internal->p_align  = BYTE_GET (external->p_align);
    }

free (phdrs);
  return true;
}
```
朴实无华, 接着看一下 `Elf32_External_Phdr` `Elf64_External_Phdr`:
```c
typedef struct {
  unsigned char	p_type[4];		/* 程序段类型 */
  unsigned char	p_offset[4];		/* 段在文件中的偏移量 */
  unsigned char	p_vaddr[4];		/* 段的虚拟地址 */
  unsigned char	p_paddr[4];		/* 段的物理地址 */
  unsigned char	p_filesz[4];		/* 段在文件中的大小 */
  unsigned char	p_memsz[4];		/* 段在内存中的大小 */
  unsigned char	p_flags[4];		/* 段的权限标志 */
  unsigned char	p_align[4];		/* 段的对齐要求 */
} Elf32_External_Phdr;

typedef struct {
  unsigned char	p_type[4];		/* Identifies program segment type */
  unsigned char	p_flags[4];		/* Segment flags */
  unsigned char	p_offset[8];		/* Segment file offset */
  unsigned char	p_vaddr[8];		/* Segment virtual address */
  unsigned char	p_paddr[8];		/* Segment physical address */
  unsigned char	p_filesz[8];		/* Segment size in file */
  unsigned char	p_memsz[8];		/* Segment size in memory */
  unsigned char	p_align[8];		/* Segment alignment, file & memory */
} Elf64_External_Phdr;
```
依旧贴出.

---

readelf 就到这吧, 如果全部记笔记要写很长, 删了很多, 整体读代码的方式大概就是这样, readelf.c 是一个非常全的 elf 解析.

总结一下读代码的流程: 首先跟着 `process_object` 找到你需要的功能对应的函数, 然后跟进去开读, 先把握整体, 在关心局部, 先 ai 注释, 在人工精读, 最后用自己的话总结一下. readelf 的代码整体看下来是非常好读, 质朴的 c 代码, 没有多少让人看不懂的工程化部分, 点赞. 好了开胃菜到此为止.

---

## linux-5.4.301fs/binfmt_elf.c
没有时间在为没读完 readelf 哀悼, 接下来映入眼帘的是 `elf 的加载`, 在 linux 系统中在运行一个 elf 时如何加载可执行文件或者 .so 文件

### load_elf_binary
搞清楚这个函数就知道 linux 怎么加载 elf 的了.
 ![](upload/attach/202512/1025255_GQQSZD3KJ9GQVA8.webp)
```c
static int load_elf_binary(struct linux_binprm *bprm)
{
	// 动态链接器
	struct file *interpreter = NULL;
 	unsigned long load_addr = 0, load_bias = 0;
	int load_addr_set = 0;
	unsigned long error;
	struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
	unsigned long elf_bss, elf_brk;
	int bss_prot = 0;
	int retval, i;
	unsigned long elf_entry;
	unsigned long interp_load_addr = 0;
	unsigned long start_code, end_code, start_data, end_data;
	unsigned long reloc_func_desc __maybe_unused = 0;
	int executable_stack = EXSTACK_DEFAULT;

// 存储 ELF 文件头部和动态链接器的 ELF 文件头部
	struct {
		struct elfhdr elf_ex;					// 主程序的 ELF 文件头部 
		struct elfhdr interp_elf_ex;	// 动态链接器的 ELF 文件头部
	} *loc;
	struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
	struct pt_regs *regs;

// 配内存存储 ELF 文件头部信息
	loc = kmalloc(sizeof(*loc), GFP_KERNEL);
	if (!loc) {
		retval = -ENOMEM;
		goto out_ret;
	}
	
	// 从文件缓冲区读取 ELF 文件头部, bprm->buf 已由内核预读, 
	loc->elf_ex = *((struct elfhdr *)bprm->buf);

retval = -ENOEXEC;
	// ELF 文件合法性检查

// 检查 ELF 魔数, 0x7f454c46
	if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
		goto out;

// 检查 ELF 文件类型, 必须是可执行文件(ET_EXEC)或动态链接库(ET_DYN)
	if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
		goto out;

// 检查 ELF 架构是否与当前内核匹配
	if (!elf_check_arch(&loc->elf_ex))
		goto out;

// 检查是否是 FDPIC 格式, 用于嵌入式系统的位置无关代码
	if (elf_check_fdpic(&loc->elf_ex))
		goto out;

// 检查文件系统是否支持内存映射, ELF 必须通过 mmap 加载
	if (!bprm->file->f_op->mmap)
		goto out;

// 加载 ELF 程序头表
	elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
	if (!elf_phdata)
		goto out;

elf_ppnt = elf_phdata;
	// 遍历程序头表, 查找动态链接器
	for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
		char *elf_interpreter;
		loff_t pos;

if (elf_ppnt->p_type != PT_INTERP)
			continue;

// 检测动态链接器路径长度
		retval = -ENOEXEC;
		if (elf_ppnt->p_filesz > PATH_MAX || elf_ppnt->p_filesz < 2)
			goto out_free_ph;

// 申请内存用来存储动态链接器路径
		retval = -ENOMEM;
		elf_interpreter = kmalloc(elf_ppnt->p_filesz, GFP_KERNEL);
		if (!elf_interpreter)
			goto out_free_ph;

// 根据对应程序头表的文件偏移读取动态链接器路径
		pos = elf_ppnt->p_offset;
		retval = kernel_read(bprm->file, elf_interpreter,
				     elf_ppnt->p_filesz, &pos);
		if (retval != elf_ppnt->p_filesz) {
			if (retval >= 0)
				retval = -EIO;
			goto out_free_interp;
		}

// 确保路径是以 '\0' 结尾
		retval = -ENOEXEC;
		if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
			goto out_free_interp;

// 打开动态链接器文件, open_exec 专门用于打开可执行文件
		interpreter = open_exec(elf_interpreter);
		kfree(elf_interpreter);

// 检查打开结果
		retval = PTR_ERR(interpreter);
		if (IS_ERR(interpreter))
			goto out_free_ph;

// 如果 interpreter 文件是不可读的, 强制设置 bprm->mm->dumpable = 0
		would_dump(bprm, interpreter);

// 读取动态链接器的 ELF 文件头部
		pos = 0;
		retval = kernel_read(interpreter, &loc->interp_elf_ex,
				     sizeof(loc->interp_elf_ex), &pos);
		if (retval != sizeof(loc->interp_elf_ex)) {
			if (retval >= 0)
				retval = -EIO;
			goto out_free_dentry;
		}

break;

out_free_interp:
		kfree(elf_interpreter);
		goto out_free_ph;
	}

// 处理特殊程序头部
	elf_ppnt = elf_phdata;
	for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
		switch (elf_ppnt->p_type) {
		case PT_GNU_STACK:
			if (elf_ppnt->p_flags & PF_X)
				executable_stack = EXSTACK_ENABLE_X;
			else
				executable_stack = EXSTACK_DISABLE_X;
			break;

case PT_LOPROC ... PT_HIPROC:
			retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
						  bprm->file, false,
						  &arch_state);
			if (retval)
				goto out_free_dentry;
			break;
		}

// 验证动态链接器合法性并加载其程序头部
	if (interpreter) {
		retval = -ELIBBAD;
		// 检查魔数
		if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
			goto out_free_dentry;
		// 检查动态链接器的架构
		if (!elf_check_arch(&loc->interp_elf_ex) ||
		    elf_check_fdpic(&loc->interp_elf_ex))
			goto out_free_dentry;

// 加载动态链接器的程序头部
		interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
						   interpreter);
		if (!interp_elf_phdata)
			goto out_free_dentry;

// 处理动态链接器特殊程序头部
		elf_ppnt = interp_elf_phdata;
		for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
			switch (elf_ppnt->p_type) {
			case PT_LOPROC ... PT_HIPROC:
				retval = arch_elf_pt_proc(&loc->interp_elf_ex,
							  elf_ppnt, interpreter,
							  true, &arch_state);
				if (retval)
					goto out_free_dentry;
				break;
			}
	}

// 架构特定的 ELF 验证
	retval = arch_check_elf(&loc->elf_ex,
				!!interpreter, &loc->interp_elf_ex,
				&arch_state);
	if (retval)
		goto out_free_dentry;

// 清除当前进程的旧执行上下文
	retval = flush_old_exec(bprm);
	if (retval)
		goto out_free_dentry;

// 设置进程的 personality, 用于兼容不同系统的行为, 如 SVr4, BSD
	SET_PERSONALITY2(loc->elf_ex, &arch_state);
	if (elf_read_implies_exec(loc->elf_ex, executable_stack))
		current->personality |= READ_IMPLIES_EXEC;

// 启用地址空间随机化
	if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
		current->flags |= PF_RANDOMIZE;

// 初始化新执行上下文
	setup_new_exec(bprm);
	install_exec_creds(bprm);

// 初始化参数和环境变量页面
	retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
				 executable_stack);
	if (retval < 0)
		goto out_free_dentry;
	
	elf_bss = 0;
	elf_brk = 0;

start_code = ~0UL;
	end_code = 0;
	start_data = 0;
	end_data = 0;

// 加载 ELF 程序段到内存, 重点部分
	for(i = 0, elf_ppnt = elf_phdata;
	    i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
		int elf_prot, elf_flags;			// 内存权限, mmap 标志
		unsigned long k, vaddr;				
		unsigned long total_size = 0;

// 只处理 PT_LOAD 类型的程序段
		if (elf_ppnt->p_type != PT_LOAD)
			continue;

// 如果 elf_brk > elf_bss, 说明上一个 PT_LOAD 段包含未初始化数据, 即 BSS, 清理 BSS 数据, 并确保内存权限正确
		if (unlikely (elf_brk > elf_bss)) {
			unsigned long nbyte;
	    
			retval = set_brk(elf_bss + load_bias,
					 elf_brk + load_bias,
					 bss_prot);
			if (retval)
				goto out_free_dentry;

// 从段的 p_flags 得到内存保护权限
		elf_prot = make_prot(elf_ppnt->p_flags);

// 设置 mmap 标志, 私有映射, 禁止写入, 可执行
		elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;

// 段虚拟地址
		vaddr = elf_ppnt->p_vaddr;

if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
			// 静态链接或已确定加载地址, 使用固定地址映射
			elf_flags |= MAP_FIXED;
		} else if (loc->elf_ex.e_type == ET_DYN) {
			// 动态链接的 ELF, 计算加载偏移

if (interpreter) {
				// 设置默认起始地址
				load_bias = ELF_ET_DYN_BASE;
				if (current->flags & PF_RANDOMIZE)
					// 随机基址
					load_bias += arch_mmap_rnd();
				elf_flags |= MAP_FIXED;
			} else
				// 无动态链接器, 使用随机地址映射
				load_bias = 0;

// 进行页边界对齐
			load_bias = ELF_PAGESTART(load_bias - vaddr);

// 计算 ELF 所有 PT_LOAD 段的总映射大小
			total_size = total_mapping_size(elf_phdata,
							loc->elf_ex.e_phnum);
			if (!total_size) {
				retval = -EINVAL;
				goto out_free_dentry;
			}
		}

// 将程序段映射到内存
		error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
				elf_prot, elf_flags, total_size);
		if (BAD_ADDR(error)) {
			retval = IS_ERR((void *)error) ?
				PTR_ERR((void*)error) : -EINVAL;
			goto out_free_dentry;
		}

// 如果是第一个 PT_LOAD 段, 确定加载基地址
		if (!load_addr_set) {
			load_addr_set = 1;
			// load_addr = p_vaddr - p_offset 就是段起始虚拟地址
			load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
			if (loc->elf_ex.e_type == ET_DYN) {
				// 对于动态链接的 ELF 还要考虑前面的 load_bias 与 mmap 的实际返回地址, 更新加载基地址
				load_bias += error -
				             ELF_PAGESTART(load_bias + vaddr);
				load_addr += load_bias;
				reloc_func_desc = load_bias;
			}
		}
		k = elf_ppnt->p_vaddr;
		// 代码段起始地址, 取最小值
		if (k < start_code)
			start_code = k;
		// 数据段起始地址, 数据段通常在代码段之后, 取最大值
		if (start_data < k)
			start_data = k;

// 检查地址是否合理
		if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
		    elf_ppnt->p_memsz > TASK_SIZE ||
		    TASK_SIZE - elf_ppnt->p_memsz < k) {
			retval = -EINVAL;
			goto out_free_dentry;
		}

k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;

// 更新 BSS 段起始地址
		if (k > elf_bss)
			elf_bss = k;
		// 更新代码段结束地址
		if ((elf_ppnt->p_flags & PF_X) && end_code < k)
			end_code = k;
		// 更新数据段结束地址
		if (end_data < k)
			end_data = k;
		k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
		// 更新 BSS 段结束地址
		if (k > elf_brk) {
			bss_prot = elf_prot;
			elf_brk = k;
		}
	}

// 调整所有地址到内存中的实际地址, 即加上偏移
	loc->elf_ex.e_entry += load_bias;
	elf_bss += load_bias;
	elf_brk += load_bias;
	start_code += load_bias;
	end_code += load_bias;
	start_data += load_bias;
	end_data += load_bias;

// 映射 BSS 段的剩余部分
	retval = set_brk(elf_bss, elf_brk, bss_prot);
	if (retval)
		goto out_free_dentry;
	if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
		retval = -EFAULT;
		goto out_free_dentry;
	}

// 如果存在动态链接器, 加载并初始化它
	if (interpreter) {
		// 动态链接器的映射地址
		unsigned long interp_map_addr = 0;

// 加载动态链接器并返回其重定位偏移
		elf_entry = load_elf_interp(&loc->interp_elf_ex,
					    interpreter,
					    &interp_map_addr,
					    load_bias, interp_elf_phdata);
		if (!IS_ERR((void *)elf_entry)) {
			// 动态链接器的加载地址
			interp_load_addr = elf_entry;
			// 动态链接器的入口地址
			elf_entry += loc->interp_elf_ex.e_entry;
		}
		if (BAD_ADDR(elf_entry)) {
			retval = IS_ERR((void *)elf_entry) ?
					(int)elf_entry : -EINVAL;
			goto out_free_dentry;
		}
		reloc_func_desc = interp_load_addr;

allow_write_access(interpreter);
		fput(interpreter);
	} else {
		// 静态链接程序, 口地址就是主程序的入口
		elf_entry = loc->elf_ex.e_entry;
		if (BAD_ADDR(elf_entry)) {
			retval = -EINVAL;
			goto out_free_dentry;
		}
	}

kfree(interp_elf_phdata);
	kfree(elf_phdata);

set_binfmt(&elf_format);

#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
	retval = arch_setup_additional_pages(bprm, !!interpreter);
	if (retval < 0)
		goto out;
#endif

// 创建 ELF 辅助向量(auxv)并传递给用户空间(如 AT_PHDR, AT_PHENT 等)
	retval = create_elf_tables(bprm, &loc->elf_ex,
			  load_addr, interp_load_addr);
	if (retval < 0)
		goto out;

// 初始化进程地址空间的代码段, 数据段信息
	current->mm->end_code = end_code;
	current->mm->start_code = start_code;
	current->mm->start_data = start_data;
	current->mm->end_data = end_data;
	current->mm->start_stack = bprm->p;

// 如果配置了 CONFIG_RANDOMIZE_BRK, 随机化 brk 地址
	if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {

// 对于动态链接器本身, 将 brk 移到 ELF_ET_DYN_BASE 附近, 避免与主程序冲突
		if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) &&
		    loc->elf_ex.e_type == ET_DYN && !interpreter)
			current->mm->brk = current->mm->start_brk =
				ELF_ET_DYN_BASE;

current->mm->brk = current->mm->start_brk =
			arch_randomize_brk(current->mm);
#ifdef compat_brk_randomized
		current->brk_randomized = 1;
#endif
	}

if (current->personality & MMAP_PAGE_ZERO) {
		error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
				MAP_FIXED | MAP_PRIVATE, 0);
	}

regs = current_pt_regs();
#ifdef ELF_PLAT_INIT
	ELF_PLAT_INIT(regs, reloc_func_desc);
#endif

// 将控制权移交给程序入口点
	finalize_exec(bprm);
	start_thread(regs, elf_entry, bprm->p);
	retval = 0;
out:
	kfree(loc);
out_ret:
	return retval;

out_free_dentry:
	kfree(interp_elf_phdata);
	allow_write_access(interpreter);
	if (interpreter)
		fput(interpreter);
out_free_ph:
	kfree(elf_phdata);
	goto out;
}
```
总结一下核心就是 `检查和加载`, 只用到 ELF 文件头, 程序头表的 PT_LOAD 段, 读取要执行的 ELF 文件, 然后通过 ELF 头找到程序头表, 然后将 PT_LOAD 段加载到内存, 再移交控制权到其入口(有动态链接器, 会先进入动态链接器代码). 核心思想就这么点, 不过细节却有很多, 下面通过几个点讲一下:

#### 入参
首先看一下入参 `struct linux_binprm`:
```c
struct linux_binprm {
#ifdef CONFIG_MMU										// 有内存管理单元
	struct vm_area_struct *vma;				// 指向虚拟内存区域
	unsigned long vma_pages;					// 记录了这个 vma 中包含的页数
#else
# define MAX_ARG_PAGES	32
	struct page *page[MAX_ARG_PAGES];
#endif
	struct mm_struct *mm;							// 指向新程序将要使用的内存描述符, 代表了一个进程的整个地址空间
	unsigned long p; 									// 当前用户态内存的"栈顶"地址, 加载过程中, 内核会从这个地址开始向下布置环境变量, 命令行参数和参数指针数组
	unsigned long argmin;

// 执行状态和安全标记
	unsigned int
		called_set_creds:1,
		cap_elevated:1,
		secureexec:1,
		called_exec_mmap:1;
#ifdef __alpha__
	unsigned int taso:1;
#endif
	unsigned int recursion_depth;
	struct file * file;								// 指向将要被执行的二进制文件对象
	struct cred *cred;								// 存放新程序的 uid gid suid sgid...
	int unsafe;
	unsigned int per_clear;
	int argc, envc;										// 命令行参数的个数, 环境变量的个数
	const char * filename;						// 被执行文件的路径名
	const char * interp;							// 真正被执行的二进制文件的路径名, 这个名字是给 procps 等工具看的
	unsigned interp_flags;
	unsigned interp_data;
	unsigned long loader, exec;

struct rlimit rlim_stack;

char buf[BINPRM_BUF_SIZE];				// 一个小的缓冲区, 内核用来读取二进制文件的头部信息
} __randomize_layout;
```
可以看到这个结构体中包含了很多结构体, 不再一一贴出, 总结一下就是记录新程序的种种信息, 内存, 文件对象, 路径, 参数...

#### 基址
这段代码要摘出来单独说一下:
```c
if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
	// 静态链接或已确定加载地址, 使用固定地址映射
	elf_flags |= MAP_FIXED;
} else if (loc->elf_ex.e_type == ET_DYN) {
	// 动态链接的 ELF, 计算加载偏移

if (interpreter) {
		// 设置默认起始地址
		load_bias = ELF_ET_DYN_BASE;
		if (current->flags & PF_RANDOMIZE)
			// 随机基址
			load_bias += arch_mmap_rnd();
		elf_flags |= MAP_FIXED;
	} else
		load_bias = 0;

// 进行页边界对齐
	load_bias = ELF_PAGESTART(load_bias - vaddr);

// 计算 ELF 所有 PT_LOAD 段的总映射大小
	total_size = total_mapping_size(elf_phdata,
					loc->elf_ex.e_phnum);
	if (!total_size) {
		retval = -EINVAL;
		goto out_free_dentry;
	}
}
```
如果是动态链接 ELF, 这段的计算流程大概是这样(一个例子):
- vaddr = 0x400123, 段的虚拟地址
- load_bias = 0x55555555400, 期望的内存起始页面
- load_bias = ELF_PAGESTART(load_bias - vaddr) = 0x555551553000, 向下页对齐
- load_bias + vaddr = 0x555555554123, 最终的映射地址
如果是静态链接的就直接根据 vaddr 加载.

#### BSS 段处理
BSS 段专门用来存放未初始化的全局变量和静态变量, 它在程序加载时由操作系统自动清零. 他们存在于"缝隙"之中:
```c
if (unlikely (elf_brk > elf_bss)) {
	unsigned long nbyte;
	
	retval = set_brk(elf_bss + load_bias,
				elf_brk + load_bias,
				bss_prot);
	if (retval)
		goto out_free_dentry;

nbyte = ELF_PAGEOFFSET(elf_bss);
	if (nbyte) {
		nbyte = ELF_MIN_ALIGN - nbyte;
		if (nbyte > elf_brk - elf_bss)
			nbyte = elf_brk - elf_bss;
		if (clear_user((void __user *)elf_bss +
					load_bias, nbyte)) {
		}
	}
}
```
- elf_brk 是 BSS 段结束地址, 也就是 `elf_ppnt->p_vaddr + elf_ppnt->p_memsz`, 即虚拟地址 + 段在内存中的大小.
- elf_bss 是 BSS 段起始地址, 也就是 `elf_ppnt->p_vaddr + elf_ppnt->p_filesz`, 即虚拟地址 + 段在文件中的大小.	
- 调用 `set_brk` 为 BSS 段分配内存并设置内存权限, 然后计算 `nbyte`, 将第一个页剩余部分手动清零.

举个例子:
- elf_bss = 0x601234, BSS 起始地址
- elf_brk = 0x605678, BSS 结束地址, 这里的 BSS 段跨了好几个页
- nbyte = ELF_PAGEOFFSET(elf_bss) = 0x234, 页内偏移
- nbyte = ELF_MIN_ALIGN - nbyte = 0x1000 - 0x234, 计算第一个页 BSS 所占字节数, 这一部分手动清零, 这个 `if (nbyte > elf_brk - elf_bss)` 是判断 BSS 是否都在一个页中.
- `clear_user`, 手动清零 BSS
- 中间完整页面, 虚拟地址范围 0x602000 ~ 0x605000, 通过 `set_brk` 分配的匿名映射, 程序首次访问时会触发缺页异常, 内核在程序首次访问时会自动分配并清零, 无需手动处理.
- 最后一个页面, 虚拟地址范围 0x605000 ~ 0x605678, 同样是通过 `set_brk` 分配的匿名映射, 程序首次访问时会触发缺页异常, 内核会自动分配并清零该页面中属于 BSS 段的部分.
- 那为什么第一个页面要手动分配: 因为这个第一个是已经由段分配了的, 不会有缺页异常, 内核会自动分配

#### load_elf_interp
再来看一下加载动态链接器这个函数
```c
static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
		struct file *interpreter, unsigned long *interp_map_addr,
		unsigned long no_base, struct elf_phdr *interp_elf_phdata)
{
	struct elf_phdr *eppnt;
	unsigned long load_addr = 0;
	int load_addr_set = 0;
	unsigned long last_bss = 0, elf_bss = 0;
	int bss_prot = 0;
	unsigned long error = ~0UL;
	unsigned long total_size;
	int i;

// 检查动态链接器的 ELF 类型
	if (interp_elf_ex->e_type != ET_EXEC &&
	    interp_elf_ex->e_type != ET_DYN)
		goto out;

// 检查动态链接器的架构是否与当前内核匹配
	if (!elf_check_arch(interp_elf_ex) ||
	    elf_check_fdpic(interp_elf_ex))
		goto out;

// 检查文件系统是否支持内存映射
	if (!interpreter->f_op->mmap)
		goto out;

// 计算动态链接器所有 PT_LOAD 段的总映射大小
	total_size = total_mapping_size(interp_elf_phdata,
					interp_elf_ex->e_phnum);
	if (!total_size) {
		error = -EINVAL;
		goto out;
	}

// 遍历动态链接器的程序头表
	eppnt = interp_elf_phdata;
	for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
		// 只处理PT_LOAD类型的程序段
		if (eppnt->p_type == PT_LOAD) {
			// mmap 标志
			int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
			// 内存权限
			int elf_prot = make_prot(eppnt->p_flags);
			unsigned long vaddr = 0;
			unsigned long k, map_addr;

// 将该 PT_LOAD 段映射到内存中
			vaddr = eppnt->p_vaddr;
			if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
				elf_type |= MAP_FIXED;
			else if (no_base && interp_elf_ex->e_type == ET_DYN)
				load_addr = -vaddr;

map_addr = elf_map(interpreter, load_addr + vaddr,
					eppnt, elf_prot, elf_type, total_size);
			total_size = 0;

// 记录第一个 PT_LOAD 段的映射地址
			if (!*interp_map_addr)
				*interp_map_addr = map_addr;
			error = map_addr;
			if (BAD_ADDR(map_addr))
				goto out;

// 如果是动态链接的且基地址尚未确定, 则根据实际映射地址(map_addr)计算加载基地址
			if (!load_addr_set &&
			    interp_elf_ex->e_type == ET_DYN) {
				load_addr = map_addr - ELF_PAGESTART(vaddr);
				load_addr_set = 1;
			}

// 检查段的大小是否会超出任务允许的地址空间
			k = load_addr + eppnt->p_vaddr;
			if (BAD_ADDR(k) ||
			    eppnt->p_filesz > eppnt->p_memsz ||
			    eppnt->p_memsz > TASK_SIZE ||
			    TASK_SIZE - eppnt->p_memsz < k) {
				error = -ENOMEM;
				goto out;
			}

// 确定 BSS 段的起始位置
			k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
			if (k > elf_bss)
				elf_bss = k;

// 确定 BSS 段的结束位置
			k = load_addr + eppnt->p_vaddr + eppnt->p_memsz;
			if (k > last_bss) {
				last_bss = k;
				bss_prot = elf_prot;
			}
		}
	}

// 将最后一个文件页中从 elf_bss 到页边界的部分清零
	if (padzero(elf_bss)) {
		error = -EFAULT;
		goto out;
	}

// 将 elf_bss 和内存 last_bss 都向上对齐到页大小
	elf_bss = ELF_PAGEALIGN(elf_bss);
	last_bss = ELF_PAGEALIGN(last_bss);

// 调用 vm_brk_flags 分配剩余部分
	if (last_bss > elf_bss) {
		error = vm_brk_flags(elf_bss, last_bss - elf_bss,
				bss_prot & PROT_EXEC ? VM_EXEC : 0);
		if (error)
			goto out;
	}

error = load_addr;
out:
	return error;
}
```
可以看到这个就像是简化版的 `load_elf_binary`, 没有那么多需要处理的额外情况.

---

`elf 的加载` 大致就这样, 可以看到没什么神秘的地方, 尽管在读这段代码之前, 我一直觉得它很神秘, 还记得在 `load_elf_binary` 中我们将程序入口设置在了哪吗, 没错, 动态链接器, 如果一个 ELF 有动态链接器的话, 会先执行动态链接器的代码, 接下来我们看看动态链接器的实现. let's go.
 ![](upload/attach/202512/1025255_XGT6XBX8RY36NCH.webp)

---

## bionic
 ![](upload/attach/202512/1025255_9YKEA6AB5TTKA5K.webp)
不同的架构有不同的入口, 对应一段简短的汇编
 ![](upload/attach/202512/1025255_CREHEFZ9NNPKSDA.webp)
在 `bionic/linker/arch/arm64/begin.S`:
```asm
#include <private/bionic_asm.h>

ENTRY(_start)
  .cfi_undefined x30

mov x0, sp
  bl __linker_init

// 返回主程序
  br x0
END(_start)
```
搜索 `__linker_init` 找到 `bionic/linker/linker_main.cpp`:
### __linker_init
```cpp
extern "C" ElfW(Addr) __linker_init(void* raw_args) {
  struct DlMutexUnlocker {
    ~DlMutexUnlocker() { pthread_mutex_unlock(&g_dl_mutex); }
  } unlocker;

KernelArgumentBlock args(raw_args);
	// 初始化临时 TCB
  bionic_tcb temp_tcb __attribute__((uninitialized));
  linker_memclr(&temp_tcb, sizeof(temp_tcb));
	// 初始化主线程早期环境
  __libc_init_main_thread_early(args, &temp_tcb);

ElfW(Addr) linker_addr = getauxval(AT_BASE);

// 计算链接器基地址(linker_addr)和加载偏移(load_bias)
  if (linker_addr == 0) {
    ElfW(Addr) load_bias;
    get_elf_base_from_phdr(
      reinterpret_cast<ElfW(Phdr)*>(getauxval(AT_PHDR)), getauxval(AT_PHNUM),
      &linker_addr, &load_bias);
  }

// ELF 文件头
  ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_addr);
	// 程序头表
  ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_addr + elf_hdr->e_phoff);

// 重定位链接器自身
  relocate_linker();

// 创建临时 soinfo 结构体描述链接器自身
  soinfo tmp_linker_so(nullptr, nullptr, nullptr, 0, 0);

// 填充链接器 soinfo 的核心字段

// 链接器基地址
  tmp_linker_so.base = linker_addr;
	// 加载大小
  tmp_linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum);
	// 加载偏移
  tmp_linker_so.load_bias = get_elf_exec_load_bias(elf_hdr);
	// 动态段初始为空
  tmp_linker_so.dynamic = nullptr;
	// 程序头指针
  tmp_linker_so.phdr = phdr;
	// 程序头数量
  tmp_linker_so.phnum = elf_hdr->e_phnum;
	// 标记为动态链接器
  tmp_linker_so.set_linker_flag();

// 失败则调用 __linker_cannot_link 报错
  if (!tmp_linker_so.prelink_image()) __linker_cannot_link(args.argv[0]);
  if (!tmp_linker_so.link_image(SymbolLookupList(&tmp_linker_so), &tmp_linker_so, nullptr, nullptr)) __linker_cannot_link(args.argv[0]);

return __linker_init_post_relocation(args, tmp_linker_so);
}
```
代码虽然简短, 但事却不少, 初始化 TCB, 计算基地址, 重定位自身...我们调重点看.

### get_elf_base_from_phdr
```cpp
static void get_elf_base_from_phdr(const ElfW(Phdr)* phdr_table, size_t phdr_count,
                                   ElfW(Addr)* base, ElfW(Addr)* load_bias) {
  for (size_t i = 0; i < phdr_count; ++i) {
    if (phdr_table[i].p_type == PT_PHDR) {
      *load_bias = reinterpret_cast<ElfW(Addr)>(phdr_table) - phdr_table[i].p_vaddr;
      *base = reinterpret_cast<ElfW(Addr)>(phdr_table) - phdr_table[i].p_offset;
      return;
    }
  }
}
```
通过程序头表中的 `PT_PHDR` 段计算链接器基地址(linker_addr)和加载偏移(load_bias):
- linker_addr = 程序头表实际内存地址 - 程序头表在文件中的偏移(p_offset)
- load_bias = 程序头表实际内存地址 - 程序头表的虚拟地址(p_vaddr)

### relocate_linker
```cpp
static void relocate_linker() {
	// 获取 ELF 文件头的起始地址
  auto ehdr = reinterpret_cast<ElfW(Addr)>(&__ehdr_start);
	// 计算程序头表的起始地址
  auto* phdr = reinterpret_cast<ElfW(Phdr)*>(ehdr + __ehdr_start.e_phoff);

// 遍历所有程序头, 找到 PT_DYNAMIC 类型的段
  for (size_t i = 0; i != __ehdr_start.e_phnum; ++i) {
    if (phdr[i].p_type != PT_DYNAMIC) {
      continue;
    }

// 动态链接信息
    auto *dyn = reinterpret_cast<ElfW(Dyn)*>(ehdr + phdr[i].p_vaddr);

// RELR 重定位地址/大小, PLT 重定位地址/大小, 普通重定位地址/大小
    ElfW(Addr) relr = 0, relrsz = 0, pltrel = 0, pltrelsz = 0, rel = 0, relsz = 0;
    for (size_t j = 0, size = phdr[i].p_filesz / sizeof(ElfW(Dyn)); j != size; ++j) {
			// 动态标签类型
      const auto tag = dyn[j].d_tag;
			// 标签对应的值
      const auto val = dyn[j].d_un.d_ptr;

CHECK(tag != DT_ANDROID_REL && tag != DT_ANDROID_RELA);

// 解析 RELR 重定位的地址和大小
      if (tag == DT_RELR || tag == DT_ANDROID_RELR) {
        relr = val;
      } else if (tag == DT_RELRSZ || tag == DT_ANDROID_RELRSZ) {
        relrsz = val;
      } 
			
			// 解析 PLT 段的重定位地址和大小
			else if (tag == DT_JMPREL) {
        pltrel = val;
      } else if (tag == DT_PLTRELSZ) {
        pltrelsz = val;
      }
			
			// 解析普通重定位段的地址和大小
			else if (tag == kRelTag) {
        rel = val;
      } else if (tag == kRelSzTag) {
        relsz = val;
      }
    }

// 优先处理 RELR 重定位
    if (relr && relrsz) {

relocate_relr(reinterpret_cast<ElfW(Relr*)>(ehdr + relr),
                    reinterpret_cast<ElfW(Relr*)>(ehdr + relr + relrsz), ehdr,
                    false);
    }

// 处理 PLT 段重定位, 解析函数地址
    if (pltrel && pltrelsz) {
      call_ifunc_resolvers_for_section(reinterpret_cast<RelType*>(ehdr + pltrel),
                                       reinterpret_cast<RelType*>(ehdr + pltrel + pltrelsz));
    }

// 处理普通重定位段的重定位
    if (rel && relsz) {
      call_ifunc_resolvers_for_section(reinterpret_cast<RelType*>(ehdr + rel),
                                       reinterpret_cast<RelType*>(ehdr + rel + relsz));
    }
  }
}
```
获取程序头表中的动态段, 解析重定位符号, 我们分别看看三个处理函数.

### relocate_relr
```cpp
bool relocate_relr(const ElfW(Relr) * begin, const ElfW(Relr) * end, ElfW(Addr) load_bias,
                   bool has_memtag_globals) {
  constexpr size_t wordsize = sizeof(ElfW(Addr));

// 位图模式下的基地址偏移
  ElfW(Addr) base = 0;

// 遍历所有 RELR 重定位项
  for (const ElfW(Relr)* current = begin; current < end; ++current) {
		// 读取当前 RELR 项的内容
    ElfW(Relr) entry = *current;
		// 待重定位的目标地址偏移
    ElfW(Addr) offset;

// 最低位为 0: 单个重定位项, 直接编码目标偏移
    if ((entry&1) == 0) {
			// 提取偏移值
      offset = static_cast<ElfW(Addr)>(entry);
			// 对该偏移地址执行相对重定位修正
      apply_relr_reloc(offset, load_bias, has_memtag_globals);
			// 设置后续位图项的基地址: 当前偏移 + 一个地址宽度
      base = offset + wordsize;
      continue;
    }

// 最低位为 1: 位图模式, 后续位映射批量重定位项
    offset = base;
		// 逐位解析位图
    while (entry != 0) {
      entry >>= 1;
			// 若当前比特位为 1, 表示对应偏移需要重定位
      if ((entry&1) != 0) {
        apply_relr_reloc(offset, load_bias, has_memtag_globals);
      }
			// 偏移递增一个地址宽度, 处理下一个可能的重定位项
      offset += wordsize;
    }

// 更新位图模式后的基地址: 64 位每次位图覆盖63个地址项(8*8-1), 32 位平台覆盖 31 个地址项(8*4-1)
    base += (8*wordsize - 1) * wordsize;
  }
  return true;
}
```
RELR 格式的重定位有两种模式: 单一项 / 位图项, 单一项不用说, 对单个地址重定位, 位图项是用来将相近的一段基址重定位, 以上一个单一项的偏移为基地址, 然后用当前取出来的值作为位图, 比特位为 0 位代表不需要重定位, 为 1 代表需要重定位.

可以看到, 逻辑写的非常清晰, 好代码, 我们在看看 `apply_relr_reloc`:

### apply_relr_reloc
```cpp
static void apply_relr_reloc(ElfW(Addr) offset, ElfW(Addr) load_bias, bool has_memtag_globals) {
	// 计算重定位目标在内存中的实际地址
  ElfW(Addr) destination = offset + load_bias;
  if (!has_memtag_globals) {
		// 没有启用内存标签功能, 将 destination 地址处的值加上偏移
    *reinterpret_cast<ElfW(Addr)*>(destination) += load_bias;
    return;
  }

// 启用了内存标签, 需要特殊处理以保持标签一致性

// 获取带标签的目标地址指针
  ElfW(Addr)* tagged_destination =
      reinterpret_cast<ElfW(Addr)*>(get_tagged_address(reinterpret_cast<void*>(destination)));

// 计算带标签的重定位值
  ElfW(Addr) tagged_value = reinterpret_cast<ElfW(Addr)>(
      get_tagged_address(reinterpret_cast<void*>(*tagged_destination + load_bias)));
	
	// 写入重定位后地址
  *tagged_destination = tagged_value;
}
```
还记得 `load_bias`, 在上边计算的: load_bias = 程序头表实际内存地址 - 程序头表的虚拟地址(p_vaddr), 也就是地址的内存偏移, 在 RELR 重定位中得到的值 `offset` 是预计的虚拟地址, 就像 `p_vaddr`, 需要加上 `load_bias` 后才是真实内存地址, 然后将这个地址存的值在加上 `load_bias` 完成重定位.

### call_ifunc_resolvers_for_section
```cpp
static void call_ifunc_resolvers_for_section(RelType* begin, RelType* end) {
	// 获取 ELF 文件头的基地址
  auto ehdr = reinterpret_cast<ElfW(Addr)>(&__ehdr_start);

// 遍历所有重定位项, 仅处理 IRELATIVE 类型, IFUNC 函数解析专用
  for (RelType *r = begin; r != end; ++r) {
    if (ELFW(R_TYPE)(r->r_info) != R_GENERIC_IRELATIVE) {
      continue;
    }

// 计算 GOT 表中需要被解析的目标地址
    ElfW(Addr)* offset = reinterpret_cast<ElfW(Addr)*>(ehdr + r->r_offset);
#if defined(USE_RELA)
		// RELA 格式: 重定位项包含 addend 字段, 直接从 r_addend 获取解析器地址
    ElfW(Addr) resolver = ehdr + r->r_addend;
#else
		// REL 格式: 解析器地址存储在目标偏移指向的内存中
    ElfW(Addr) resolver = ehdr + *offset;
#endif
		// 调用 IFUNC 解析器, 将解析后的实际函数地址写入 GOT 表
    *offset = __bionic_call_ifunc_resolver(resolver);
  }
}

ElfW(Addr) __bionic_call_ifunc_resolver(ElfW(Addr) resolver_addr) {
	// 调用 IFUNC 解析器函数, 根据不同架构传递参数并获取最终函数地址

#if defined(__aarch64__)
	// ARM64 架构: IFUNC 解析器需接收硬件能力标志和扩展参数结构体
  typedef ElfW(Addr) (*ifunc_resolver_t)(uint64_t, __ifunc_arg_t*);
  BIONIC_USED_BEFORE_LINKER_RELOCATES static __ifunc_arg_t arg;
  BIONIC_USED_BEFORE_LINKER_RELOCATES static bool initialized = false;
  if (!initialized) {
    initialized = true;
    arg._size = sizeof(__ifunc_arg_t);
    arg._hwcap = getauxval(AT_HWCAP);
    arg._hwcap2 = getauxval(AT_HWCAP2);
  }
  return reinterpret_cast<ifunc_resolver_t>(resolver_addr)(arg._hwcap | _IFUNC_ARG_HWCAP, &arg);
#elif defined(__arm__)
	// ARM32 架构: IFUNC 解析器仅接收硬件能力标志
  typedef ElfW(Addr) (*ifunc_resolver_t)(unsigned long);
  static unsigned long hwcap = getauxval(AT_HWCAP);
  return reinterpret_cast<ifunc_resolver_t>(resolver_addr)(hwcap);
#elif defined(__riscv)
	// RISC-V 架构: IFUNC 解析器接收硬件能力, hwprobe 信息及保留参数
  typedef ElfW(Addr) (*ifunc_resolver_t)(uint64_t, __riscv_hwprobe_t, void*);
  static uint64_t hwcap = getauxval(AT_HWCAP);
  return reinterpret_cast<ifunc_resolver_t>(resolver_addr)(hwcap, __riscv_hwprobe, nullptr);
#else
	// 其他架构(如 x86): IFUNC 解析器无需参数, 直接调用
  typedef ElfW(Addr) (*ifunc_resolver_t)(void);
  return reinterpret_cast<ifunc_resolver_t>(resolver_addr)();
#endif
}
```
这里要讲一下 IFUNC 机制, Indirect Function, 即间接函数. 运行时动态选择函数实现, 也就是添加了一个中间层, 为兼容性和优化创造了条件.
- 首先在 `call_ifunc_resolvers_for_section` 中遍历重定位段, 仅处理 IRELATIVE 类型重定位项, 处理这些项, 得到在 GOT 表中的对应的函数槽位以及 `虚拟地址偏移`, 在用 `ELF 基地址` + `虚拟地址偏移`, 得到 `中间函数地址`.
- 然后调用 `中间函数地址`, 根据架构传递硬件信息, 调用 `中间函数`, 得到实际函数实现地址, 返回实际函数实现地址.
- 最后将实际函数地址写回 GOT 表, 这样下次在调用可以直接通过 GOT 表获取, 不再需要中间层函数. 增加运行速度.

### prelink_image
回到 `__linker_init` 接着往下看, 来到了 `prelink_image` 函数
```cpp
bool soinfo::prelink_image(bool dlext_use_relro) {
	// 若已完成预链接, 直接返回成功
  if (flags_ & FLAG_PRELINKED) return true;

// 提取动态段的地址和属性
  ElfW(Word) dynamic_flags = 0;
  phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic, &dynamic_flags);

bool relocating_linker = (flags_ & FLAG_LINKER) != 0;
  if (!relocating_linker) {
    LD_DEBUG(any, "[ Linking \"%s\" ]", get_realpath());
    LD_DEBUG(any, "si->base = %p si->flags = 0x%08x", reinterpret_cast<void*>(base), flags_);
  }

if (dynamic == nullptr) {
    if (!relocating_linker) {
      DL_ERR("missing PT_DYNAMIC in \"%s\"", get_realpath());
    }
    return false;
  } else {
    if (!relocating_linker) {
      LD_DEBUG(dynamic, "dynamic section @%p", dynamic);
    }
  }

#if defined(__arm__)
	// ARM架构: 提取 ARM 异常索引表, 用于异常处理
  (void) phdr_table_get_arm_exidx(phdr, phnum, load_bias,
                                  &ARM_exidx, &ARM_exidx_count);
#endif

// 解析 TLS 段信息
  TlsSegment tls_segment;
  if (__bionic_get_tls_segment(phdr, phnum, load_bias, &tls_segment)) {
    CHECK(!relocating_linker && "TLS not supported in loader");
		// 验证 TLS 段对齐是否为 2 的幂次
    if (!__bionic_check_tls_align(tls_segment.aligned_size.align.value)) {
      DL_ERR("TLS segment alignment in \"%s\" is not a power of 2: %zu", get_realpath(),
             tls_segment.aligned_size.align.value);
      return false;
    }
    tls_ = std::make_unique<soinfo_tls>();
    tls_->segment = tls_segment;
  }

// 遍历动态段条目, 提取关键信息(符号表, 重定位表, 构造函数等)
  uint32_t needed_count = 0;
  for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
    LD_DEBUG(dynamic, "dynamic entry @%p: d_tag=%p, d_val=%p",
             d, reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
    switch (d->d_tag) {
      case DT_SONAME:
        // 库名称, 需在字符串表初始化后解析, 延后处理
        break;

case DT_HASH:
				// 传统 ELF 哈希表: 初始化桶数, 链数及指针
        nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
        nchain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
        bucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8);
        chain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8 + nbucket_ * 4);
        break;

case DT_GNU_HASH:
				// GNU 扩展哈希表: 初始化过滤器, 桶和链
        gnu_nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
        gnu_maskwords_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[2];
        gnu_shift2_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[3];
        gnu_bloom_filter_ = reinterpret_cast<ElfW(Addr)*>(load_bias + d->d_un.d_ptr + 16);
        gnu_bucket_ = reinterpret_cast<uint32_t*>(gnu_bloom_filter_ + gnu_maskwords_);
        gnu_chain_ = gnu_bucket_ + gnu_nbucket_ -
            reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];

// 验证过滤器大小是否为 2 的幂次
        if (!powerof2(gnu_maskwords_)) {
          DL_ERR("invalid maskwords for gnu_hash = 0x%x, in \"%s\" expecting power to two",
              gnu_maskwords_, get_realpath());
          return false;
        }
        --gnu_maskwords_;

// 标记使用 GNU 哈希
        flags_ |= FLAG_GNU_HASH;
        break;

case DT_STRTAB:
				// 字符串表基地址
        strtab_ = reinterpret_cast<const char*>(load_bias + d->d_un.d_ptr);
        break;

case DT_STRSZ:
				// 字符串表大小
        strtab_size_ = d->d_un.d_val;
        break;

case DT_SYMTAB:
				// 符号表基地址, 存储函数/变量的符号信息
        symtab_ = reinterpret_cast<ElfW(Sym)*>(load_bias + d->d_un.d_ptr);
        break;

case DT_SYMENT:
				// 符号表项大小, 必须与 ElfW(Sym) 大小一致
        if (d->d_un.d_val != sizeof(ElfW(Sym))) {
          DL_ERR("invalid DT_SYMENT: %zd in \"%s\"",
              static_cast<size_t>(d->d_un.d_val), get_realpath());
          return false;
        }
        break;

case DT_PLTREL:
			// PLT 重定位类型, REL/RELA 需与编译配置一致
#if defined(USE_RELA)
        if (d->d_un.d_val != DT_RELA) {
          DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_RELA", get_realpath());
          return false;
        }
#else
        if (d->d_un.d_val != DT_REL) {
          DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_REL", get_realpath());
          return false;
        }
#endif
        break;

case DT_JMPREL:
			// PLT 重定位表地址, 包含函数跳转表的重定位项
#if defined(USE_RELA)
        plt_rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
#else
        plt_rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
#endif
        break;

case DT_PLTRELSZ:
			// PLT 重定位表大小, 计算重定位项数量
#if defined(USE_RELA)
        plt_rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
#else
        plt_rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
#endif
        break;

case DT_PLTGOT:
        // PLT的 GOT 表地址
        break;

case DT_DEBUG:
				// 调试器支持
        if ((dynamic_flags & PF_W) != 0) {
          d->d_un.d_val = reinterpret_cast<uintptr_t>(&_r_debug);
        }
        break;
#if defined(USE_RELA)
      case DT_RELA:
				// 普通 RELA 重定位表地址
        rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
        break;

case DT_RELASZ:
				// RELA 重定位表大小
        rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
        break;

case DT_ANDROID_RELA:
				// Android 扩展 RELA 重定位表地址
        android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr);
        break;

case DT_ANDROID_RELASZ:
				// Android 扩展 RELA 重定位表大小
        android_relocs_size_ = d->d_un.d_val;
        break;

case DT_ANDROID_REL:
        DL_ERR("unsupported DT_ANDROID_REL in \"%s\"", get_realpath());
        return false;

case DT_ANDROID_RELSZ:
        DL_ERR("unsupported DT_ANDROID_RELSZ in \"%s\"", get_realpath());
        return false;

case DT_RELAENT:
				// RELA 项大小
        if (d->d_un.d_val != sizeof(ElfW(Rela))) {
          DL_ERR("invalid DT_RELAENT: %zd", static_cast<size_t>(d->d_un.d_val));
          return false;
        }
        break;

case DT_RELACOUNT:
        break;

case DT_REL:
        DL_ERR("unsupported DT_REL in \"%s\"", get_realpath());
        return false;

case DT_RELSZ:
        DL_ERR("unsupported DT_RELSZ in \"%s\"", get_realpath());
        return false;

#else
      case DT_REL:
				// REL 重定位表地址
        rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
        break;

case DT_RELSZ:
				// REL 重定位表大小, 计算项数量
        rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
        break;

case DT_RELENT:
				// REL 项大小
        if (d->d_un.d_val != sizeof(ElfW(Rel))) {
          DL_ERR("invalid DT_RELENT: %zd", static_cast<size_t>(d->d_un.d_val));
          return false;
        }
        break;

case DT_ANDROID_REL:
				// Android 扩展 REL 重定位表地址
        android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr);
        break;

case DT_ANDROID_RELSZ:
				// Android 扩展 REL 重定位表大小
        android_relocs_size_ = d->d_un.d_val;
        break;

case DT_ANDROID_RELA:
        DL_ERR("unsupported DT_ANDROID_RELA in \"%s\"", get_realpath());
        return false;

case DT_ANDROID_RELASZ:
        DL_ERR("unsupported DT_ANDROID_RELASZ in \"%s\"", get_realpath());
        return false;

case DT_RELCOUNT:
        break;

case DT_RELA:
        DL_ERR("unsupported DT_RELA in \"%s\"", get_realpath());
        return false;

case DT_RELASZ:
        DL_ERR("unsupported DT_RELASZ in \"%s\"", get_realpath());
        return false;

#endif
      case DT_RELR:
      case DT_ANDROID_RELR:
				// RELR 重定位表地址
        relr_ = reinterpret_cast<ElfW(Relr)*>(load_bias + d->d_un.d_ptr);
        break;

case DT_RELRSZ:
      case DT_ANDROID_RELRSZ:
				// RELR 重定位表大小
        relr_count_ = d->d_un.d_val / sizeof(ElfW(Relr));
        break;

case DT_RELRENT:
      case DT_ANDROID_RELRENT:
				// RELR 项大小验证
        if (d->d_un.d_val != sizeof(ElfW(Relr))) {
          DL_ERR("invalid DT_RELRENT: %zd", static_cast<size_t>(d->d_un.d_val));
          return false;
        }
        break;

case DT_ANDROID_RELRCOUNT:
        break;

case DT_INIT:
				// 初始化函数, 旧版构造函数
        init_func_ = reinterpret_cast<linker_ctor_function_t>(load_bias + d->d_un.d_ptr);
        LD_DEBUG(dynamic, "%s constructors (DT_INIT) found at %p", get_realpath(), init_func_);
        break;

case DT_FINI:
				// 析构函数, 旧版析构函数
        fini_func_ = reinterpret_cast<linker_dtor_function_t>(load_bias + d->d_un.d_ptr);
        LD_DEBUG(dynamic, "%s destructors (DT_FINI) found at %p", get_realpath(), fini_func_);
        break;

case DT_INIT_ARRAY:
				// 初始化函数数组, 新版构造函数
        init_array_ = reinterpret_cast<linker_ctor_function_t*>(load_bias + d->d_un.d_ptr);
        LD_DEBUG(dynamic, "%s constructors (DT_INIT_ARRAY) found at %p", get_realpath(), init_array_);
        break;

case DT_INIT_ARRAYSZ:
				// 初始化函数数组大小
        init_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
        break;

case DT_FINI_ARRAY:
				// 析构函数数组, 新版析构函数
        fini_array_ = reinterpret_cast<linker_dtor_function_t*>(load_bias + d->d_un.d_ptr);
        LD_DEBUG(dynamic, "%s destructors (DT_FINI_ARRAY) found at %p", get_realpath(), fini_array_);
        break;

case DT_FINI_ARRAYSZ:
				// 析构函数数组大小
        fini_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
        break;

case DT_PREINIT_ARRAY:
				// 预初始化函数数组
        preinit_array_ = reinterpret_cast<linker_ctor_function_t*>(load_bias + d->d_un.d_ptr);
        LD_DEBUG(dynamic, "%s constructors (DT_PREINIT_ARRAY) found at %p", get_realpath(), preinit_array_);
        break;

case DT_PREINIT_ARRAYSZ:
				// 预初始化函数数组大小
        preinit_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
        break;

case DT_TEXTREL:
			// 文本段重定位
#if defined(__LP64__)
        DL_ERR("\"%s\" has text relocations", get_realpath());
        return false;
#else
        has_text_relocations = true;
        break;
#endif

case DT_SYMBOLIC:
				// 符号解析优先级, 优先使用库内符号
        has_DT_SYMBOLIC = true;
        break;

case DT_NEEDED:
				// 依赖库计数
        ++needed_count;
        break;

case DT_FLAGS:
				// 动态段标志
        if (d->d_un.d_val & DF_TEXTREL) {
#if defined(__LP64__)
          DL_ERR("\"%s\" has text relocations", get_realpath());
          return false;
#else
          has_text_relocations = true;
#endif
        }
        if (d->d_un.d_val & DF_SYMBOLIC) {
          has_DT_SYMBOLIC = true;
        }
        break;

case DT_FLAGS_1:
				// 扩展动态标志
        set_dt_flags_1(d->d_un.d_val);

if ((d->d_un.d_val & ~SUPPORTED_DT_FLAGS_1) != 0) {
          DL_WARN("Warning: \"%s\" has unsupported flags DT_FLAGS_1=%p "
                  "(ignoring unsupported flags)",
                  get_realpath(), reinterpret_cast<void*>(d->d_un.d_val));
        }
        break;

case DT_BIND_NOW:
        break;

case DT_VERSYM:
				// 版本符号表
        versym_ = reinterpret_cast<ElfW(Versym)*>(load_bias + d->d_un.d_ptr);
        break;

case DT_VERDEF:
				// 版本定义表地址
        verdef_ptr_ = load_bias + d->d_un.d_ptr;
        break;
      case DT_VERDEFNUM:
				// 版本定义数量
        verdef_cnt_ = d->d_un.d_val;
        break;

case DT_VERNEED:
				// 版本依赖表地址
        verneed_ptr_ = load_bias + d->d_un.d_ptr;
        break;

case DT_VERNEEDNUM:
				// 版本依赖数量
        verneed_cnt_ = d->d_un.d_val;
        break;

case DT_RUNPATH:
        // 运行时库搜索路径, 需字符串表初始化后解析
        break;

case DT_TLSDESC_GOT:
      case DT_TLSDESC_PLT:
				// TLS 描述符, bionic 不支持懒加载, 忽略
        break;

#if defined(__aarch64__)
      case DT_AARCH64_BTI_PLT:
      case DT_AARCH64_PAC_PLT:
      case DT_AARCH64_VARIANT_PCS:
        break;
      case DT_AARCH64_MEMTAG_MODE:
				// ARM64 MTE 模式, 内存标记模式
        memtag_dynamic_entries_.has_memtag_mode = true;
        memtag_dynamic_entries_.memtag_mode = d->d_un.d_val;
        break;
      case DT_AARCH64_MEMTAG_HEAP:
				// MTE 堆标记配置
        memtag_dynamic_entries_.memtag_heap = d->d_un.d_val;
        break;
      case DT_AARCH64_MEMTAG_STACK:
				// MTE 栈标记配置
        memtag_dynamic_entries_.memtag_stack = d->d_un.d_val;
        break;
      case DT_AARCH64_MEMTAG_GLOBALS:
				// MTE 全局变量标记配置
        memtag_dynamic_entries_.memtag_globals = reinterpret_cast<void*>(load_bias + d->d_un.d_ptr);
        break;
      case DT_AARCH64_MEMTAG_GLOBALSSZ:
				// MTE 全局变量标记区域大小
        memtag_dynamic_entries_.memtag_globalssz = d->d_un.d_val;
        break;
#endif

default:
				// 忽略未知动态标签, 输出警告
        if (!relocating_linker) {
          const char* tag_name;
          if (d->d_tag == DT_RPATH) {
            tag_name = "DT_RPATH";
          } else if (d->d_tag == DT_ENCODING) {
            tag_name = "DT_ENCODING";
          } else if (d->d_tag >= DT_LOOS && d->d_tag <= DT_HIOS) {
            tag_name = "unknown OS-specific";
          } else if (d->d_tag >= DT_LOPROC && d->d_tag <= DT_HIPROC) {
            tag_name = "unknown processor-specific";
          } else {
            tag_name = "unknown";
          }
          DL_WARN("Warning: \"%s\" unused DT entry: %s (type %p arg %p) (ignoring)",
                  get_realpath(),
                  tag_name,
                  reinterpret_cast<void*>(d->d_tag),
                  reinterpret_cast<void*>(d->d_un.d_val));
        }
        break;
    }
  }

LD_DEBUG(dynamic, "si->base = %p, si->strtab = %p, si->symtab = %p",
           reinterpret_cast<void*>(base), strtab_, symtab_);

// 合法性校验

// 链接器不能有依赖库, DT_NEEDED
  if (relocating_linker && needed_count != 0) {
    DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
    return false;
  }
	// 必须有哈希表, 传统或 GNU 哈希二选一
  if (nbucket_ == 0 && gnu_nbucket_ == 0) {
    DL_ERR("empty/missing DT_HASH/DT_GNU_HASH in \"%s\" "
        "(new hash type from the future?)", get_realpath());
    return false;
  }
	// 字符串表不能为空
  if (strtab_ == nullptr) {
    DL_ERR("empty/missing DT_STRTAB in \"%s\"", get_realpath());
    return false;
  }
	// 符号表不能为空
  if (symtab_ == nullptr) {
    DL_ERR("empty/missing DT_SYMTAB in \"%s\"", get_realpath());
    return false;
  }

// 二次遍历: 处理遗留的库名称与运行时库搜索路径, 解析依赖字符串表
  if (!relocating_linker) {
    for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
      switch (d->d_tag) {
        case DT_SONAME:
          set_soname(get_string(d->d_un.d_val));
          break;
        case DT_RUNPATH:
          set_dt_runpath(get_string(d->d_un.d_val));
          break;
      }
    }
  }

// 兼容处理: API 23前无 SONAME 的库, 使用 basename 作为 SONAME
  if (soname_.empty() && this != solist_get_executable() && !relocating_linker &&
      get_application_target_sdk_version() < 23) {
    soname_ = basename(realpath_.c_str());
    DL_ERROR_AFTER(23, "\"%s\" has no DT_SONAME (will use %s instead)",
                   get_realpath(), soname_.c_str());
  }

// 验证版本定义节
  if (!validate_verdef_section(this)) return false;

// ARM64 MTE 全局变量支持: 重新映射数据段为匿名映射
  if (should_tag_memtag_globals() &&
      remap_memtag_globals_segments(phdr, phnum, base) == 0) {
    tag_globals(dlext_use_relro);
    protect_memtag_globals_ro_segments(phdr, phnum, base);
  }

// 标记预链接完成
  flags_ |= FLAG_PRELINKED;
  return true;
}
```
整体看下来, 主要是就是在遍历解析动态段的信息, 先找到动态段位置, 然后遍历, 保存信息, 然后在做一些校验.

额外说明 `ARM64 MTE`: MTE 通过给内存地址和指针添加 "标签", 并在内存访问时验证标签匹配性, 实现对非法内存访问的实时检测, 将物理内存按 16 字节划分, 每个 16 字节块分配一个 5 位的 "内存标签", 64 位虚拟地址的高 8 位(bit 56-63)中预留 5 位作为 "指针标签", 用于存储对应内存块的标签值.

还有哈希表, 这个也要介绍一下, 传统哈希表(DT_HASH)和 GNU 哈希表(DT_GNU_HASH)都是用于"根据符号名快速找到对应的符号地址"这一问题, 当程序调用外部函数或者访问全局变量时, 需要通过符号名在符号表中找到对应的内存地址, 哈希表的作用就是将符号名映射为哈希值, 通过哈希表快速定位符号在符号表中的位置, 避免线性遍历符号表.

### link_image
回到 `__linker_init` 接着往下看, 来到了 `link_image` 函数
```cpp
bool soinfo::link_image(const SymbolLookupList& lookup_list, soinfo* local_group_root,
                        const android_dlextinfo* extinfo, size_t* relro_fd_offset) {
	// 若已完成镜像链接, 直接返回成功
  if (is_image_linked()) {
    return true;
  }

if (g_is_ldd && !is_main_executable()) {
    async_safe_format_fd(STDOUT_FILENO, "\t%s => %s (%p)\n", get_soname(),
                         get_realpath(), reinterpret_cast<void*>(base));
  }

// 设置本地符号组根节点
  local_group_root_ = local_group_root;
  if (local_group_root_ == nullptr) {
    local_group_root_ = this;
  }

if ((flags_ & FLAG_LINKER) == 0 && local_group_root_ == this) {
    target_sdk_version_ = get_application_target_sdk_version();
  }

#if !defined(__LP64__)
	// 32位系统: 处理文本段重定位, 64 位系统禁止文本重定位
  if (has_text_relocations) {
    if (DL_ERROR_AFTER(23, "\"%s\" has text relocations", get_realpath())) {
      return false;
    }
    add_dlwarning(get_realpath(), "text relocations");
    if (phdr_table_unprotect_segments(phdr, phnum, load_bias, should_pad_segments_,
                                      should_use_16kib_app_compat_) < 0) {
      DL_ERR("can't unprotect loadable segments for \"%s\": %m", get_realpath());
      return false;
    }
  }
#endif

// 执行重定位
  if (this != solist_get_vdso() && !relocate(lookup_list)) {
    return false;
  }

LD_DEBUG(any, "[ finished linking %s ]", get_realpath());

#if !defined(__LP64__)
  if (has_text_relocations) {
    // 32位系统: 重定位完成后恢复段保护, 设为只读
    if (phdr_table_protect_segments(phdr, phnum, load_bias, should_pad_segments_,
                                    should_use_16kib_app_compat_) < 0) {
      DL_ERR("can't protect segments for \"%s\": %m", get_realpath());
      return false;
    }
  }
#endif

// RELRO 段保护, 链接器自身的延后处理, 因为尚未初始化系统调用
  if (!is_linker() && !protect_relro()) {
    return false;
  }

// 不管下面这些
  if (should_tag_memtag_globals()) {
    std::list<std::string>* vma_names_ptr = vma_names();
    CHECK(vma_names_ptr);
    name_memtag_globals_segments(phdr, phnum, base, get_realpath(), vma_names_ptr);
  }

if (extinfo && (extinfo->flags & ANDROID_DLEXT_WRITE_RELRO)) {
    if (phdr_table_serialize_gnu_relro(phdr, phnum, load_bias,
                                       extinfo->relro_fd, relro_fd_offset) < 0) {
      DL_ERR("failed serializing GNU RELRO section for \"%s\": %m", get_realpath());
      return false;
    }
  } else if (extinfo && (extinfo->flags & ANDROID_DLEXT_USE_RELRO)) {
    if (phdr_table_map_gnu_relro(phdr, phnum, load_bias,
                                 extinfo->relro_fd, relro_fd_offset) < 0) {
      DL_ERR("failed mapping GNU RELRO section for \"%s\": %m", get_realpath());
      return false;
    }
  }

++g_module_load_counter;
  notify_gdb_of_load(this);
	// 标记镜像链接完成
  set_image_linked();
  return true;
}
```
这个只是一个包装方法, 实际是调用 `relocate` 方法处理, 跟入 `relocate`:

### relocate
```cpp
bool soinfo::relocate(const SymbolLookupList& lookup_list) {
  if (g_is_ldd) {
    return true;
  }

VersionTracker version_tracker;

if (!version_tracker.init(this)) {
    return false;
  }

// 初始化重定位器
  Relocator relocator(version_tracker, lookup_list);
  relocator.si = this;
  relocator.si_strtab = strtab_;
  relocator.si_strtab_size = is_lp64_or_has_min_version(1) ? strtab_size_ : SIZE_MAX;
  relocator.si_symtab = symtab_;
  relocator.tlsdesc_args = &tlsdesc_args_;
  relocator.tls_tp_base = __libc_shared_globals()->static_tls_layout.offset_thread_pointer();

// 处理 RELR 重定位, 如果是链接器就跳过, 链接器已处理过了, 调用的是在上边 relocate_relr 方法
  if (relr_ != nullptr && !is_linker()) {
    LD_DEBUG(reloc, "[ relocating %s relr ]", get_realpath());
    const ElfW(Relr)* begin = relr_;
    const ElfW(Relr)* end = relr_ + relr_count_;
    if (!relocate_relr(begin, end, load_bias, should_tag_memtag_globals())) {
      return false;
    }
  }

// 处理 Android 扩展压缩重定位, APK2 格式
  if (android_relocs_ != nullptr) {

// 验证压缩重定位头部签名, 必须为 "APS2"
    if (android_relocs_size_ > 3 &&
        android_relocs_[0] == 'A' &&
        android_relocs_[1] == 'P' &&
        android_relocs_[2] == 'S' &&
        android_relocs_[3] == '2') {
      LD_DEBUG(reloc, "[ relocating %s android rel/rela ]", get_realpath());

const uint8_t* packed_relocs = android_relocs_ + 4;
      const size_t packed_relocs_size = android_relocs_size_ - 4;

// 解压并执行压缩重定位
      if (!packed_relocate<RelocMode::Typical>(relocator, sleb128_decoder(packed_relocs, packed_relocs_size))) {
        return false;
      }
    } else {
      DL_ERR("bad android relocation header.");
      return false;
    }
  }

#if defined(USE_RELA)
	// 处理普通 RELA 重定位
  if (rela_ != nullptr) {
    LD_DEBUG(reloc, "[ relocating %s rela ]", get_realpath());

if (!plain_relocate<RelocMode::Typical>(relocator, rela_, rela_count_)) {
      return false;
    }
  }
	// 处理 PLT 的 RELA 重定位(函数跳转表重定位)
  if (plt_rela_ != nullptr) {
    LD_DEBUG(reloc, "[ relocating %s plt rela ]", get_realpath());
    if (!plain_relocate<RelocMode::JumpTable>(relocator, plt_rela_, plt_rela_count_)) {
      return false;
    }
  }
#else
	// 处理普通 REL 重定位
  if (rel_ != nullptr) {
    LD_DEBUG(reloc, "[ relocating %s rel ]", get_realpath());
    if (!plain_relocate<RelocMode::Typical>(relocator, rel_, rel_count_)) {
      return false;
    }
  }
	// 处理 PLT 的 REL 重定位(函数跳转表重定位)
  if (plt_rel_ != nullptr) {
   LD_DEBUG(reloc, "[ relocating %s plt rel ]", get_realpath());
    if (!plain_relocate<RelocMode::JumpTable>(relocator, plt_rel_, plt_rel_count_)) {
      return false;
    }
  }
#endif

// 处理延迟的 TLS 描述符重定位, 仅 ARM64/RISC-V 支持
#if defined(__aarch64__) || defined(__riscv)
  for (const std::pair<TlsDescriptor*, size_t>& pair : relocator.deferred_tlsdesc_relocs) {
    TlsDescriptor* desc = pair.first;
    desc->func = tlsdesc_resolver_dynamic;
    desc->arg = reinterpret_cast<size_t>(&tlsdesc_args_[pair.second]);
  }
#endif // defined(__aarch64__) || defined(__riscv)

return true;
}
```
### plain_relocate 一系列
```cpp
template <RelocMode OptMode, typename ...Args>
static bool plain_relocate(Relocator& relocator, Args ...args) {
  return needs_slow_relocate_loop(relocator) ?
      plain_relocate_impl<RelocMode::General>(relocator, args...) : // 通用模式
      plain_relocate_impl<OptMode>(relocator, args...);             // 优化模式
}

template <RelocMode Mode>
__attribute__((noinline))
static bool plain_relocate_impl(Relocator& relocator, rel_t* rels, size_t rel_count) {
  // 遍历每个重定位项, 逐个处理
  for (size_t i = 0; i < rel_count; ++i) {
    if (!process_relocation<Mode>(relocator, rels[i])) {
      return false;
    }
  }
  return true;
}

template <RelocMode Mode>
__attribute__((always_inline))
static inline bool process_relocation(Relocator& relocator, const rel_t& reloc) {
  return Mode == RelocMode::General ?
      process_relocation_general(relocator, reloc) :
      process_relocation_impl<Mode>(relocator, reloc);
}

__attribute__((noinline))
static bool process_relocation_general(Relocator& relocator, const rel_t& reloc) {
  return process_relocation_impl<RelocMode::General>(relocator, reloc);
}

// 参数 reloc 是单个重定位项
template <RelocMode Mode>
__attribute__((always_inline))
static bool process_relocation_impl(Relocator& relocator, const rel_t& reloc) {
  // 是否为通用模式
  constexpr bool IsGeneral = Mode == RelocMode::General;

// 计算重定位目标地址 虚拟地址偏移(reloc.r_offset) + 加载偏移(relocator.si->load_bias)
  void* const rel_target = reinterpret_cast<void*>(
      relocator.si->apply_memtag_if_mte_globals(reloc.r_offset + relocator.si->load_bias));
  // 重定位类型
  const uint32_t r_type = ELFW(R_TYPE)(reloc.r_info);
  // 符号表索引
  const uint32_t r_sym = ELFW(R_SYM)(reloc.r_info);
  // 符号所在的 soinfo
  soinfo* found_in = nullptr;

const ElfW(Sym)* sym = nullptr;
  const char* sym_name = nullptr;
  ElfW(Addr) sym_addr = 0;

// 若符号索引有效, 获取符号名称
  if (r_sym != 0) {
    sym_name = relocator.get_string(relocator.si_symtab[r_sym].st_name);
  }

// 处理文本重定位的特殊情况, 临时修改内存权限, 不理会
#if defined(__LP64__)
  const bool handle_text_relocs = false;
  auto protect_segments = []() { return true; };
  auto unprotect_segments = []() { return true; };
#else
  const bool handle_text_relocs = IsGeneral && relocator.si->has_text_relocations;
  auto protect_segments = [&]() {
    if (phdr_table_protect_segments(relocator.si->phdr, relocator.si->phnum,
                                    relocator.si->load_bias, relocator.si->should_pad_segments(),
                                    relocator.si->should_use_16kib_app_compat()) < 0) {
      DL_ERR("can't protect segments for \"%s\": %m", relocator.si->get_realpath());
      return false;
    }
    return true;
  };
  auto unprotect_segments = [&]() {
    if (phdr_table_unprotect_segments(relocator.si->phdr, relocator.si->phnum,
                                      relocator.si->load_bias, relocator.si->should_pad_segments(),
                                      relocator.si->should_use_16kib_app_compat()) < 0) {
      DL_ERR("can't unprotect loadable segments for \"%s\": %m",
             relocator.si->get_realpath());
      return false;
    }
    return true;
  };
#endif

// 跳过 R_GENERIC_NONE 类型的重定位
  if (__predict_false(r_type == R_GENERIC_NONE)) {
    LD_DEBUG(reloc && IsGeneral, "RELO NONE");
    return true;
  }

// 获取重定位偏移
#if defined(USE_RELA)
  auto get_addend_rel   = [&]() -> ElfW(Addr) { return reloc.r_addend; };
  auto get_addend_norel = [&]() -> ElfW(Addr) { return reloc.r_addend; };
#else
  auto get_addend_rel   = [&]() -> ElfW(Addr) { return *static_cast<ElfW(Addr)*>(rel_target); };
  auto get_addend_norel = [&]() -> ElfW(Addr) { return 0; };
#endif

// 处理优化模式下 TLS 重定位
  if (!IsGeneral && __predict_false(is_tls_reloc(r_type))) {
    return process_relocation_general(relocator, reloc);
  }

if (IsGeneral && is_tls_reloc(r_type)) {
    // 处理通用模式下 TLS 重定位

// 一些错误处理
    if (r_sym == 0) {
      found_in = relocator.si;
    } else if (ELF_ST_BIND(relocator.si_symtab[r_sym].st_info) == STB_LOCAL) {
      sym = &relocator.si_symtab[r_sym];
      auto sym_type = ELF_ST_TYPE(sym->st_info);
      if (sym_type == STT_SECTION) {
        DL_ERR("unexpected TLS reference to local section in \"%s\": sym type %d, rel type %u",
               relocator.si->get_realpath(), sym_type, r_type);
      } else {
        DL_ERR(
            "unexpected TLS reference to local symbol \"%s\" in \"%s\": sym type %d, rel type %u",
            sym_name, relocator.si->get_realpath(), sym_type, r_type);
      }
      return false;
    } else if (!lookup_symbol<IsGeneral>(relocator, r_sym, sym_name, &found_in, &sym)) {
      return false;
    }

// 一些校验
    if (found_in != nullptr && found_in->get_tls() == nullptr) {
      DL_ERR("TLS relocation refers to symbol \"%s\" in solib \"%s\" with no TLS segment",
             sym_name, found_in->get_realpath());
      return false;
    }
    if (sym != nullptr) {
      if (ELF_ST_TYPE(sym->st_info) != STT_TLS) {
        DL_ERR("reference to non-TLS symbol \"%s\" from TLS relocation in \"%s\"",
               sym_name, relocator.si->get_realpath());
        return false;
      }
      // 得到符号地址
      sym_addr = sym->st_value;
    }
  } else {
    // 非 TLS 重定位的符号处理
    if (r_sym == 0) {
      // Do nothing.
    } else {
      if (!lookup_symbol<IsGeneral>(relocator, r_sym, sym_name, &found_in, &sym)) return false;
      if (sym != nullptr) {
        const bool should_protect_segments = handle_text_relocs &&
                                             found_in == relocator.si &&
                                             ELF_ST_TYPE(sym->st_info) == STT_GNU_IFUNC;
        if (should_protect_segments && !protect_segments()) return false;

// 得到符号地址
        sym_addr = found_in->resolve_symbol_address(sym);
        /* resolve_symbol_address 函数源码, 其实就是 s->st_value + load_bias
        ElfW(Addr) resolve_symbol_address(const ElfW(Sym)* s) const {
          if (ELF_ST_TYPE(s->st_info) == STT_GNU_IFUNC) {
            return call_ifunc_resolver(s->st_value + load_bias);
          }

return static_cast<ElfW(Addr)>(s->st_value + load_bias);
        }
        */

if (should_protect_segments && !unprotect_segments()) return false;
      } else if constexpr (IsGeneral) {
        // 弱引用未定义符号的处理
        switch (r_type) {
#if defined(__x86_64__)
          case R_X86_64_PC32:
            sym_addr = reinterpret_cast<ElfW(Addr)>(rel_target);
            break;
#elif defined(__i386__)
          case R_386_PC32:
            sym_addr = reinterpret_cast<ElfW(Addr)>(rel_target);
            break;
#endif
        }
      }
    }
  }

// 处理 PLT 跳转槽重定位
  if constexpr (IsGeneral || Mode == RelocMode::JumpTable) {
    if (r_type == R_GENERIC_JUMP_SLOT) {
      count_relocation_if<IsGeneral>(kRelocAbsolute);
      // 计算最终地址
      const ElfW(Addr) result = sym_addr + get_addend_norel();
      LD_DEBUG(reloc && IsGeneral, "RELO JMP_SLOT %16p <- %16p %s",
               rel_target, reinterpret_cast<void*>(result), sym_name);
      // 写入目标地址, 完成重定位
      *static_cast<ElfW(Addr)*>(rel_target) = result;
      return true;
    }
  }

// 处理典型重定位类型
  if constexpr (IsGeneral || Mode == RelocMode::Typical) {
    if (r_type == R_GENERIC_ABSOLUTE) {
      // 绝对重定位

count_relocation_if<IsGeneral>(kRelocAbsolute);
      // MTE 标签处理
      if (found_in) sym_addr = found_in->apply_memtag_if_mte_globals(sym_addr);
      // 计算最终地址
      const ElfW(Addr) result = sym_addr + get_addend_rel();
      LD_DEBUG(reloc && IsGeneral, "RELO ABSOLUTE %16p <- %16p %s",
               rel_target, reinterpret_cast<void*>(result), sym_name);
      // 写入目标地址, 完成重定位
      *static_cast<ElfW(Addr)*>(rel_target) = result;
      return true;
    } else if (r_type == R_GENERIC_GLOB_DAT) {
      // 全局数据重定位

// 与上边类似
      count_relocation_if<IsGeneral>(kRelocAbsolute);
      if (found_in) sym_addr = found_in->apply_memtag_if_mte_globals(sym_addr);
      const ElfW(Addr) result = sym_addr + get_addend_norel();
      LD_DEBUG(reloc && IsGeneral, "RELO GLOB_DAT %16p <- %16p %s",
               rel_target, reinterpret_cast<void*>(result), sym_name);
      *static_cast<ElfW(Addr)*>(rel_target) = result;
      return true;
    } else if (r_type == R_GENERIC_RELATIVE) {
      // 相对重定位

// 与上边类似
      count_relocation_if<IsGeneral>(kRelocRelative);
      ElfW(Addr) result = relocator.si->load_bias + get_addend_rel();
      if (relocator.si->should_tag_memtag_globals()) {
        int64_t* place = static_cast<int64_t*>(rel_target);
        int64_t offset = *place;
        result = relocator.si->apply_memtag_if_mte_globals(result + offset) - offset;
      }
      LD_DEBUG(reloc && IsGeneral, "RELO RELATIVE %16p <- %16p",
               rel_target, reinterpret_cast<void*>(result));
      *static_cast<ElfW(Addr)*>(rel_target) = result;
      return true;
    }
  }

// 优化模式下未处理的重定位回退到通用模式
  if constexpr (!IsGeneral) {
    return process_relocation_general(relocator, reloc);
  }

// 处理其他特殊重定位类型
  switch (r_type) {
    case R_GENERIC_IRELATIVE:
      // IFUNC 重定位

if (!relocator.si->is_linker()) {
        count_relocation_if<IsGeneral>(kRelocRelative);
        const ElfW(Addr) ifunc_addr = relocator.si->load_bias + get_addend_rel();
        LD_DEBUG(reloc && IsGeneral, "RELO IRELATIVE %16p <- %16p",
                 rel_target, reinterpret_cast<void*>(ifunc_addr));
        if (handle_text_relocs && !protect_segments()) return false;
        const ElfW(Addr) result = call_ifunc_resolver(ifunc_addr);
        if (handle_text_relocs && !unprotect_segments()) return false;
        *static_cast<ElfW(Addr)*>(rel_target) = result;
      }
      break;
    case R_GENERIC_COPY:
      // 拷贝重定位, Bionic 不支持
      DL_ERR("%s COPY relocations are not supported", relocator.si->get_realpath());
      return false;
    case R_GENERIC_TLS_TPREL:
      // TLS TP 相对重定位

count_relocation_if<IsGeneral>(kRelocRelative);
      {
        ElfW(Addr) tpoff = 0;
        if (found_in == nullptr) {

} else {
          CHECK(found_in->get_tls() != nullptr); // We rejected a missing TLS segment above.
          const TlsModule& mod = get_tls_module(found_in->get_tls()->module_id);
          if (mod.static_offset != SIZE_MAX) {
            tpoff += mod.static_offset - relocator.tls_tp_base;
          } else {
            DL_ERR("TLS symbol \"%s\" in dlopened \"%s\" referenced from \"%s\" using IE access model",
                   sym_name, found_in->get_realpath(), relocator.si->get_realpath());
            return false;
          }
        }
        tpoff += sym_addr + get_addend_rel();
        LD_DEBUG(reloc && IsGeneral, "RELO TLS_TPREL %16p <- %16p %s",
                 rel_target, reinterpret_cast<void*>(tpoff), sym_name);
        *static_cast<ElfW(Addr)*>(rel_target) = tpoff;
      }
      break;
    case R_GENERIC_TLS_DTPMOD:
      // TLS 模块 ID 重定位

count_relocation_if<IsGeneral>(kRelocRelative);
      {
        size_t module_id = 0;
        if (found_in == nullptr) {
          // Unresolved weak relocation. Evaluate the module ID to 0.
        } else {
          CHECK(found_in->get_tls() != nullptr); // We rejected a missing TLS segment above.
          module_id = found_in->get_tls()->module_id;
          CHECK(module_id != kTlsUninitializedModuleId);
        }
        LD_DEBUG(reloc && IsGeneral, "RELO TLS_DTPMOD %16p <- %zu %s",
                 rel_target, module_id, sym_name);
        *static_cast<ElfW(Addr)*>(rel_target) = module_id;
      }
      break;
    case R_GENERIC_TLS_DTPREL:
      // TLS DTP 相对重定位

count_relocation_if<IsGeneral>(kRelocRelative);
      {
        const ElfW(Addr) result = sym_addr + get_addend_rel() - TLS_DTV_OFFSET;
        LD_DEBUG(reloc && IsGeneral, "RELO TLS_DTPREL %16p <- %16p %s",
                 rel_target, reinterpret_cast<void*>(result), sym_name);
        *static_cast<ElfW(Addr)*>(rel_target) = result;
      }
      break;

#if defined(__aarch64__) || defined(__riscv)
    case R_GENERIC_TLSDESC:
      // TLS 描述符重定位, ARM64 / RISC-V
      count_relocation_if<IsGeneral>(kRelocRelative);
      {
        ElfW(Addr) addend = reloc.r_addend;
        TlsDescriptor* desc = static_cast<TlsDescriptor*>(rel_target);
        if (found_in == nullptr) {
          desc->func = tlsdesc_resolver_unresolved_weak;
          desc->arg = addend;
          LD_DEBUG(reloc && IsGeneral, "RELO TLSDESC %16p <- unresolved weak, addend 0x%zx %s",
                   rel_target, static_cast<size_t>(addend), sym_name);
        } else {
          CHECK(found_in->get_tls() != nullptr); 
          size_t module_id = found_in->get_tls()->module_id;
          const TlsModule& mod = get_tls_module(module_id);
          if (mod.static_offset != SIZE_MAX) {
            // 静态 TLS
            desc->func = tlsdesc_resolver_static;
            desc->arg = mod.static_offset - relocator.tls_tp_base + sym_addr + addend;
            LD_DEBUG(reloc && IsGeneral, "RELO TLSDESC %16p <- static (0x%zx - 0x%zx + 0x%zx + 0x%zx) %s",
                     rel_target, mod.static_offset, relocator.tls_tp_base,
                     static_cast<size_t>(sym_addr), static_cast<size_t>(addend),
                     sym_name);
          } else {
            // 动态 TLS, 延迟处理
            relocator.tlsdesc_args->push_back({
              .generation = mod.first_generation,
              .index.module_id = module_id,
              .index.offset = sym_addr + addend,
            });

relocator.deferred_tlsdesc_relocs.push_back({
              desc, relocator.tlsdesc_args->size() - 1
            });
            const TlsDynamicResolverArg& desc_arg = relocator.tlsdesc_args->back();
            LD_DEBUG(reloc && IsGeneral, "RELO TLSDESC %16p <- dynamic (gen %zu, mod %zu, off %zu) %s",
                     rel_target, desc_arg.generation, desc_arg.index.module_id,
                     desc_arg.index.offset, sym_name);
          }
        }
      }
      break;
#endif  // defined(__aarch64__) || defined(__riscv)

#if defined(__x86_64__)
    case R_X86_64_32:
      // x86_64 32 位绝对重定位
      count_relocation_if<IsGeneral>(kRelocAbsolute);
      {
        const Elf32_Addr result = sym_addr + reloc.r_addend;
        LD_DEBUG(reloc && IsGeneral, "RELO R_X86_64_32 %16p <- 0x%08x %s",
                 rel_target, result, sym_name);
        *static_cast<Elf32_Addr*>(rel_target) = result;
      }
      break;
    case R_X86_64_PC32:
      // x86_64 PC 相对重定位
      count_relocation_if<IsGeneral>(kRelocRelative);
      {
        const ElfW(Addr) target = sym_addr + reloc.r_addend;
        const ElfW(Addr) base = reinterpret_cast<ElfW(Addr)>(rel_target);
        // 计算相对值, 写入 rel_target
        const Elf32_Addr result = target - base;
        LD_DEBUG(reloc && IsGeneral, "RELO R_X86_64_PC32 %16p <- 0x%08x (%16p - %16p) %s",
                 rel_target, result, reinterpret_cast<void*>(target),
                 reinterpret_cast<void*>(base), sym_name);
        *static_cast<Elf32_Addr*>(rel_target) = result;
      }
      break;
#elif defined(__i386__)
    case R_386_PC32:
      // x86 PC 相对重定位
      count_relocation_if<IsGeneral>(kRelocRelative);
      {
        const ElfW(Addr) target = sym_addr + get_addend_rel();
        const ElfW(Addr) base = reinterpret_cast<ElfW(Addr)>(rel_target);
        const ElfW(Addr) result = target - base;
        LD_DEBUG(reloc && IsGeneral, "RELO R_386_PC32 %16p <- 0x%08x (%16p - %16p) %s",
                 rel_target, result, reinterpret_cast<void*>(target),
                 reinterpret_cast<void*>(base), sym_name);
        *static_cast<ElfW(Addr)*>(rel_target) = result;
      }
      break;
#endif
    default:
      // 未知重定位类型
      DL_ERR("unknown reloc type %d in \"%s\"", r_type, relocator.si->get_realpath());
      return false;
  }
  return true;
}
```
总结一下就是根据重定位项不同的类型做重定位处理, 计算重定位值写会目标地址, 与上边的 `apply_relr_reloc` 中的处理逻辑其实很类似.

到此完成了链接器的重定位.

### __linker_init_post_relocation
回到主线, 再看 `__linker_init_post_relocation`
```cpp
static ElfW(Addr) __attribute__((noinline))
__linker_init_post_relocation(KernelArgumentBlock& args, soinfo& tmp_linker_so) {
  // 完成主线程的后期初始化
  __libc_init_main_thread_late();

// 链接器的 RELRO 段保护: link_image 阶段因 x86 系统调用限制未执行, 此处补做
  if (!tmp_linker_so.protect_relro()) __linker_cannot_link(args.argv[0]);

set_bss_vma_name(&tmp_linker_so);

// 初始化链接器静态链接的 libc 全局变量
  __libc_init_globals();

pthread_mutex_lock(&g_dl_mutex);

// 执行链接器自身的构造函数
  tmp_linker_so.call_constructors();

// 设置链接器的 SONAME
  for (const ElfW(Dyn)* d = tmp_linker_so.dynamic; d->d_tag != DT_NULL; ++d) {
    if (d->d_tag == DT_SONAME) {
      tmp_linker_so.set_soname(tmp_linker_so.get_string(d->d_un.d_val));
    }
  }

// 处理链接器直接运行的情况, 这个我们可以忽略
  const char* exe_to_load = nullptr;
  if (getauxval(AT_ENTRY) == reinterpret_cast<uintptr_t>(&_start)) {
    if (args.argc == 3 && !strcmp(args.argv[1], "--list")) {
      g_is_ldd = true;
      exe_to_load = args.argv[2];
    } else if (args.argc <= 1 || !strcmp(args.argv[1], "--help")) {
      async_safe_format_fd(STDOUT_FILENO,
         "Usage: %s [--list] PROGRAM [ARGS-FOR-PROGRAM...]\n"
         "       %s [--list] path.zip!/PROGRAM [ARGS-FOR-PROGRAM...]\n"
         "\n"
         "A helper program for linking dynamic executables. Typically, the kernel loads\n"
         "this program because it's the PT_INTERP of a dynamic executable.\n"
         "\n"
         "This program can also be run directly to load and run a dynamic executable. The\n"
         "executable can be inside a zip file if it's stored uncompressed and at a\n"
         "page-aligned offset.\n"
         "\n"
         "The --list option gives behavior equivalent to ldd(1) on other systems.\n",
         args.argv[0], args.argv[0]);
      _exit(EXIT_SUCCESS);
    } 
		// 直接运行: 加载指定的可执行文件
		else {
      exe_to_load = args.argv[1];
      __libc_shared_globals()->initial_linker_arg_count = 1;
    }
  }

// 保存参数
  g_argc = args.argc - __libc_shared_globals()->initial_linker_arg_count;
  g_argv = args.argv + __libc_shared_globals()->initial_linker_arg_count;
  g_envp = args.envp;
  __libc_shared_globals()->init_progname = g_argv[0];

// 将链接器自身注册为动态链接库的 soinfo 对象
  solinker = get_libdl_info(tmp_linker_so);
  g_default_namespace.add_soinfo(solinker);

// 加载并链接目标程序, 返回其入口地址
  ElfW(Addr) start_address = linker_main(args, exe_to_load);

LD_DEBUG(any, "[ Jumping to _start (%p)... ]", reinterpret_cast<void*>(start_address));
  return start_address;
}
```
可以看到做了很多的初始化, 感兴趣可以自己看一下, 我们跟入 `linker_main`, 看后续如何处理目标程序,

### linker_main
加载并链接目标可执行文件, 算是最核心的部分, 也是最后一部分, 坐稳发车.
```cpp
static ElfW(Addr) linker_main(KernelArgumentBlock& args, const char* exe_to_load) {
  ProtectedDataGuard guard;

timeval t0, t1;
  gettimeofday(&t0, nullptr);

// 净化环境变量
  __libc_init_AT_SECURE(args.envp);

// 初始化系统属性
  __system_properties_init();

// 初始化平台属性
  platform_properties_init();

// 注册 debuggerd 信号处理器
  linker_debuggerd_init();

g_linker_logger.ResetState();

// 处理环境变量
  const char* LD_DEBUG = getenv("LD_DEBUG");
  if (LD_DEBUG != nullptr) init_LD_DEBUG(LD_DEBUG);

if (getenv("LD_SHOW_AUXV") != nullptr) ld_show_auxv(args.auxv);

LD_DEBUG(any, "[ Android dynamic linker (" ABI_STRING ") ]");

const char* ldpath_env = nullptr;
  const char* ldpreload_env = nullptr;
  if (!getauxval(AT_SECURE)) {
    ldpath_env = getenv("LD_LIBRARY_PATH");
    if (ldpath_env != nullptr) {
      LD_DEBUG(any, "[ LD_LIBRARY_PATH set to \"%s\" ]", ldpath_env);
    }
    ldpreload_env = getenv("LD_PRELOAD");
    if (ldpreload_env != nullptr) {
      LD_DEBUG(any, "[ LD_PRELOAD set to \"%s\" ]", ldpreload_env);
    }
  }

// 获取目标可执行文件信息
  const ExecutableInfo exe_info = exe_to_load ? load_executable(exe_to_load) :
                                                get_executable_info(args.argv[0]);

LD_DEBUG(any, "[ Linking executable \"%s\" ]", exe_info.path.c_str());

// 初始化目标程序的 soinfo 对象
  soinfo* si = soinfo_alloc(&g_default_namespace,
                            exe_info.path.c_str(), &exe_info.file_stat,
                            0, RTLD_GLOBAL);
  somain = si;
  si->phdr = exe_info.phdr;
  si->phnum = exe_info.phdr_count;
  si->set_should_pad_segments(exe_info.should_pad_segments);
  get_elf_base_from_phdr(si->phdr, si->phnum, &si->base, &si->load_bias);
  si->size = phdr_table_get_load_size(si->phdr, si->phnum);
  si->dynamic = nullptr;
  si->set_main_executable();
  init_link_map_head(*si);
  set_bss_vma_name(si);

// 将链接器添加到目标程序的 so 链表
  solist_add_soinfo(solinker);

// 获取目标程序链接器段中存的路径
  const char *interp = phdr_table_get_interpreter_name(somain->phdr, somain->phnum,
                                                       somain->load_bias);
  if (interp == nullptr) {
		// 链接器直接运行自身时使用默认路径
#if defined(__LP64__)
#define DEFAULT_INTERP "/system/bin/linker64"
#else
#define DEFAULT_INTERP "/system/bin/linker"
#endif
    interp = DEFAULT_INTERP;
  }
	// 设置真实路径
  solinker->set_realpath(interp);

init_link_map_head(*solinker);
  init_sanitizer_mode(interp);

#if defined(__aarch64__)
	// 初始化 ARM64 MTE
  __libc_init_mte(somain->memtag_dynamic_entries(), somain->phdr, somain->phnum, somain->load_bias);

if (exe_to_load == nullptr) {
		// 内核未为可执行页添加 BTI 保护, 此处补加
    auto note_gnu_property = GnuPropertySection(somain);
    if (note_gnu_property.IsBTICompatible() &&
        (phdr_table_protect_segments(
             somain->phdr, somain->phnum, somain->load_bias, somain->should_pad_segments(),
             somain->should_use_16kib_app_compat(), &note_gnu_property) < 0)) {
      __linker_error("error: can't protect segments for \"%s\": %m", exe_info.path.c_str());
    }
  }
#endif

insert_link_map_into_debug_map(&somain->link_map_head);
  insert_link_map_into_debug_map(&solinker->link_map_head);

// 加载 vdso, 内核提供的虚拟 DSO, 包含系统调用封装
  add_vdso();

ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(si->base);

if (elf_hdr->e_type != ET_DYN) {
    __linker_error("error: %s: Android only supports position-independent "
                   "executables (-fPIE)", exe_info.path.c_str());
  }

parse_LD_LIBRARY_PATH(ldpath_env);
  parse_LD_PRELOAD(ldpreload_env);

// 初始化默认命名空间, 处理库隔离和搜索路径
  std::vector<android_namespace_t*> namespaces = init_default_namespaces(exe_info.path.c_str());

// 预链接主程序, 这个与上边的 prelink_image 方法是一个
  if (!si->prelink_image()) __linker_cannot_link(g_argv[0]);

// 将主程序加入全局符号组
  si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
  // 将主程序添加到所有关联命名空间
  for (auto linked_ns : namespaces) {
    if (linked_ns != &g_default_namespace) {
      linked_ns->add_soinfo(somain);
      somain->add_secondary_namespace(linked_ns);
    }
  }

// 初始化主程序的静态 TLS
  linker_setup_exe_static_tls(g_argv[0]);

// 收集需加载的库列表: LD_PRELOAD 优先, 然后是 DT_NEEDED 依赖
  std::vector<const char*> needed_library_name_list;
  size_t ld_preloads_count = 0;

for (const auto& ld_preload_name : g_ld_preload_names) {
    needed_library_name_list.push_back(ld_preload_name.c_str());
    ++ld_preloads_count;
  }

for (const ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
    if (d->d_tag == DT_NEEDED) {
			// 修正依赖库名称
      const char* name = fix_dt_needed(si->get_string(d->d_un.d_val), si->get_realpath());
      needed_library_name_list.push_back(name);
    }
  }

const char** needed_library_names = &needed_library_name_list[0];
  size_t needed_libraries_count = needed_library_name_list.size();

// 加载依赖库
  if (needed_libraries_count > 0 &&
      !find_libraries(&g_default_namespace,
                      si,
                      needed_library_names,
                      needed_libraries_count,
                      nullptr,
                      &g_ld_preloads,
                      ld_preloads_count,
                      RTLD_GLOBAL,
                      nullptr,
                      true,
                      &namespaces)) {
    __linker_cannot_link(g_argv[0]);
  } else if (needed_libraries_count == 0) {
		// 无依赖库时直接链接主程序, link_image 同上边说的是同一个
    if (!si->link_image(SymbolLookupList(si), si, nullptr, nullptr)) {
      __linker_cannot_link(g_argv[0]);
    }
    si->increment_ref_count();
  }

if (g_is_ldd) _exit(EXIT_SUCCESS);

#if defined(__aarch64__)
  __libc_init_mte_stack(args.argv);
#endif

linker_finalize_static_tls();
  __libc_init_main_thread_final();

if (!get_cfi_shadow()->InitialLinkDone(solist_get_head())) __linker_cannot_link(g_argv[0]);

// 执行主程序的预初始化构造函数
  si->call_pre_init_constructors();
	// 执行主程序的构造函数
  si->call_constructors();

if (g_linker_debug_config.timing) {
    gettimeofday(&t1, nullptr);
    long long t0_us = (t0.tv_sec * 1000000LL) + t0.tv_usec;
    long long t1_us = (t1.tv_sec * 1000000LL) + t1.tv_usec;
    LD_DEBUG(timing, "LINKER TIME: %s: %lld microseconds", g_argv[0], t1_us - t0_us);
  }
  if (g_linker_debug_config.statistics) {
    print_linker_stats();
  }
  purge_unused_memory();

// 返回目标程序入口地址
  ElfW(Addr) entry = exe_info.entry_point;
  LD_DEBUG(any, "[ Ready to execute \"%s\" @ %p ]", si->get_realpath(), reinterpret_cast<void*>(entry));
  return entry;
}
```
读下来和动态链接器的最大的区别就是是否加载依赖库是吧, 剩下的重定位逻辑基本一致, 初始化也差不多, 我们重点分析一下加载依赖库部分.

### find_libraries
把大象装进冰箱分为哪几步?
```cpp
bool find_libraries(android_namespace_t* ns,
                    soinfo* start_with,
                    const char* const library_names[],
                    size_t library_names_count,
                    soinfo* soinfos[],
                    std::vector<soinfo*>* ld_preloads,
                    size_t ld_preloads_count,
                    int rtld_flags,
                    const android_dlextinfo* extinfo,
                    bool add_as_children,
                    std::vector<android_namespace_t*>* namespaces) {
  // Step 0: 初始化 ELF 读取器缓存和加载任务列表
  std::unordered_map<const soinfo*, ElfReader> readers_map;
  LoadTaskList load_tasks;

// 为每个待加载库创建初始加载任务
  for (size_t i = 0; i < library_names_count; ++i) {
    const char* name = library_names[i];
    load_tasks.push_back(LoadTask::create(name, start_with, ns, &readers_map));
  }

// 如果soinfos数组为空, 则在栈上分配
  if (soinfos == nullptr) {
    size_t soinfos_size = sizeof(soinfo*)*library_names_count;
    soinfos = reinterpret_cast<soinfo**>(alloca(soinfos_size));
    memset(soinfos, 0, soinfos_size);
  }

// 已加载库计数
  size_t soinfos_count = 0;

auto scope_guard = android::base::make_scope_guard([&]() {
    for (LoadTask* t : load_tasks) {
      LoadTask::deleter(t);
    }
  });

// ZIP 包缓存, 处理 APK 内库加载
  ZipArchiveCache zip_archive_cache;
  // 新的全局组成员, DF_1_GLOBAL 标记的库
  soinfo_list_t new_global_group_members;

// Step 1: 递归扩展加载任务列表, 解析所有 DT_NEEDED 依赖
  for (size_t i = 0; i<load_tasks.size(); ++i) {
    LoadTask* task = load_tasks[i];
    // 当前库的父库
    soinfo* needed_by = task->get_needed_by();

// 判断是否为 DT_NEEDED 依赖
    bool is_dt_needed = needed_by != nullptr && (needed_by != start_with || add_as_children);
    task->set_extinfo(is_dt_needed ? nullptr : extinfo);
    task->set_dt_needed(is_dt_needed);

// 从任务的起始命名空间搜索, 支持跨命名空间依赖
    android_namespace_t* start_ns = const_cast<android_namespace_t*>(task->get_start_from());

LD_LOG(kLogDlopen, "find_library_internal(ns=%s@%p): task=%s, is_dt_needed=%d",
           start_ns->get_name(), start_ns, task->get_name(), is_dt_needed);

// 查找并加载库
    if (!find_library_internal(start_ns, task, &zip_archive_cache, &load_tasks, rtld_flags)) {
      return false;
    }

soinfo* si = task->get_soinfo();

// 如果是 DT_NEEDED 依赖, 将当前库加入父库的子节点
    if (is_dt_needed) {
      needed_by->add_child(si);
    }

// 处理 LD_PRELOAD 库, 因为前几个处理的都是 LD_PRELOAD 库, 可以看前面的代码, 所以有 soinfos_count < ld_preloads_count
    bool is_ld_preload = false;
    if (ld_preloads != nullptr && soinfos_count < ld_preloads_count) {
      ld_preloads->push_back(si);
      is_ld_preload = true;
    }

// 记录加载后的 soinfo 对象
    if (soinfos_count < library_names_count) {
      soinfos[soinfos_count++] = si;
    }

// 处理全局组库(DF_1_GLOBAL 或 LD_PRELOAD), 添加到所有命名空间的全局组
    if (is_ld_preload || (si->get_dt_flags_1() & DF_1_GLOBAL) != 0) {
      if (!si->is_linked() && namespaces != nullptr && !new_global_group_members.contains(si)) {
        new_global_group_members.push_back(si);

// 遍历命名空间, 排除库的主命名空间后, 对库与其他命名空间进行双向关联绑定
        for (auto linked_ns : *namespaces) {
          if (si->get_primary_namespace() != linked_ns) {
            linked_ns->add_soinfo(si);
            si->add_secondary_namespace(linked_ns);
          }
        }
      }
    }
  }

// Step 2: 加载库
  LoadTaskList load_list;

// 构建去重的加载列表
  for (auto&& task : load_tasks) {
    soinfo* si = task->get_soinfo();
    auto pred = [&](const LoadTask* t) {
      return t->get_soinfo() == si;
    };

// 去重处理, 仅添加未链接且未在列表中的库
    if (!si->is_linked() &&
        std::find_if(load_list.begin(), load_list.end(), pred) == load_list.end() ) {
      load_list.push_back(task);
    }
  }

// 判断是否需要递归预留地址
  bool reserved_address_recursive = false;
  if (extinfo) {
    reserved_address_recursive = extinfo->flags & ANDROID_DLEXT_RESERVED_ADDRESS_RECURSIVE;
  }

// 非地址预留场景下随机化加载顺序, 解决依赖顺序问题
  if (!reserved_address_recursive) {
    shuffle(&load_list);
  }

// 设置地址空间参数, 预留地址或默认
  address_space_params extinfo_params, default_params;
  size_t relro_fd_offset = 0;
  if (extinfo) {
    if (extinfo->flags & ANDROID_DLEXT_RESERVED_ADDRESS) {
      extinfo_params.start_addr = extinfo->reserved_addr;
      extinfo_params.reserved_size = extinfo->reserved_size;
      extinfo_params.must_use_address = true;
    } else if (extinfo->flags & ANDROID_DLEXT_RESERVED_ADDRESS_HINT) {
      extinfo_params.start_addr = extinfo->reserved_addr;
      extinfo_params.reserved_size = extinfo->reserved_size;
    }
  }

// 调用 LoadTask::load, 执行加载
  for (auto&& task : load_list) {
    address_space_params* address_space =
        (reserved_address_recursive || !task->is_dt_needed()) ? &extinfo_params : &default_params;
    if (!task->load(address_space)) {
      return false;
    }
  }

bool dlext_use_relro =
      extinfo && extinfo->flags & (ANDROID_DLEXT_WRITE_RELRO | ANDROID_DLEXT_USE_RELRO);

// Step 3: 预链接所有库
  bool any_memtag_stack = false;

// 遍历所有任务, 执行预链接
  for (auto&& task : load_tasks) {
    soinfo* si = task->get_soinfo();
		// prelink_image 同上边是同一个, 预链接, 解析动态段
    if (!si->is_linked() && !si->prelink_image(dlext_use_relro)) {
      return false;
    }

if (si->memtag_stack()) {
      any_memtag_stack = true;
      LD_LOG(kLogDlopen,
             "... load_library requesting stack MTE for: realpath=\"%s\", soname=\"%s\"",
             si->get_realpath(), si->get_soname());
    }
    // 注册 TLS 段
    register_soinfo_tls(si);
  }
  if (any_memtag_stack) {
    if (auto* cb = __libc_shared_globals()->memtag_stack_dlopen_callback) {
      cb();
    } else {
      __libc_shared_globals()->initial_memtag_stack_abi = true;
    }
  }

// Step 4: 构造全局符号组, LD_PRELOAD 库强制设为全局
  if (ld_preloads != nullptr) {
    for (auto&& si : *ld_preloads) {
      si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
    }
  }

// Step 5: 收集本地组根节点, 跨命名空间依赖就加入组
  std::vector<soinfo*> local_group_roots;

// 确定初始根节点, start_with(第一个加载的库)
  if (start_with != nullptr && add_as_children) {
    local_group_roots.push_back(start_with);
  } else {
    CHECK(soinfos_count == 1);
    local_group_roots.push_back(soinfos[0]);
  }

// 遍历任务, 收集跨命名空间的本地组根节点
  for (auto&& task : load_tasks) {
    // 当前处理的库
    soinfo* si = task->get_soinfo();
    // 依赖当前库的父库
    soinfo* needed_by = task->get_needed_by();
    bool is_dt_needed = needed_by != nullptr && (needed_by != start_with || add_as_children);
    // 父库所在的命名空间
    android_namespace_t* needed_by_ns =
        is_dt_needed ? needed_by->get_primary_namespace() : ns;

// 当前库和父库不在同一个命名空间且还没链接
    if (!si->is_linked() && si->get_primary_namespace() != needed_by_ns) {
      auto it = std::find(local_group_roots.begin(), local_group_roots.end(), si);
      LD_LOG(kLogDlopen,
             "Crossing namespace boundary (si=%s@%p, si_ns=%s@%p, needed_by=%s@%p, ns=%s@%p, needed_by_ns=%s@%p) adding to local_group_roots: %s",
             si->get_realpath(),
             si,
             si->get_primary_namespace()->get_name(),
             si->get_primary_namespace(),
             needed_by == nullptr ? "(nullptr)" : needed_by->get_realpath(),
             needed_by,
             ns->get_name(),
             ns,
             needed_by_ns->get_name(),
             needed_by_ns,
             it == local_group_roots.end() ? "yes" : "no");

// 加入 local_group_roots, 当前库作为新根
      if (it == local_group_roots.end()) {
        local_group_roots.push_back(si);
      }
    }
  }

// Step 6: 链接 local_group_roots 中的每个根
  for (auto root : local_group_roots) {
    soinfo_list_t local_group;

// 当前库的命名空间
    android_namespace_t* local_group_ns = root->get_primary_namespace();

// 遍历依赖树, 被依赖的库优先加入 local_group
    walk_dependencies_tree(root,
      [&] (soinfo* si) {
        // 遍历依赖, 只收集能访问的库
        if (local_group_ns->is_accessible(si)) {
          local_group.push_back(si);
          return kWalkContinue;
        } else {
          return kWalkSkip;
        }
      });

// 构建符号查找列表, 当前库的全局组 + local_group
    soinfo_list_t global_group = local_group_ns->get_global_group();
    SymbolLookupList lookup_list(global_group, local_group);
    soinfo* local_group_root = local_group.front();

// 链接本地组内的所有库
    bool linked = local_group.visit([&](soinfo* si) {
      // 仅链接同命名空间且未链接的库
      if (!si->is_linked() && si->get_primary_namespace() == local_group_ns) {
        const android_dlextinfo* link_extinfo = nullptr;
        if (si == soinfos[0] || reserved_address_recursive) {
          link_extinfo = extinfo;
        }
        if (__libc_shared_globals()->load_hook) {
          __libc_shared_globals()->load_hook(si->load_bias, si->phdr, si->phnum);
        }

lookup_list.set_dt_symbolic_lib(si->has_DT_SYMBOLIC ? si : nullptr);

// link_image 同上边是同一个, 完成重定位
        if (!si->link_image(lookup_list, local_group_root, link_extinfo, &relro_fd_offset) ||
            !get_cfi_shadow()->AfterLoad(si, solist_get_head())) {
          return false;
        }
      }

return true;
    });

if (!linked) {
      return false;
    }
  }

// Step 7: 标记链接完成并更新引用计数

// 标记 start_with 为已链接
  if (start_with != nullptr && add_as_children) {
    start_with->set_linked();
  }

// 标记所有加载的库为已链接
  for (auto&& task : load_tasks) {
    soinfo* si = task->get_soinfo();
    si->set_linked();
  }

// 更新跨本地组的引用计数
  for (auto&& task : load_tasks) {
    soinfo* si = task->get_soinfo();
    soinfo* needed_by = task->get_needed_by();
    if (needed_by != nullptr &&
        needed_by != start_with &&
        needed_by->get_local_group_root() != si->get_local_group_root()) {
      // 跨组引用计数 + 1
      si->increment_ref_count();
    }
  }

return true;
}
```
前边的几步好说, 但是 Step 5-7 工作机制要举个例子讲一下.
- 命名空间 NS_A 包含 libA.so; 命名空间 NS_B 包含 libB.so(libA.so 依赖它) 与 libC.so(libB.so 依赖它): `libA.so(NS_A) → libB.so(NS_B) → libC.so(NS_B)`
- Step 5: libA.so 是第一个加载项, 所以 `local_group_roots = [libA.so]`. 遍历 load_tasks, load_tasks 包含三个库: libA.so, libB.so, libC.so, 逐个处理:
  - libA.so: needed_by=nullptr, 即没有库依赖 libA.so, 不满足条件, 不加入 `local_group_roots`
  - libB.so: needed_by=libA.so, needed_by_ns=NS_A, 即 libA.so 依赖 libB.so, libA.so 的主命名空间是 NS_A. 而 libB.so 的主命名空间是 NS_B, 跨命名空间且未链接, 加入 `local_group_roots`, 此时 `local_group_roots = [libA.so, libB.so]`
  - libC.so: needed_by=libB.so, needed_by_ns=NS_B, 即 libB.so 依赖 libC.so, libB.so 的主命名空间是 NS_B. 而 libC.so 的主命名空间也是 NS_B, 不满足条件, 不加入 `local_group_roots`.
  - 最终 `local_group_roots = [libA.so, libB.so]`
- Step 6: 对 `local_group_roots` 里的每个根分别处理:
  - libA.so(NS_A): 调用 `walk_dependencies_tree`, 遍历依赖但只收集 NS_A 能访问的库, libB.so 在 NS_B, NS_A 访问不到, 所以 `local_group = [libA.so]`, 用 NS_A 的全局组 + `local_group` 组成 `lookup_list`. 根据 `lookup_list` 调用 `libA.so->link_image()`, 解析 libA.so 中引用的符号, 完成重定位.
  - libB.so(NS_B): 调用 `walk_dependencies_tree`, 得到 `local_group = [libC.so, libB.so]`, 被依赖的 libC.so 在前, 用 NS_B 的全局组 + `local_group` 组成 `lookup_list`. 根据 `lookup_list`, 先处理 libC.so, 调用 `libC.so->link_image()`; 再处理 libB.so, 调用`libB.so->link_image()`. 完成重定位
- Step 7: 把 libA.so, libB.so, libC.so 都标记为 `is_linked=true`, 表示链接完成. 然后更新跨组引用计数, libA.so(NS_A) 依赖 libB.so(NS_B) → 跨组了, 所以 libB.so 的引用计数 + 1, 确保 libA.so 在用时, libB.so 不会被卸载. 而当运行时 libA.so 使用的 libB.so 符号时, 在进行惰性绑定(即 PLT, 上边重定位逻辑中提到了), 重定位符号.

这就是库重定位, 链接的逻辑.

### find_library_internal
回过头, 我们在看一下是如何加载库到内存的.
```cpp
static bool find_library_internal(android_namespace_t* ns,
                                  LoadTask* task,
                                  ZipArchiveCache* zip_archive_cache,
                                  LoadTaskList* load_tasks,
                                  int rtld_flags) {
  // 存储找到的已加载库
  soinfo* candidate;

// 检查当前命名空间及其链接的命名空间中是否已加载该库
  if (find_loaded_library_by_soname(ns, task->get_name(), true /* search_linked_namespaces */,
                                    &candidate)) {
    LD_LOG(kLogDlopen,
           "find_library_internal(ns=%s, task=%s): Already loaded (by soname): %s",
           ns->get_name(), task->get_name(), candidate->get_realpath());
    // 找到已加载库, 复用已加载的 soinfo, 直接返回成功
    task->set_soinfo(candidate);
    return true;
  }

LD_DEBUG(any, "[ \"%s\" find_loaded_library_by_soname failed (*candidate=%s@%p). Trying harder... ]",
           task->get_name(), candidate == nullptr ? "n/a" : candidate->get_realpath(), candidate);

// 尝试在当前命名空间中加载新库
  if (load_library(ns, task, zip_archive_cache, load_tasks, rtld_flags,
                   true /* search_linked_namespaces */)) {
    return true;
  }

// 豁免列表中的库需要切换到默认命名空间重新尝试加载, 兼容处理
  if (ns->is_exempt_list_enabled() && is_exempt_lib(ns, task->get_name(), task->get_needed_by())) {
    LD_LOG(kLogDlopen,
           "find_library_internal(ns=%s, task=%s): Exempt system library - trying namespace %s",
           ns->get_name(), task->get_name(), g_default_namespace.get_name());
    // 切换到默认命名空间
    ns = &g_default_namespace;
    // 在默认命名空间中重新尝试加载
    if (load_library(ns, task, zip_archive_cache, load_tasks, rtld_flags,
                     true /* search_linked_namespaces */)) {
      return true;
    }
  }

DlErrorRestorer dlerror_restorer;
  LD_LOG(kLogDlopen, "find_library_internal(ns=%s, task=%s): Trying %zu linked namespaces",
         ns->get_name(), task->get_name(), ns->linked_namespaces().size());
  
  // 当前命名空间加载失败, 遍历链接的命名空间继续查找/加载
  for (auto& linked_namespace : ns->linked_namespaces()) {
    // 在链接的命名空间中查找库
    if (find_library_in_linked_namespace(linked_namespace, task)) {
      // 找到已加载的库, 复用已加载库, 返回成功
      if (task->get_soinfo() != nullptr) {
        return true;
      }

// 未找到已加载库, 尝试在链接命名空间中加载新库
      if (load_library(linked_namespace.linked_namespace(), task, zip_archive_cache, load_tasks,
                       rtld_flags, false /* search_linked_namespaces */)) {
        LD_LOG(kLogDlopen, "find_library_internal(ns=%s, task=%s): Found in linked namespace %s",
               ns->get_name(), task->get_name(), linked_namespace.linked_namespace()->get_name());
        return true;
      }
    }
  }

return false;
}
```
通过名称判断当前命名空间及其链接的命名空间中是否已加载该库, 如果未加载就调用 `load_library` 加载, 如果已经加载就复用, 总结来说就是这样.

### load_library
再看 `load_library`
```cpp
static bool load_library(android_namespace_t* ns,
                         LoadTask* task,
                         LoadTaskList* load_tasks,
                         int rtld_flags,
                         const std::string& realpath,
                         bool search_linked_namespaces) {
  // 省略一堆校验...

// 分配 soinfo 对象
  soinfo* si = soinfo_alloc(ns, realpath.c_str(), &file_stat, file_offset, rtld_flags);
  task->set_soinfo(si);

// 读取库的 ELF 头和段信息
  if (!task->read(realpath.c_str(), file_stat.st_size)) {
    task->remove_cached_elf_reader();
    task->set_soinfo(nullptr);
    soinfo_free(si);
    return false;
  }

// 解析 ELF 动态段中的 DT_RUNPATH / DT_SONAME / DT_FLAGS_1
  const ElfReader& elf_reader = task->get_elf_reader();
  for (const ElfW(Dyn)* d = elf_reader.dynamic(); d->d_tag != DT_NULL; ++d) {
    if (d->d_tag == DT_RUNPATH) {
      // 设置运行时库路径
      si->set_dt_runpath(elf_reader.get_string(d->d_un.d_val));
    }
    if (d->d_tag == DT_SONAME) {
      // 设置库的 SONAME
      si->set_soname(elf_reader.get_string(d->d_un.d_val));
    }
    if (d->d_tag == DT_FLAGS_1) {
      // 设置动态标志
      si->set_dt_flags_1(d->d_un.d_val);
    }
  }

#if !defined(__ANDROID__)
  if (si->get_dt_runpath().empty()) {
    si->set_dt_runpath("$ORIGIN/../lib64:$ORIGIN/lib64");
  }
#endif

// 解析 DT_NEEDED 依赖, 添加到全局加载任务列表
  for (const ElfW(Dyn)* d = elf_reader.dynamic(); d->d_tag != DT_NULL; ++d) {
    if (d->d_tag == DT_NEEDED) {
      const char* name = fix_dt_needed(elf_reader.get_string(d->d_un.d_val), elf_reader.name());
      LD_LOG(kLogDlopen, "load_library(ns=%s, task=%s): Adding DT_NEEDED task: %s",
             ns->get_name(), task->get_name(), name);
      // 创建依赖库的加载任务并加入列表
      load_tasks->push_back(LoadTask::create(name, si, ns, task->get_readers_map()));
    }
  }

return true;
}
```
解析要加载库的 ELF 文件, 做一些校验, 得到它的 soinfo, 然后将它依赖库加入加载任务列表. 至于怎么解析的 ELF, 这里就不再看了, 已经读过太多遍了.

---

到此为止, 旅途结束.

---

回复或点赞可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

最后于 2025-12-2 18:34 被nothing233编辑，原因：增加流程图

#基础理论 #系统相关 #源码框架 #其他

最新回复 (54) 1 2 3 ▶
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 707 粉丝 7 关注私信	mb_ldbucrik 2 楼感谢分享 2025-12-2 14:00 0
iBa0 雪币： 1901 活跃值： (5928) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 490 粉丝 37 关注私信	iBa0 3 楼 111 2025-12-2 14:04 0
丶咖啡猫丶雪币： 2769 活跃值： (3986) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 178 粉丝 4 关注私信	丶咖啡猫丶 4 楼大佬太牛了 2025-12-2 14:05 0
mb_obunkbty 雪币：能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	mb_obunkbty 5 楼大佬太强了 2025-12-2 14:39 0
街道办事处雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 48 粉丝 0 关注私信	街道办事处 6 楼 111 2025-12-2 14:40 0
金罡雪币： 3251 活跃值： (4418) 能力值： ( LV10，RANK：170 ) 在线值：发帖 15 回帖 381 粉丝 303 关注私信	金罡 3 7 楼不错，感谢楼主的精彩文章。 2025-12-2 14:53 1
Xx_gg 雪币： 227 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 35 粉丝 0 关注私信	Xx_gg 8 楼 6666 2025-12-2 16:00 0
夜惜风雨雪币： 95 活跃值： (3767) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 155 粉丝 0 关注私信	夜惜风雨 9 楼 666666 2025-12-2 16:05 0
墨穹呢雪币： 4770 活跃值： (8232) 能力值： ( LV3，RANK：20 ) 在线值：发帖 2 回帖 231 粉丝 18 关注私信	墨穹呢 10 楼感谢分享 2025-12-2 16:11 0
mb_qimctavn 雪币： 5327 活跃值： (6780) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 401 粉丝 1 关注私信	mb_qimctavn 11 楼 6 2025-12-2 16:27 0
azd放雪币： 43 活跃值： (2579) 能力值： ( LV2，RANK：10 ) 在线值：发帖 3 回帖 45 粉丝 0 关注私信	azd放 12 楼这个讨论对我很有帮助，谢谢！ 2025-12-2 16:50 0
nothing233 雪币： 2314 活跃值： (1966) 能力值： ( LV6，RANK：90 ) 在线值：发帖 17 回帖 18 粉丝 87 关注私信	nothing233 1 13 楼金罡不错，感谢楼主的精彩文章。诚惶诚恐 2025-12-2 17:47 0
mb_4nrpVMxJ 雪币： 3837 活跃值： (215) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 96 粉丝 0 关注私信	mb_4nrpVMxJ 14 楼学习 2025-12-2 19:10 0
zzzzz1 雪币： 285 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 11 粉丝 0 关注私信	zzzzz1 15 楼学习 2025-12-2 21:12 0
KanXue_NG 雪币： 678 能力值： ( LV1，RANK：0 ) 在线值：发帖 7 回帖 100 粉丝 66 关注私信	KanXue_NG 16 楼学习学习 2025-12-2 21:28 0
wx_WantC 雪币： 772 活跃值： (578) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 43 粉丝 1 关注私信	wx_WantC 17 楼学习了???? 2025-12-2 22:27 0
GEKEZYX 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 157 粉丝 0 关注私信	GEKEZYX 18 楼 666 2025-12-3 09:52 0
Imxz 雪币： 110 活跃值： (9571) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 775 粉丝 9 关注私信	Imxz 19 楼 TQL 2025-12-3 14:23 0
毛毛毛毛虫雪币： 2981 活跃值： (3455) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 75 粉丝 0 关注私信	毛毛毛毛虫 20 楼学习一下 2025-12-3 14:31 0
mb_jnmxfjku 雪币： 109 活跃值： (820) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 149 粉丝 0 关注私信	mb_jnmxfjku 21 楼 11 2025-12-3 17:39 0
mb_irhdtnzm 雪币： 23 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 158 粉丝 0 关注私信	mb_irhdtnzm 22 楼 6666 2025-12-4 09:16 0
huangjw 雪币： 6747 活跃值： (11957) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 514 粉丝 2 关注私信	huangjw 23 楼很ok啊 2025-12-4 09:31 0
mb_euhyowpw 雪币： 2 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 152 粉丝 0 关注私信	mb_euhyowpw 24 楼 111 2025-12-6 20:45 0
koflfy 雪币： 102 活跃值： (4136) 能力值： ( LV4，RANK：50 ) 在线值：发帖 8 回帖 483 粉丝 5 关注私信	koflfy 1 25 楼文章非常nice，写得非常细。感谢楼主 2025-12-6 21:01 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复