/* Standard ELF types.  */

/* Type for a 16-bit quantity.  */
typedef uint16_t Elf32_Half;
typedef uint16_t Elf64_Half;
/* Types for signed and unsigned 32-bit quantities.  */
typedef uint32_t Elf32_Word;
typedef int32_t  Elf32_Sword;
typedef uint32_t Elf64_Word;
typedef int32_t  Elf64_Sword;
/* Types for signed and unsigned 64-bit quantities.  */
typedef uint64_t Elf32_Xword;
typedef int64_t  Elf32_Sxword;
typedef uint64_t Elf64_Xword;
typedef int64_t  Elf64_Sxword;
/* Type of addresses.  */
typedef uint32_t Elf32_Addr;
typedef uint64_t Elf64_Addr;
/* Type of file offsets.  */
typedef uint32_t Elf32_Off;
typedef uint64_t Elf64_Off;
/* Type for section indices, which are 16-bit quantities.  */
typedef uint16_t Elf32_Section;
typedef uint16_t Elf64_Section;
/* Type for version symbol information.  */
typedef Elf32_Half Elf32_Versym;
typedef Elf64_Half Elf64_Versym;

typedef struct {
    Elf32_Sword d_tag;
    union {
        Elf32_Word d_val;
        Elf32_Addr d_ptr;
    } d_un;
} Elf32_Dyn;

typedef struct {
    Elf64_Sxword d_tag;
    union {
        Elf64_Xword d_val;  
        Elf64_Addr d_ptr;    
    } d_un;
} Elf64_Dyn;

/* Legal values for d_tag (dynamic entry type).  */
#define DT_NULL     0   /* Marks end of dynamic section */
#define DT_NEEDED   1   /* Name of needed library */
#define DT_PLTRELSZ 2   /* Size in bytes of PLT relocs */
#define DT_PLTGOT   3   /* Processor defined value */
#define DT_HASH     4   /* Address of symbol hash table */
#define DT_STRTAB   5   /* Address of string table */
#define DT_SYMTAB   6   /* Address of symbol table */
#define DT_RELA     7   /* Address of Rela relocs */
#define DT_RELASZ   8   /* Total size of Rela relocs */
#define DT_RELAENT  9   /* Size of one Rela reloc */
#define DT_STRSZ    10  /* Size of string table */
#define DT_SYMENT   11  /* Size of one symbol table entry */
#define DT_INIT     12  /* Address of init function */
#define DT_FINI     13  /* Address of termination function */
#define DT_SONAME   14  /* Name of shared object */
#define DT_RPATH    15  /* Library search path (deprecated) */
#define DT_SYMBOLIC 16  /* Start symbol search here */
#define DT_REL      17  /* Address of Rel relocs */
#define DT_RELSZ    18  /* Total size of Rel relocs */
#define DT_RELENT   19  /* Size of one Rel reloc */
#define DT_PLTREL   20  /* Type of reloc in PLT */
#define DT_DEBUG    21  /* For debugging; unspecified */
#define DT_TEXTREL  22  /* Reloc might modify .text */
#define DT_JMPREL   23  /* Address of PLT relocs */
#define DT_BIND_NOW 24  /* Process relocations of object */
#define DT_INIT_ARRAY 25  /* Array with addresses of init fct */
#define DT_FINI_ARRAY 26  /* Array with addresses of fini fct */
#define DT_INIT_ARRAYSZ 27  /* Size in bytes of DT_INIT_ARRAY */
#define DT_FINI_ARRAYSZ 28  /* Size in bytes of DT_FINI_ARRAY */
#define DT_RUNPATH      29  /* Library search path */
#define DT_FLAGS        30  /* Flags for the object being loaded */
#define DT_ENCODING     31  /* Start of encoded range */
#define DT_PREINIT_ARRAY 32  /* Array with addresses of preinit fct*/
#define DT_PREINIT_ARRAYSZ 33  /* size in bytes of DT_PREINIT_ARRAY */
#define DT_SYMTAB_SHNDX    34  /* Address of SYMTAB_SHNDX section */
#define DT_NUM             35  /* Number used */
#define DT_LOOS    0x6000000d  /* Start of OS-specific */
#define DT_HIOS    0x6ffff000  /* End of OS-specific */
#define DT_LOPROC  0x70000000  /* Start of processor-specific */
#define DT_HIPROC  0x7fffffff  /* End of processor-specific */
#define DT_PROCNUM DT_MIPS_NUM  /* Most used by any processor */
......

