• GNU gold链接器 - target.cc 实现特定目标架构的支持

    一、Target::do_is_local_label_name(const char* name) const

    1. object.cc 中  调用target().is_local_label_name(name)

    1. 这段代码是在链接器中用于决定是否应该丢弃本地符号的部分。它包含了一些逻辑，以便在满足特定条件时丢弃本地符号。下面是关键部分的解释：
    2. 条件判断：这段代码执行了一系列条件检查，以确定是否应该丢弃本地符号。判断是基于以下条件：
    3. discard_locals 变量控制是否应该丢弃本地符号，如果为真，将会丢弃。
    4. discard_sec_merge 变量控制是否应该丢弃合并部分（merge sections）中的本地符号。
    5. is_ordinary 表示符号是否为普通符号。
    6. out_section_offsets[shndx] 用于检查符号所属的输出节（section）是否为无效地址（invalid_address）。
    7. 符号属性检查：代码接着检查符号的一些属性：
    8. sym.get_st_type() != elfcpp::STT_FILE 用于排除文件类型符号。
    9. !lv.needs_output_dynsym_entry() 确保不需要动态符号表入口。
    10. lv.may_be_discarded_from_output_symtab() 检查是否可以从输出符号表中丢弃。
    11. 本地标签名检查：最后，通过调用 parameters->target().is_local_label_name(name) 来检查符号名称是否是本地标签名。
    12. 如果是本地标签名，那么这个符号将被设置为不输出到符号表中，即被丢弃。
    13.    */
    14.       if ((discard_locals
    15. 	   || (discard_sec_merge
    16. 	       && is_ordinary
    17. 	       && out_section_offsets[shndx] == invalid_address))
    18. 	  && sym.get_st_type() != elfcpp::STT_FILE
    19. 	  && !lv.needs_output_dynsym_entry()
    20. 	  && lv.may_be_discarded_from_output_symtab()
    21. 	  && parameters->target().is_local_label_name(name))
    22. 	{
    23. 	  lv.set_no_output_symtab_entry();
    24. 	  continue;
    25. 	}

    2. target.h中调用类的成员函数 ，do_is_local_label_name是个虚函数，可以在别的地方实现

    1. // Return whether NAME is a local label name.  This is used to implement the
    2.   // --discard-locals options.
    3.   bool
    4.   is_local_label_name(const char* name) const
    5.   { return this->do_is_local_label_name(name); }

     3. 在target.cc中实现这个函数，目的就是判断符号是不是局部符号

    1. //  用于判断一个符号名是否是局部标签名
    2. bool
    3. Target::do_is_local_label_name(const char* name) const
    4. {
    5.   
    6.   // Normal local symbols start with ``.L''.
    7.   if (name[0] == '.' && name[1] == 'L')
    8.     return true;
    9.  
    10.   // At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
    11.   // DWARF debugging symbols starting with ``..''.
    12.   if (name[0] == '.' && name[1] == '.')
    13.     return true;
    14.  
    15.   // gcc will sometimes generate symbols beginning with ``_.L_'' when
    16.   // emitting DWARF debugging output.  I suspect this is actually a
    17.   // small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
    18.   // ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
    19.   // underscore to be emitted on some ELF targets).  For ease of use,
    20.   // we treat such symbols as local.
    21.   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
    22.     return true;
    23.  
    24.   return false;
    25. }

    二、Object* Target::do_make_elf_object

    用于根据不同的目标平台和体系结构，选择合适的函数来创建 ELF 对象。这段代码的目的是根据不同的目标平台和体系结构选择正确的函数版本，以创建符合目标平台特性的 ELF 对象。

    1. // Make an ELF object called NAME by reading INPUT_FILE at OFFSET.  EHDR
    2. // is the ELF header of the object.  There are four versions of this
    3. // for different address sizes and endianities.
    4. // LITTLE 位小端字节序 32 表示地址大小，
    5. #ifdef HAVE_TARGET_32_LITTLE
    6. Object*
    7. Target::do_make_elf_object(const std::string& name, Input_file* input_file,
    8. 			   off_t offset, const elfcpp::Ehdr<32, false>& ehdr)
    9. {
    10.   return this->do_make_elf_object_implementation<32, false>(name, input_file,
    11. 							    offset, ehdr);
    12. }
    13. #endif
    14.  
    15. #ifdef HAVE_TARGET_32_BIG
    16. Object*
    17. Target::do_make_elf_object(const std::string& name, Input_file* input_file,
    18. 			   off_t offset, const elfcpp::Ehdr<32, true>& ehdr)
    19. {
    20.   return this->do_make_elf_object_implementation<32, true>(name, input_file,
    21. 							   offset, ehdr);
    22. }
    23. #endif
    24.  
    25. #ifdef HAVE_TARGET_64_LITTLE
    26. Object*
    27. Target::do_make_elf_object(const std::string& name, Input_file* input_file,
    28. 			   off_t offset, const elfcpp::Ehdr<64, false>& ehdr)
    29. {
    30.   return this->do_make_elf_object_implementation<64, false>(name, input_file,
    31. 							    offset, ehdr);
    32. }
    33. #endif
    34.  
    35. #ifdef HAVE_TARGET_64_BIG
    36. Object*
    37. Target::do_make_elf_object(const std::string& name, Input_file* input_file,
    38. 			   off_t offset, const elfcpp::Ehdr<64, true>& ehdr)
    39. {
    40.   return this->do_make_elf_object_implementation<64, true>(name, input_file,
    41. 							   offset, ehdr);
    42. }
    43. #endif

    跟据目标平台地址大小和字节顺序，创建一个ELF对象

    1. // Implementations of methods Target::do_make_elf_object are almost identical
    2. // except for the address sizes and endianities.  So we extract this
    3. // into a template.
    4. //  一个模板方法，用于创建一个 ELF 对象。这个方法的实现依赖于目标平台的地址大小和字节顺序。
    5. template<int size, bool big_endian>
    6. inline Object*
    7. Target::do_make_elf_object_implementation(
    8.     const std::string& name,
    9.     Input_file* input_file,
    10.     off_t offset,
    11.     const elfcpp::Ehdr& ehdr)
    12.  // name 是对象的名称，input_file 是输入文件对象，offset 是文件中 ELF 头的偏移，ehdr 是 ELF 头的信息。
    13.  
    14. {
    15.   int et = ehdr.get_e_type(); // 获取 ELF 文件类型
    16.   // ET_EXEC files are valid input for --just-symbols/-R,
    17.   // and we treat them as relocatable objects.
    18.   // elfcpp::ET_REL表示是可重定位对象文件,文件类型是 elfcpp::ET_EXEC 且输入文件是仅包含符号的情况（input_file->just_symbols()），则将其视为可重定位对象
    19.   // ET_REL (1): 表示可重定位文件     ET_EXEC (2): 表示可执行文件     ET_DYN (3): 表示共享对象文件  
    20.   if (et == elfcpp::ET_REL
    21.       || (et == elfcpp::ET_EXEC && input_file->just_symbols()))
    22.     {
    23.       Sized_relobj_file* obj =
    24. 	new Sized_relobj_file(name, input_file, offset, ehdr); 
    25.   //  Sized_relobj_file(name, input_file, offset, ehdr) 是模板类的实例化
    26.       obj->setup();
    27.       return obj;
    28.     }
    29.   else if (et == elfcpp::ET_DYN)
    30.     {
    31.       Sized_dynobj* obj =
    32. 	new Sized_dynobj(name, input_file, offset, ehdr);
    33.       obj->setup();
    34.       return obj;
    35.     }
    36.   else
    37.     {
    38.       gold_error(_("%s: unsupported ELF file type %d"),
    39. 		 name.c_str(), et);
    40.       return NULL;
    41.     }
    42. }

    三、Output_section* Target::do_make_output_section

    1. // 用于创建输出段对象
    2. Output_section*
    3. Target::do_make_output_section(const char* name, elfcpp::Elf_Word type,
    4. 			       elfcpp::Elf_Xword flags)
    5. // 段的名称 name、段的类型 type 和段的标志 flags。
    6. {
    7.   // 链接器中创建输出段对象，以便后续将链接结果存储在这些段中，这些段将成为生成的可执行文件或共享库的一部分。
    8.   return new Output_section(name, type, flags);
    9. }

    四、    bool Target::do_is_call_to_non_split

    用于确定重定位的时候是否对非分割函数调用

    1. // Default for whether a reloc is a call to a non-split function is
    2. // whether the symbol is a function.
    3. // 用于确定一个重定位是否是对非分割函数的调用
    4. /*
    5.   非分割函数" 指的是在程序的链接和执行过程中不会被拆分或分割成多个部分的函数。这意味着这些函数的定义是完整的，
    6.   没有被分成多个代码段，它们可以被直接调用并执行，而不需要进一步的合并或组装。这与 "分割函数" 形成对比，
    7.   分割函数通常被分成多个部分以实现某种特定的优化或节省内存的目的。
    8. */
    9.  
    10. bool
    11. Target::do_is_call_to_non_split(const Symbol* sym, const unsigned char*,
    12. 				const unsigned char*, section_size_type) const
    13. {
    14.   return sym->type() == elfcpp::STT_FUNC;
    15.   // 如果符号的类型是函数类型，那么函数返回 true，表示这个重定位是对非分割函数的调用；否则返回 false。
    16. }

    五、void Target::do_calls_non_split

    用于出链接器涉及栈分割时，打印错误消息

    1. // Default conversion for -fsplit-stack is to give an error.
    2. // 用于处理在链接器中涉及到栈分割（stack split）支持的情况
    3. // 会设置 warned 为 false，并输出一条错误消息，指出链接器不包括栈分割支持，而栈分割是由链接对象（object）所需的
    4. void
    5. Target::do_calls_non_split(Relobj* object, unsigned int, section_offset_type,
    6. 			   section_size_type, const unsigned char*, size_t,
    7. 			   unsigned char*, section_size_type,
    8. 			   std::string*, std::string*) const
    9. {
    10.   static bool warned;
    11.   // 一次性警告
    12.   if (!warned)
    13.     {
    14.       gold_error(_("linker does not include stack split support "
    15. 		   "required by %s"),
    16. 		 object->name().c_str());
    17.       warned = true;
    18.     }
    19. }

    六、bool Target::match_view

            这个函数通常用于检查视图中特定位置的字节数据是否与预期的字节数组匹配，以便进行一些数据匹配和校验操作。

    1. //  Return whether BYTES/LEN matches VIEW/VIEW_SIZE at OFFSET.
    2. // 用于比较一个视图（view）中的字节数据是否与给定的字节数组匹配。
    3. // 函数会检查是否在给定的视图（view）中的指定偏移（offset）处的一段字节与指定的字节数组（bytes）匹配。
    4. /* 
    5. 视图"（View）通常是指对目标文件或可执行文件中的某一部分内存内容进行抽象和管理的一种数据结构或概念。
    6. 这些视图用于支持链接器的各种任务和操作，
    7. 包括但不限于以下几个方面：
    8. 内存管理： 视图可以用于管理目标文件或可执行文件在内存中的布局，包括各个段（sections）的起始地址、大小和属性。这有助于链接器将不同的目标文件组合成一个整体的可执行文件，保证各段在内存中的正确位置。
    9. 符号解析： 视图用于查找和定位目标文件中的符号表（symbol table），以便解析符号引用和符号定义。链接器使用视图来查找符号的地址，以便正确地建立符号引用关系。
    10. 重定位： 视图用于处理重定位信息，即在链接过程中对符号引用的地址进行修正。视图可以帮助链接器确定需要进行哪些重定位，以及如何修正目标文件中的地址，以适应最终的可执行文件。
    11. 段合并和填充： 在链接过程中，链接器可能需要将多个目标文件的段合并到一个输出段中，或者填充一些内存区域以满足对齐或布局的要求。视图用于管理这些操作，确保数据正确放置在内存中。
    12. 异常处理： 链接器可能需要生成或更新异常处理相关的信息，例如异常处理表（exception table）或调试信息，以便在程序出现异常时能够正确处理。
    13. */
    14. bool
    15. Target::match_view(const unsigned char* view, section_size_type view_size,
    16. 		   section_offset_type offset, const char* bytes,
    17. 		   size_t len) const
    18. {
    19.   if (offset + len > view_size)
    20.     return false;
    21.   return memcmp(view + offset, bytes, len) == 0;
    22. }

    七、 void Target::set_view_to_nop

    它的作用是将指定的内存视图（view）中的一段内存区域设置为 NOP（No Operation）指令。这通常用于在链接过程中进行填充，以确保生成的可执行文件或共享库满足一些特定的要求，例如对齐或布局。

    1. // Set the contents of a VIEW/VIEW_SIZE to nops starting at OFFSET
    2. // for LEN bytes.
    3.  
    4. void
    5. Target::set_view_to_nop(unsigned char* view, section_size_type view_size,
    6. 			section_offset_type offset, size_t len) const
    7. // 方法用于将一段内存设置为 NOP 指令。这个方法主要用于处理链接过程中的填充问题。
    8. {
    9.   gold_assert(offset >= 0 && offset + len <= view_size); 
    10.   // 检查链接器是否支持特点的代码填充方式 ，通过调用 this->has_code_fill() 来确定。
    11.   if (!this->has_code_fill())
    12.     memset(view + offset, 0, len);
    13.   else
    14.     {
    15.       // 使用 this->code_fill(len) 来获取填充的具体数据
    16.       std::string fill = this->code_fill(len);
    17.       // 使用 memcpy 将填充数据复制到内存视图的指定位置，
    18.       memcpy(view + offset, fill.data(), len);
    19.     }
    20. }

    八、 void Target::do_plt_fde_location

    PLT（Procedure Linkage Table）是一个存储在 plt 参数中的数据结构，用于动态链接和解析共享库中的函数。在链接器中，PLT 通常是一种输出数据，用于支持动态链接过程中的函数调用。

    PLT 主要用于以下目的：

    1. Lazy Binding： PLT 支持延迟绑定，也称为懒绑定。在动态链接中，共享库中的函数不会在程序加载时立即绑定到调用点。相反，PLT 包含一组跳转指令，用于在第一次调用函数时将其绑定到相应的共享库函数。这可以减少程序启动时间。

    2. 解析外部符号： PLT 用于解析外部符号，即位于共享库中的函数。当程序调用共享库中的函数时，PLT 负责查找和绑定正确的函数。

    3. 异常处理： PLT 也与异常处理相关。在动态链接的情况下，异常处理需要知道 PLT 中函数的地址和大小，以便正确处理异常。

     do_plt_fde_location 的目的是获取 PLT 的地址和大小，并将这些信息用于生成与 PLT 相关的 EH frame FDE。这有助于确保程序在异常处理过程中能够正确识别和处理 PLT 中的函数。所以，PLT 是链接器的一个重要输出数据，用于支持程序的动态链接和异常处理。

    1. // Return address and size to plug into eh_frame FDEs associated with a PLT.
    2. void
    3. Target::do_plt_fde_location(const Output_data* plt, unsigned char*,
    4. 			    uint64_t* address, off_t* len) const
    5. //  方法用于获取 PLT 的 FDE 地址和大小。这个方法主要用于处理异常处理框架（EH frame）的问题。
    6.  
    7. {
    8.   *address = plt->address();
    9.   *len = plt->data_size();
    10. }

    九、 void Sized_target::do_adjust_elf_header

            用于调整 ELF 头的 EI_OSABI 字段，以处理目标平台的操作系统 ABI（Application Binary Interface）问题。ABI 定义了二进制程序与操作系统之间的接口规范，包括函数调用约定、系统调用方式、数据布局等。

    1. template<int size, bool big_endian>
    2. void
    3. Sized_target::do_adjust_elf_header(unsigned char* view,
    4. 						     int len)
    5. {
    6.   // 用于调整 ELF 头的 EI_OSABI 字段。这个方法主要用于处理目标平台的 OS ABI 问题。
    7.   // 获取了当前目标平台的操作系统 ABI
    8.   elfcpp::ELFOSABI osabi = this->osabi();
    9.   if (osabi != elfcpp::ELFOSABI_NONE)
    10.     {
    11.       gold_assert(len == elfcpp::Elf_sizes::ehdr_size);
    12.  
    13.       elfcpp::Ehdr ehdr(view);
    14.       // 创建一个 ELF 头对象，根据给定的地址大小和字节顺序，该 ELF 头对象用于处理 ELF 文件头信息
    15.       unsigned char e_ident[elfcpp::EI_NIDENT];
    16.       // 创建了一个用于存储 ELF 头标识字段（e_ident）的数组
    17.       memcpy(e_ident, ehdr.get_e_ident(), elfcpp::EI_NIDENT);
    18.       // 将原始 ELF 头的标识字段复制到新的数组中
    19.       e_ident[elfcpp::EI_OSABI] = osabi;
    20.       // 新的标识字段中的 EI_OSABI 字段为操作系统 ABI 的值
    21.       elfcpp::Ehdr_write oehdr(view);
    22.       // 创建一个可写的 ELF 头对象，用于将修改后的标识字段写回原始 ELF 头的视图中
    23.       oehdr.put_e_ident(e_ident);
    24.     }
    25. }

    target.cc代码

    1. // target.cc -- target support for gold.
    2.  
    3. // Copyright (C) 2009-2017 Free Software Foundation, Inc.
    4. // Written by Doug Kwan .
    5.  
    6. // This file is part of gold.
    7.  
    8. // This program is free software; you can redistribute it and/or modify
    9. // it under the terms of the GNU General Public License as published by
    10. // the Free Software Foundation; either version 3 of the License, or
    11. // (at your option) any later version.
    12.  
    13. // This program is distributed in the hope that it will be useful,
    14. // but WITHOUT ANY WARRANTY; without even the implied warranty of
    15. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    16. // GNU General Public License for more details.
    17.  
    18. // You should have received a copy of the GNU General Public License
    19. // along with this program; if not, write to the Free Software
    20. // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    21. // MA 02110-1301, USA.
    22.  
    23.  
    24.  
    25. /* 
    27. 这个文件是 GNU 的 Gold 链接器的一部分，用于实现特定目标平台的支持。以下是文件的详细解析：
    29. */
    30.  
    31. #include "gold.h"     //   包含了链接器的一些基本定义和全局函数
    32. #include "elfcpp.h"   //   包含了处理 ELF (Executable and Linkable Format) 文件的类和函数。ELF 是一种常见的二进制文件格式，用于可执行文件、目标文件、共享库等
    33. #include "dynobj.h"   //   定义了处理动态对象（如共享库）的类和函数
    34. #include "symtab.h"   //   定义了处理符号表的类和函数。符号表是存储符号（如函数名、变量名）信息的数据结构  
    35. #include "output.h"   //   定义了输出链接结果（如生成的可执行文件或共享库）的类和函数
    36. #include "target.h"   //   定义了处理特定目标平台的类和函数。在编译和链接过程中，需要针对不同的目标平台（如 x86、ARM、MIPS 等）进行不同的处理
    37.  
    38. namespace gold
    39. {
    40.  
    41. // Return whether NAME is a local label name.  This is used to implement the
    42. // --discard-locals options and can be overridden by child classes to
    43. // implement system-specific behaviour.  The logic here is the same as that
    44. // in _bfd_elf_is_local_label_name().
    45.  
    46.  
    47. //  用于判断一个符号名是否是局部标签名
    48. bool
    49. Target::do_is_local_label_name(const char* name) const
    50. {
    51.   
    52.   // Normal local symbols start with ``.L''.
    53.   if (name[0] == '.' && name[1] == 'L')
    54.     return true;
    55.  
    56.   // At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
    57.   // DWARF debugging symbols starting with ``..''.
    58.   if (name[0] == '.' && name[1] == '.')
    59.     return true;
    60.  
    61.   // gcc will sometimes generate symbols beginning with ``_.L_'' when
    62.   // emitting DWARF debugging output.  I suspect this is actually a
    63.   // small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
    64.   // ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
    65.   // underscore to be emitted on some ELF targets).  For ease of use,
    66.   // we treat such symbols as local.
    67.   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
    68.     return true;
    69.  
    70.   return false;
    71. }
    72.  
    73. // Implementations of methods Target::do_make_elf_object are almost identical
    74. // except for the address sizes and endianities.  So we extract this
    75. // into a template.
    76. //  一个模板方法，用于创建一个 ELF 对象。这个方法的实现依赖于目标平台的地址大小和字节顺序。
    77. template<int size, bool big_endian>
    78. inline Object*
    79. Target::do_make_elf_object_implementation(
    80.     const std::string& name,
    81.     Input_file* input_file,
    82.     off_t offset,
    83.     const elfcpp::Ehdr& ehdr)
    84.  // name 是对象的名称，input_file 是输入文件对象，offset 是文件中 ELF 头的偏移，ehdr 是 ELF 头的信息。
    85.  
    86. {
    87.   int et = ehdr.get_e_type(); // 获取 ELF 文件类型
    88.   // ET_EXEC files are valid input for --just-symbols/-R,
    89.   // and we treat them as relocatable objects.
    90.   // elfcpp::ET_REL表示是可重定位对象文件,文件类型是 elfcpp::ET_EXEC 且输入文件是仅包含符号的情况（input_file->just_symbols()），则将其视为可重定位对象
    91.   // ET_REL (1): 表示可重定位文件     ET_EXEC (2): 表示可执行文件     ET_DYN (3): 表示共享对象文件  
    92.   if (et == elfcpp::ET_REL
    93.       || (et == elfcpp::ET_EXEC && input_file->just_symbols()))
    94.     {
    95.       Sized_relobj_file* obj =
    96. 	new Sized_relobj_file(name, input_file, offset, ehdr); 
    97.   //  Sized_relobj_file(name, input_file, offset, ehdr) 是模板类的实例化
    98.       obj->setup();
    99.       return obj;
    100.     }
    101.   else if (et == elfcpp::ET_DYN)
    102.     {
    103.       Sized_dynobj* obj =
    104. 	new Sized_dynobj(name, input_file, offset, ehdr);
    105.       obj->setup();
    106.       return obj;
    107.     }
    108.   else
    109.     {
    110.       gold_error(_("%s: unsupported ELF file type %d"),
    111. 		 name.c_str(), et);
    112.       return NULL;
    113.     }
    114. }
    115.  
    116. // Make an ELF object called NAME by reading INPUT_FILE at OFFSET.  EHDR
    117. // is the ELF header of the object.  There are four versions of this
    118. // for different address sizes and endianities.
    119. // LITTLE 位小端字节序 32 表示地址大小，
    120. #ifdef HAVE_TARGET_32_LITTLE
    121. Object*
    122. Target::do_make_elf_object(const std::string& name, Input_file* input_file,
    123. 			   off_t offset, const elfcpp::Ehdr<32, false>& ehdr)
    124. {
    125.   return this->do_make_elf_object_implementation<32, false>(name, input_file,
    126. 							    offset, ehdr);
    127. }
    128. #endif
    129.  
    130. #ifdef HAVE_TARGET_32_BIG
    131. Object*
    132. Target::do_make_elf_object(const std::string& name, Input_file* input_file,
    133. 			   off_t offset, const elfcpp::Ehdr<32, true>& ehdr)
    134. {
    135.   return this->do_make_elf_object_implementation<32, true>(name, input_file,
    136. 							   offset, ehdr);
    137. }
    138. #endif
    139.  
    140. #ifdef HAVE_TARGET_64_LITTLE
    141. Object*
    142. Target::do_make_elf_object(const std::string& name, Input_file* input_file,
    143. 			   off_t offset, const elfcpp::Ehdr<64, false>& ehdr)
    144. {
    145.   return this->do_make_elf_object_implementation<64, false>(name, input_file,
    146. 							    offset, ehdr);
    147. }
    148. #endif
    149.  
    150. #ifdef HAVE_TARGET_64_BIG
    151. Object*
    152. Target::do_make_elf_object(const std::string& name, Input_file* input_file,
    153. 			   off_t offset, const elfcpp::Ehdr<64, true>& ehdr)
    154. {
    155.   return this->do_make_elf_object_implementation<64, true>(name, input_file,
    156. 							   offset, ehdr);
    157. }
    158. #endif
    159.  
    160.  
    161.  
    162. // 用于创建输出段对象
    163. Output_section*
    164. Target::do_make_output_section(const char* name, elfcpp::Elf_Word type,
    165. 			       elfcpp::Elf_Xword flags)
    166. // 段的名称 name、段的类型 type 和段的标志 flags。
    167. {
    168.   // 链接器中创建输出段对象，以便后续将链接结果存储在这些段中，这些段将成为生成的可执行文件或共享库的一部分。
    169.   return new Output_section(name, type, flags);
    170. }
    171.  
    172.  
    173. // Default for whether a reloc is a call to a non-split function is
    174. // whether the symbol is a function.
    175. // 用于确定一个重定位是否是对非分割函数的调用
    176. /*
    177.   非分割函数" 指的是在程序的链接和执行过程中不会被拆分或分割成多个部分的函数。这意味着这些函数的定义是完整的，
    178.   没有被分成多个代码段，它们可以被直接调用并执行，而不需要进一步的合并或组装。这与 "分割函数" 形成对比，
    179.   分割函数通常被分成多个部分以实现某种特定的优化或节省内存的目的。
    180. */
    181.  
    182. bool
    183. Target::do_is_call_to_non_split(const Symbol* sym, const unsigned char*,
    184. 				const unsigned char*, section_size_type) const
    185. {
    186.   return sym->type() == elfcpp::STT_FUNC;
    187.   // 如果符号的类型是函数类型，那么函数返回 true，表示这个重定位是对非分割函数的调用；否则返回 false。
    188. }
    189.  
    190.  
    191. // Default conversion for -fsplit-stack is to give an error.
    192. // 用于处理在链接器中涉及到栈分割（stack split）支持的情况
    193. // 会设置 warned 为 false，并输出一条错误消息，指出链接器不包括栈分割支持，而栈分割是由链接对象（object）所需的
    194. void
    195. Target::do_calls_non_split(Relobj* object, unsigned int, section_offset_type,
    196. 			   section_size_type, const unsigned char*, size_t,
    197. 			   unsigned char*, section_size_type,
    198. 			   std::string*, std::string*) const
    199. {
    200.   static bool warned;
    201.   // 一次性警告
    202.   if (!warned)
    203.     {
    204.       gold_error(_("linker does not include stack split support "
    205. 		   "required by %s"),
    206. 		 object->name().c_str());
    207.       warned = true;
    208.     }
    209. }
    210.  
    211. //  Return whether BYTES/LEN matches VIEW/VIEW_SIZE at OFFSET.
    212. // 用于比较一个视图（view）中的字节数据是否与给定的字节数组匹配。
    213. // 函数会检查是否在给定的视图（view）中的指定偏移（offset）处的一段字节与指定的字节数组（bytes）匹配。
    214. /* 
    215. 视图"（View）通常是指对目标文件或可执行文件中的某一部分内存内容进行抽象和管理的一种数据结构或概念。
    216. 这些视图用于支持链接器的各种任务和操作，
    217. 包括但不限于以下几个方面：
    218. 内存管理： 视图可以用于管理目标文件或可执行文件在内存中的布局，包括各个段（sections）的起始地址、大小和属性。这有助于链接器将不同的目标文件组合成一个整体的可执行文件，保证各段在内存中的正确位置。
    219. 符号解析： 视图用于查找和定位目标文件中的符号表（symbol table），以便解析符号引用和符号定义。链接器使用视图来查找符号的地址，以便正确地建立符号引用关系。
    220. 重定位： 视图用于处理重定位信息，即在链接过程中对符号引用的地址进行修正。视图可以帮助链接器确定需要进行哪些重定位，以及如何修正目标文件中的地址，以适应最终的可执行文件。
    221. 段合并和填充： 在链接过程中，链接器可能需要将多个目标文件的段合并到一个输出段中，或者填充一些内存区域以满足对齐或布局的要求。视图用于管理这些操作，确保数据正确放置在内存中。
    222. 异常处理： 链接器可能需要生成或更新异常处理相关的信息，例如异常处理表（exception table）或调试信息，以便在程序出现异常时能够正确处理。
    223. */
    224. bool
    225. Target::match_view(const unsigned char* view, section_size_type view_size,
    226. 		   section_offset_type offset, const char* bytes,
    227. 		   size_t len) const
    228. {
    229.   if (offset + len > view_size)
    230.     return false;
    231.   return memcmp(view + offset, bytes, len) == 0;
    232. }
    233.  
    234. // Set the contents of a VIEW/VIEW_SIZE to nops starting at OFFSET
    235. // for LEN bytes.
    236.  
    237. void
    238. Target::set_view_to_nop(unsigned char* view, section_size_type view_size,
    239. 			section_offset_type offset, size_t len) const
    240. // 方法用于将一段内存设置为 NOP 指令。这个方法主要用于处理链接过程中的填充问题。
    241. {
    242.   gold_assert(offset >= 0 && offset + len <= view_size); 
    243.   // 检查链接器是否支持特点的代码填充方式 ，通过调用 this->has_code_fill() 来确定。
    244.   if (!this->has_code_fill())
    245.     memset(view + offset, 0, len);
    246.   else
    247.     {
    248.       // 使用 this->code_fill(len) 来获取填充的具体数据
    249.       std::string fill = this->code_fill(len);
    250.       // 使用 memcpy 将填充数据复制到内存视图的指定位置，
    251.       memcpy(view + offset, fill.data(), len);
    252.     }
    253. }
    254.  
    255. // Return address and size to plug into eh_frame FDEs associated with a PLT.
    256. void
    257. Target::do_plt_fde_location(const Output_data* plt, unsigned char*,
    258. 			    uint64_t* address, off_t* len) const
    259. //  方法用于获取 PLT 的 FDE 地址和大小。这个方法主要用于处理异常处理框架（EH frame）的问题。
    260.  
    261. {
    262.   *address = plt->address();
    263.   *len = plt->data_size();
    264. }
    265.  
    266. // Class Sized_target.
    267.  
    268. // Set the EI_OSABI field of the ELF header if requested.
    269.  
    270. template<int size, bool big_endian>
    271. void
    272. Sized_target::do_adjust_elf_header(unsigned char* view,
    273. 						     int len)
    274. {
    275.   // 用于调整 ELF 头的 EI_OSABI 字段。这个方法主要用于处理目标平台的 OS ABI 问题。
    276.   // 获取了当前目标平台的操作系统 ABI
    277.   elfcpp::ELFOSABI osabi = this->osabi();
    278.   if (osabi != elfcpp::ELFOSABI_NONE)
    279.     {
    280.       gold_assert(len == elfcpp::Elf_sizes::ehdr_size);
    281.  
    282.       elfcpp::Ehdr ehdr(view);
    283.       // 创建一个 ELF 头对象，根据给定的地址大小和字节顺序，该 ELF 头对象用于处理 ELF 文件头信息
    284.       unsigned char e_ident[elfcpp::EI_NIDENT];
    285.       // 创建了一个用于存储 ELF 头标识字段（e_ident）的数组
    286.       memcpy(e_ident, ehdr.get_e_ident(), elfcpp::EI_NIDENT);
    287.       // 将原始 ELF 头的标识字段复制到新的数组中
    288.       e_ident[elfcpp::EI_OSABI] = osabi;
    289.       // 新的标识字段中的 EI_OSABI 字段为操作系统 ABI 的值
    290.       elfcpp::Ehdr_write oehdr(view);
    291.       // 创建一个可写的 ELF 头对象，用于将修改后的标识字段写回原始 ELF 头的视图中
    292.       oehdr.put_e_ident(e_ident);
    293.     }
    294. }
    295.  
    296. //  Sized_target 类的模板实例化。这些实例化分别对应了 32 位/64 位 和 大端/小端 的目标平台。
    297.  
    298. #ifdef HAVE_TARGET_32_LITTLE
    299. template
    300. class Sized_target<32, false>;
    301. #endif
    302.  
    303. #ifdef HAVE_TARGET_32_BIG
    304. template
    305. class Sized_target<32, true>;
    306. #endif
    307.  
    308. #ifdef HAVE_TARGET_64_LITTLE
    309. template
    310. class Sized_target<64, false>;
    311. #endif
    312.  
    313. #ifdef HAVE_TARGET_64_BIG
    314. template
    315. class Sized_target<64, true>;
    316. #endif
    317.  
    318. } // End namespace gold.

  • 相关阅读:
    bootstrap-datepicker控件的使用及修改位置错误问题
    WebSocket Day04 : 消息推送
    前端Vue预览下载pdf文件后台管理
    【图像处理】【应用程序设计】加载，编辑和保存图像数据、图像分割、色度键控研究（Matlab代码实现）
    C++实现对Json数据的友好处理
    【第十五篇】Camunda系列-任务回退【驳回回退】
    创造者设计模式
    IO 框架
    GerbView生产高级软件,支持新旧表单
    晶振分频【FPGA】
  • 原文地址：https://blog.csdn.net/leimeili/article/details/134284729