/* Relocation table entry without addend (in section of type SHT_REL).  */
typedef struct {
    Elf32_Addr r_offset; /* 表示重定位所作用的虚拟地址或相对基地址的偏移 */
    Elf32_Word r_info;   /* 重定位类型和符号表下标 */
} Elf32_Rel;

/* The following, at least, is used on Sparc v9, MIPS, and Alpha.  */
typedef struct {
    Elf64_Addr r_offset; /* 表示重定位所作用的虚拟地址或相对基地址的偏移 */
    Elf64_Xword r_info;  /* 重定位类型和符号表下标 */
} Elf64_Rel;

/* Relocation table entry with addend (in section of type SHT_RELA).  */
typedef struct {
    Elf32_Addr r_offset;  /* 表示重定位所作用的虚拟地址或相对基地址的偏移 */
    Elf32_Word r_info;    /* 重定位类型和符号表下标 */
    Elf32_Sword r_addend; /* Addend */
} Elf32_Rela;

typedef struct {
    Elf64_Addr r_offset;  /* 表示重定位所作用的虚拟地址或相对基地址的偏移 */
    Elf64_Xword r_info;   /* 重定位类型和符号表下标 */
    Elf64_Sxword r_addend; /* Addend */
} Elf64_Rela;

/* How to extract and insert information held in the r_info field.  */
//获得高24位，表示在符号表中的下标
#define ELF32_R_SYM(val)  ((val) >> 8) 
//获得低8位，表示重定位类型
#define ELF32_R_TYPE(val)  ((val) & 0xff) 
//通过R_SYM和R_Type重组r_info
#define ELF32_R_INFO(sym, type)  (((sym) << 8) + ((type) & 0xff)) 

//获得高32位，表示在符号表中的下标
#define ELF64_R_SYM(i)  ((i) >> 32)
//获得低32位，表示重定位类型
#define ELF64_R_TYPE(i)  ((i) & 0xffffffff)
//通过R_SYM和R_Type重组r_info
#define ELF64_R_INFO(sym,type)  ((((Elf64_Xword) (sym)) << 32) + (type))

/* i386 relocs.  */
#define R_386_NONE     0  /* No reloc */
#define R_386_32       1  /* Direct 32 bit  */
#define R_386_PC32     2  /* PC relative 32 bit */
#define R_386_GOT32    3  /* 32 bit GOT entry */
#define R_386_PLT32    4  /* 32 bit PLT address */
#define R_386_COPY     5  /* Copy symbol at runtime */
#define R_386_GLOB_DAT 6  /* Create GOT entry */
#define R_386_JMP_SLOT 7  /* Create PLT entry */
#define R_386_RELATIVE 8  /* Adjust by program base */
......

/* AMD x86-64 relocations.  */
#define R_X86_64_NONE      0  /* No reloc */
#define R_X86_64_64        1  /* Direct 64 bit  */
#define R_X86_64_PC32      2  /* PC relative 32 bit signed */
#define R_X86_64_GOT32     3  /* 32 bit GOT entry */
#define R_X86_64_PLT32     4  /* 32 bit PLT address */
#define R_X86_64_COPY      5  /* Copy symbol at runtime */
#define R_X86_64_GLOB_DAT  6  /* Create GOT entry */
#define R_X86_64_JUMP_SLOT 7  /* Create PLT entry */
#define R_X86_64_RELATIVE  8  /* Adjust by program base */
#define R_X86_64_GOTPCREL  9  /* 32 bit signed PC relative offset to GOT */
......

/* Symbol table entry.  */
typedef struct {
    Elf32_Word    st_name;  /* 符号名，符号在字符串表中的偏移 */
    Elf32_Addr    st_value; /* 符号的值，可能是地址或偏移 */
    Elf32_Word    st_size;  /* 符号的大小 */
    unsigned char st_info;  /* 符号类型及绑定属性 */
    unsigned char st_other; /* 符号的可见性 */
    Elf32_Section st_shndx; /* 节头表索引 */
} Elf32_Sym;

typedef struct {
  Elf64_Word    st_name;  /* 符号名，符号在字符串表中的偏移 */
  unsigned char st_info;  /* 符号类型及绑定属性 */
  unsigned char st_other; /* 符号的可见性 */
  Elf64_Section st_shndx; /* 节头表索引 */
  Elf64_Addr    st_value; /* 符号的值，可能是地址或偏移 */
  Elf64_Xword   st_size;  /* 符号的大小 */
} Elf64_Sym;

/* st_info字段中符号类型和绑定属性的提取 */
#define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4)
#define ELF32_ST_TYPE(val) ((val) & 0xf)
#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
/* Elf32_Sym和Elf64_Sym都使用相同的一字节的st_info字段 */
#define ELF64_ST_BIND(val) ELF32_ST_BIND (val)
#define ELF64_ST_TYPE(val) ELF32_ST_TYPE (val)
#define ELF64_ST_INFO(bind, type) ELF32_ST_INFO ((bind), (type))

#include <link_map.h>
/* 描述加载的共享库的结构体。“l_next”和“l_prev”成员构成了启动时加载的所有共享对象的链表。
   这些数据结构存在于运行时动态链接器使用的空间中。 修改它们可能会导致灾难性的后果。 如有
   必要，此数据结构将来可能会更改。 用户级程序必须避免定义这种类型的对象。 */
struct link_map {
    /* 这些最初的几个成员是调试器协议的一部分。 这与SVR4中使用的格式相同。 */
    ElfW(Addr) l_addr;  /* ELF文件中的地址与内存中的地址之间的不同。共享文件加载基地址。 */
    char *l_name;       /* 绝对文件名 */
    ElfW(Dyn) *l_ld;    /* 共享对象的动态节 */
    struct link_map *l_next, *l_prev;  /* 加载的共享对象链表指针 */
    /* 以下所有成员都是动态链接器的内部组件，可能随时改变不受提醒 */
    /* 当在多个名称空间中使用ld.so时，该元素与指向该类型的相同副本的指针不同。 */
    struct link_map *l_real;
    /* 该link map所属的命名空间个数 */
    Lmid_t l_ns;
    struct libname_list *l_libname;
    /* 指向“.dynamic”节的索引指针。
    这个数组用于快速访问动态节的信息，在lookup系列函数中会频繁使用。
    它的有关定义还包含了一系列用于访问信息的功能宏。 */
    ElfW(Dyn) *l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM
                    + DT_EXTRANUM + DT_VALNUM + DT_ADDRNUM];
    const ElfW(Phdr) *l_phdr;  /* 指向程序头表的指针。 */
    ElfW(Addr) l_entry;        /* 入口点位置。 */
    ElfW(Half) l_phnum;        /* 程序头条目的数量。 */
    ElfW(Half) l_ldnum;        /* dynamic节条目数量 */
    /* DT_NEEDED依存项及其依存项的数组，按依赖关系查找符号（包含和不包含重复项）。 在加载依赖项之前，没有任何条目。 */
    struct r_scope_elem l_searchlist;
    /* 我们需要一个特殊的搜索列表来处理标记有DT_SYMBOLIC的对象。 */
    struct r_scope_elem l_symbolic_searchlist;
    /* 第一次导致该对象被加载的对象。  */
    struct link_map *l_loader;
    /* 版本名称的数组。 */
    struct r_found_version *l_versions;
    unsigned int l_nversions;
    /* 符号Hash表 */
    Elf_Symndx l_nbuckets;
    Elf32_Word l_gnu_bitmask_idxbits;
    Elf32_Word l_gnu_shift;
    const ElfW(Addr) *l_gnu_bitmask;
    union {
        const Elf32_Word *l_gnu_buckets;
        const Elf_Symndx *l_chain;
    };
    union {
        const Elf32_Word *l_gnu_chain_zero;
        const Elf_Symndx *l_buckets;
    };
    unsigned int l_direct_opencount; /* dlopen/dlclose的引用计数。  */
    enum {                    /* 该对象来自何处。 */
        lt_executable,        /* 主要的可执行程序。 */
        lt_library,           /* 主可执行文件需要的库。 */
        lt_loaded             /* 额外的运行时加载的共享库。 */
    } l_type:2;
    unsigned int l_relocated:1;      /* 如果对象的重定位完成，则为非零值。 */
    unsigned int l_init_called:1;    /* 如果DT_INIT函数被调用，则为非零值。 */
    unsigned int l_global:1;         /* 如果对象在_dl_global_scope中，则为非零值。 */
    unsigned int l_reserved:2;       /* 保留供内部使用。 */
    unsigned int l_phdr_allocated:1; /* 如果分配了由“ l_phdr”指向的数据结构，则为非零值。 */
    unsigned int l_soname_added:1;   /* 如果确定SO_NAME在l_libname列表中，则为非零值。 */
    unsigned int l_faked:1;          /* 如果这是一个没有关联文件的伪造描述符，则为非零值。 */
    unsigned int l_need_tls_init:1;  /* 重定位完成后，如果在此link map上调用GL（dl_init_static_tls），则为非零值。 */
    unsigned int l_auditing:1;       /* 如果DSO用于审计，则为非零值。 */
    unsigned int l_audit_any_plt:1;  /* 如果至少一个审计模块对PLT拦截感兴趣，则为非零值。 */
    unsigned int l_removed:1;        /* 如果该对象已被删除而无法再使用，则为非零值。 */
    unsigned int l_contiguous:1;     /* 如果段间孔受到保护，或者根本不存在孔，则为非零值。 */
    unsigned int l_symbolic_in_local_scope:1; /* 如果LD_TRACE_PRELINKING = 1期间的
                                                l_local_scope包含任何DT_SYMBOLIC库，则为非零值。 */
    unsigned int l_free_initfini:1; /* 如果可以释放l_initfini，则为非零值。即，没有在ld.so中与虚拟malloc一起分配。 */

    /* 收集有关自己的RPATH目录的信息。 */
    struct r_search_path_struct l_rpath_dirs;
    /* 概要分析时收集的重定位结果。 */
    struct reloc_result {
        DL_FIXUP_VALUE_TYPE addr;
        struct link_map *bound;
        unsigned int boundndx;
        uint32_t enterexit;
        unsigned int flags;
        /* 并发性注：这用于保护跨多个线程的重定位结果的并发初始化。 请参阅elf/dl-runtime.c中的更详细说明。 */
        unsigned int init;
    } *l_reloc_result;
    /* 指向版本信息的指针（如果有）。 */
    ElfW(Versym) *l_versyms;
    /* 字符串，指定找到此对象的路径。 */
    const char *l_origin;
    /* 此对象的内存映射的开始和结束。 l_map_start不必与l_addr相同。 */
    ElfW(Addr) l_map_start, l_map_end;
    /* 映射的可执行部分的结尾。 */
    ElfW(Addr) l_text_end;
    /* “l_scope”的默认数组。 */
    struct r_scope_elem *l_scope_mem[4];
    /* 为“ l_scope”分配的数组大小。 */
    size_t l_scope_max;
    /* 这是一个定义此link map的查找范围的数组。最初最多有三个不同的范围列表。 */
    struct r_scope_elem **l_scope;
    /* 类似的数组，这次仅与本地范围有关。偶尔使用。 */
    struct r_scope_elem *l_local_scope[2];
    /* 保留此信息以检查共享对象是否与已加载的对象相同。 */
    struct r_file_id l_file_id;
    /* 收集有关自己的RUNPATH目录的信息。 */
    struct r_search_path_struct l_runpath_dirs;
    /* 按init和fini调用的顺序列出对象。 */
    struct link_map **l_initfini;
    /* 通过符号绑定引入的依赖项列表。 */
    struct link_map_reldeps {
        unsigned int act;
        struct link_map *list[];
    } *l_reldeps;
    unsigned int l_reldepsmax;
    /* 如果使用DSO，则为非零值。 */
    unsigned int l_used;
    /* 各种标志字。 */
    ElfW(Word) l_feature_1;
    ElfW(Word) l_flags_1;
    ElfW(Word) l_flags;
    /* 暂时在dl_close中使用。 */
    int l_idx;
    struct link_map_machine l_mach;
    struct {
        const ElfW(Sym) *sym;
        int type_class;
        struct link_map *value;
        const ElfW(Sym) *ret;
    } l_lookup_cache;
    /* 线程本地存储相关信息。 */
    /* 初始化映像的开始。 */
    void *l_tls_initimage;
    /* 初始化映像的大小。 */
    size_t l_tls_initimage_size;
    /* TLS块的大小。 */
    size_t l_tls_blocksize;
    /* TLS块的对齐要求。 */
    size_t l_tls_align;
    /* 第一个字节模块对齐方式的偏移量。 */
    size_t l_tls_firstbyte_offset;
    #ifndef NO_TLS_OFFSET
    # define NO_TLS_OFFSET        0
    #endif
    #ifndef FORCED_DYNAMIC_TLS_OFFSET
    # if NO_TLS_OFFSET == 0
    #  define FORCED_DYNAMIC_TLS_OFFSET -1
    # elif NO_TLS_OFFSET == -1
    #  define FORCED_DYNAMIC_TLS_OFFSET -2
    # else
    #  error "FORCED_DYNAMIC_TLS_OFFSET is not defined"
    # endif
    #endif
    /* 对于启动时出现的对象：静态TLS块中的偏移量。 */
    ptrdiff_t l_tls_offset;
    /* dtv数组中模块的索引。 */
    size_t l_tls_modid;
    /* 此DSO构造的thread_local对象的数量。 这是原子访问和修改的，
    并不总是受加载锁保护。 另请参见：cxa_thread_atexit_impl.c中的“注意事项”。 */
    size_t l_tls_dtor_count;
    /* 重定位完成后用于更改权限的信息。 */
    ElfW(Addr) l_relro_addr;
    size_t l_relro_size;
    unsigned long long int l_serial;
    /* 审计信息。 该数组显然必须是结构体中的最后一个。 切勿在其后添加任何内容。 */
    struct auditstate {
        uintptr_t cookie;
        unsigned int bindflags;
    } l_audit[0];
};

#ifndef reloc_offset
# define reloc_offset reloc_arg
# define reloc_index  reloc_arg / sizeof (PLTREL)
#endif

/* elf_machine_type_class()返回的重定位类型类。 
   ELF_RTYPE_CLASS_PLT表示此重定位不应由某些PLT符号满足，
   ELF_RTYPE_CLASS_COPY意味着此重定位不应由可执行文件中的任何符号满足。 
   某些体系结构不支持copy重定位(引用外部变量)。 在这种情况下，我们将宏定义为零，以便自
   动优化处理它们的代码。 ELF_RTYPE_CLASS_EXTERN_PROTECTED_DATA表示
   共享库中定义的受保护数据的地址可能是外部的，即由于copy重定位。 */
#define ELF_RTYPE_CLASS_PLT 1
#ifndef DL_NO_COPY_RELOCS
# define ELF_RTYPE_CLASS_COPY 2
#else
# define ELF_RTYPE_CLASS_COPY 0
#endif


/* 第一次调用每个PLT条目时，将通过PLT的特殊跳转调用此功能。 我们必须执行给定共享对象的PLT中指定的重定位，并将已解析的函数地址返回到跳转，这将重新启动对该地址的原始调用。 将来的调用将直接从PLT跳转到该功能。 */
DL_FIXUP_VALUE_TYPE
attribute_hidden __attribute ((noinline)) ARCH_FIXUP_ATTRIBUTE
_dl_fixup (
# ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
           ELF_MACHINE_RUNTIME_FIXUP_ARGS,
# endif
           //l为共享库或可执行文件ID，link_map结构指针。link_map结构链表第一个结点表示的是可执行文件。
           //reloc_arg为所解析函数的重定位项在重定位表.rel.plt中的偏移
           struct link_map *l, ElfW(Word) reloc_arg)  
{
    //D_PTR是一个宏定义，位于glibc/sysdeps/generic/ldsodefs.h中，用于通过link_map结构体寻址。
    //通过link_map结构获取动态链接符号表.dynsym的地址
    //ELFW宏用来拼接字符串，在这里实际上是为了自动兼容32和64位,Elf32_Sym或Elf64_Sym
    const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);  
    //通过link_map结构获取动态链接字符串表.dynstr的地址
    const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]); 
    //通过link_map结构获取重定位表.rel.plt中所求函数的重定位项的地址
    //reloc_offset为所解析函数的重定位项在重定位表.rel.plt中的偏移
    const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset); 
    //求出所求函数在动态链接符号表.dynsym中对应符号项的地址
    const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];  
    const ElfW(Sym) *refsym = sym;
    //l_addr是共享库或可执行文件加载基址，rel_addr是重定位需要修改内容的地址，也就是.got.plt中所求函数对应项
    //r_offset为相对虚拟地址，rel_addr为虚拟地址
    void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);

    lookup_t result;    //查找函数的结果，其为定义函数的共享对象的加载基地址
    DL_FIXUP_VALUE_TYPE value;  //DL_FIXUP_VALUE_TYPE是fixup/profile_fixup返回值的类型。保存函数的真实地址。

    /* 安全性检查，我们需要确定它是一个PLT的重定位项 */
    assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
    /* 查找目标符号。如果未使用常规查找规则，则不要在全局范围内查找。 */
    //st_other定义了符号的可见性，__builtin_expect返回值为第一个参数
    //#define ELF32_ST_VISIBILITY(o) ((o) & 0x03)
    if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0) //使用了常规查找规则
    {
        const struct r_found_version *version = NULL;   //当前符号的版本
        if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)   
        {
            //获取动态符号版本表“.gnu.version”的地址
            const ElfW(Half) *vernum = (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
            ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
            version = &l->l_versions[ndx];  //得到当前所解析符号的版本
            if (version->hash == 0)
                version = NULL;
        }
        /* 我们需要保持范围不变，因此需要进行一些锁定。 对于无法卸载的对象或尚未使用任何线程的对象，这不是必需的。  */
        int flags = DL_LOOKUP_ADD_DEPENDENCY;
        if (!RTLD_SINGLE_THREAD_P)
        {
            THREAD_GSCOPE_SET_FLAG ();
            flags |= DL_LOOKUP_GSCOPE_LOCK;
        }
        #ifdef RTLD_ENABLE_FOREIGN_CALL
            RTLD_ENABLE_FOREIGN_CALL;
        #endif
        //strtab + sym->st_name为所解析函数的符号在字符串表中的地址，result为定义函数的共享对象的加载基地址
        //_dl_lookup_symbol_x的功能是在加载的共享对象的符号表中搜索符号的定义，其参数也许带有该符号的版本。
        result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
                                    version, ELF_RTYPE_CLASS_PLT, flags, NULL);
        /* 我们已经完成了全局范围的工作。 */
        if (!RTLD_SINGLE_THREAD_P)
            THREAD_GSCOPE_RESET_FLAG ();
        #ifdef RTLD_FINALIZE_FOREIGN_CALL
            RTLD_FINALIZE_FOREIGN_CALL;
        #endif
        /* 当前result包含定义sym的共享对象的加载基地址（或link map）。 现在添加符号偏移量。 */
        //value为所求函数的真实内存地址
        //SYMBOL_ADDRESS(map, ref, map_set)：如果ref不是NULL，则使用映射MAP中的基地址来计算符号引用的地址。 
        //如果MAP_SET为TRUE，请勿检查NULL映射。
        value = DL_FIXUP_MAKE_VALUE (result,SYMBOL_ADDRESS (result, sym, false));
    }
    else //未使用常规查找规则
    {
        /* 我们已经找到了符号。 模块（及其加载地址）也是已知的。 */
        value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, sym, true));
        result = l;
    }

    //elf_machine_plt_value返回PLT重定位的最终值。在x86-64上JUMP_SLOT重定位忽略addend。
    value = elf_machine_plt_value (l, reloc, value);
    if (sym != NULL && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
        value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));
    /* 最后，修复PLT本身。 */
    if (__glibc_unlikely (GLRO(dl_bind_not)))
        return value;
    //向所查找函数对应的GOT表中填写找到的函数的真实地址。
    return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value);
}

const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
const ElfW(Sym) *refsym = sym;
void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);

//strtab + sym->st_name为所解析函数的符号在字符串表中的地址，result为定义函数的共享对象的加载基地址
//_dl_lookup_symbol_x的功能是在加载的共享对象的符号表中搜索符号的定义，其参数也许带有该符号的版本。
result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, 
    l->l_scope,version, ELF_RTYPE_CLASS_PLT, flags, NULL);

/* 当前result包含定义sym的共享对象的加载基地址（或link map）。 现在添加符号偏移量。 */
//value为所求函数的真实内存地址
//SYMBOL_ADDRESS(map, ref, map_set)：如果ref不是NULL，则使用映射MAP中的基地址来计算符号引用的地址。 
//如果MAP_SET为TRUE，请勿检查NULL映射。
value = DL_FIXUP_MAKE_VALUE (result,SYMBOL_ADDRESS (result, sym, false));

/* 根据地址和link_map构造修正值 */
#define DL_FIXUP_MAKE_VALUE(map, addr) (map) ? ((struct fdesc){(addr),(map)->l_info[DT_PLTGOT]->d_un.d_ptr }) : ((struct fdesc) { 0, 0 })

/* 如果ref不是NULL，则使用映射MAP中的基地址来计算符号引用的地址。如果MAP_SET为TRUE，请勿检查NULL映射。  */
#define SYMBOL_ADDRESS(map, ref, map_set) ((ref) == NULL ? 0 : (__glibc_unlikely((ref)->st_shndx == SHN_ABS) ? 0 : LOOKUP_VALUE_ADDRESS(map, map_set)) + (ref)->st_value)

//向所查找函数对应的GOT表中填写找到的函数的真实地址。
return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value);

static inline ElfW(Addr)
elf_machine_fixup_plt (struct link_map *map, lookup_t t,
                       const ElfW(Sym) *refsym, const ElfW(Sym) *sym,
                       const ElfW(Rela) *reloc,
                       ElfW(Addr) *reloc_addr, ElfW(Addr) value)
{
  return *reloc_addr = value;
}

ssize_t main1()
{
    char slogan; // [esp+1Ch] [ebp-9Ch] 0x80 = 128
    char name[16]; // [esp+9Ch] [ebp-1Ch]
    size_t nbytes; // [esp+ACh] [ebp-Ch] 32程序size_t大小为4bytes
    
    nbytes = 16;
    *name = 0;
    *&name[4] = 0;
    *&name[8] = 0;
    *&name[12] = 0;
    memset(&slogan, 0, 128u);
    write(1, "input name:", 12u);
    // name的大小为16byte,多读一个字节,覆盖了后面的数据
    read(0, name, nbytes + 1);
    // 检查输入长度,name输入长度最长为10byte,并且name前8个字节为"syclover"
    if ( strlen(name) - 1 > 9 || strncmp("syclover", name, 8u) )
      return -1;
    write(1, "input slogan:", 14u);
    read(0, &slogan, nbytes);
    return write(1, &slogan, nbytes);
}

if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)   
{
    //获取动态符号版本表“.gnu.version”的地址
    const ElfW(Half) *vernum = (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
    //ndx是当前符号所使用的glibc库版本在版本需要表(.gnu.version_r)中的版本结构体的vna_other成员的值
    ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff; 
    //l_version数组存储的是版本需要表(.gnu.version_r)中包含的二进制程序实际依赖的glibc库版本结构体指针
    version = &l->l_versions[ndx];  //得到当前所解析符号的glibc库版本信息
    if (version->hash == 0)
        version = NULL;
}

ssize_t __fastcall main(__int64 a1, char **a2, char **a3)
{
  char buf; // [rsp+0h] [rbp-10h] buf大小只有16byte

  return read(0, &buf, 32uLL);
}