• GNU ld链接器 lang_process()(二）

    一、ldemul_create_output_section_statements()

    位于lang_process()中11行  。  该函数用于创建与目标有关的输出段的语句。这些语句将用于描述输出段的属性和分配。

    1. void
    2. ldemul_create_output_section_statements (void)
    3. {
    4.   if (ld_emulation->create_output_section_statements)
    5.     ld_emulation->create_output_section_statements ();
    6. }
    static ld_emulation_xfer_type *ld_emulation;
    1.   /* Create any output sections needed by the target.  */
    2.   void	(*create_output_section_statements) (void);  // 14
    1. typedef struct ld_emulation_xfer_struct {
    2.   /* Run before parsing the command line and script file.
    3.      Set the architecture, maybe other things.  */
    4.   void   (*before_parse) (void); // 1
    5.  
    6.   /* Handle the SYSLIB (low level library) script command.  */
    7.   void   (*syslib) (char *);  // 2
    8.  
    9.   /* Handle the HLL (high level library) script command.  */
    10.   void   (*hll) (char *);  // 3
    11.  
    12.   /* Run after parsing the command line and script file.  */
    13.   void   (*after_parse) (void);  // 4
    14.  
    15.   /* Run after opening all input files, and loading the symbols.  */
    16.   void   (*after_open) (void);  // 5
    17.  
    18.   /* Run after allocating output sections.  */
    19.   void   (*after_allocation)  (void);  // 6
    20.  
    21.   /* Set the output architecture and machine if possible.  */
    22.   void   (*set_output_arch) (void);  // 7
    23.  
    24.   /* Decide which target name to use.  */
    25.   char * (*choose_target) (int, char**);  // 8
    26.  
    27.   /* Run before allocating output sections.  */
    28.   void   (*before_allocation) (void);  // 9
    29.  
    30.   /* Return the appropriate linker script.  */
    31.   char * (*get_script) (int *isfile);  // 10
    32.  
    33.   /* The name of this emulation.  */
    34.   char *emulation_name;  // 11
    35.  
    36.   /* The output format.  */
    37.   char *target_name;  // 12
    38.  
    39.   /* Run after assigning values from the script.  */
    40.   void	(*finish) (void);  // 13
    41.  
    42.   /* Create any output sections needed by the target.  */
    43.   void	(*create_output_section_statements) (void);  // 14
    44.  
    45.   /* Try to open a dynamic library.  ARCH is an architecture name, and
    46.      is normally the empty string.  ENTRY is the lang_input_statement
    47.      that should be opened.  */
    48.   bfd_boolean (*open_dynamic_archive)
    49.     (const char *arch, struct search_dirs *,
    50.      struct lang_input_statement_struct *entry);  // 15
    51.  
    52.   /* Place an orphan section.  Return TRUE if it was placed, FALSE if
    53.      the default action should be taken.  This field may be NULL, in
    54.      which case the default action will always be taken.  */
    55.   lang_output_section_statement_type *(*place_orphan)
    56.     (asection *, const char *, int);  // 16
    57.  
    58.   /* Run after assigning parsing with the args, but before
    59.      reading the script.  Used to initialize symbols used in the script.  */
    60.   void	(*set_symbols) (void);  // 17
    61.  
    62.   /* Parse args which the base linker doesn't understand.
    63.      Return TRUE if the arg needs no further processing.  */
    64.   bfd_boolean (*parse_args) (int, char **);  // 18
    65.  
    66.   /* Hook to add options to parameters passed by the base linker to
    67.      getopt_long and getopt_long_only calls.  */
    68.   void (*add_options)
    69.     (int, char **, int, struct option **, int, struct option **);  // 19
    70.  
    71.   /* Companion to the above to handle an option.  Returns TRUE if it is
    72.      one of our options.  */
    73.   bfd_boolean (*handle_option) (int);  // 20
    74.  
    75.   /* Run to handle files which are not recognized as object files or
    76.      archives.  Return TRUE if the file was handled.  */
    77.   bfd_boolean (*unrecognized_file)
    78.     (struct lang_input_statement_struct *);  // 21
    79.  
    80.   /* Run to list the command line options which parse_args handles.  */
    81.   void (* list_options) (FILE *);  // 22
    82.  
    83.   /* Run to specially handle files which *are* recognized as object
    84.      files or archives.  Return TRUE if the file was handled.  */
    85.   bfd_boolean (*recognized_file)
    86.     (struct lang_input_statement_struct *);  // 23
    87.  
    88.   /* Called when looking for libraries in a directory specified
    89.      via a linker command line option or linker script option.
    90.      Files that match the pattern "lib*.a" have already been scanned.
    91.      (For VMS files matching ":lib*.a" have also been scanned).  */
    92.   int (* find_potential_libraries)
    93.     (char *, struct lang_input_statement_struct *);  // 24
    94.  
    95.   /* Called when adding a new version pattern.  PowerPC64-ELF uses
    96.      this hook to add a pattern matching ".foo" for every "foo".  */
    97.   struct bfd_elf_version_expr * (*new_vers_pattern)
    98.     (struct bfd_elf_version_expr *);  // 25
    99.  
    100.   /* Called when printing the map file, in case there are
    101.      emulation-specific sections for it.  */
    102.   void (*extra_map_file_text)
    103.     (bfd *, struct bfd_link_info *, FILE *);  // 26
    104.  
    105. } ld_emulation_xfer_type;

    二、lang_place_undefineds ()

     将命令行中所有未定义的符号加入哈希表中

    结构体类型：

    struct bfd_sym_chain：

    • 这是一个结构体定义，表示符号链的链接列表节点。每个节点包含指向下一个节点的指针和指向字符字符串的指针（可能是符号名称）。

    • typedef struct bfd_sym_chain ldlang_undef_chain_list_type：

    • 这行代码为struct bfd_sym_chain创建了类型别名ldlang_undef_chain_list_type，以便更容易使用和声明这种类型的变量。

    • #define ldlang_undef_chain_list_head entry_symbol.next：

    • 这似乎是一个预处理器宏，将ldlang_undef_chain_list_head定义为entry_symbol.next。它可能用作访问符号链节点的next字段的简写。
    1. struct bfd_sym_chain
    2. {
    3.   struct bfd_sym_chain *next;
    4.   const char *name;
    5. };
    6.  
    7. typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
    8.  
    9. #define ldlang_undef_chain_list_head entry_symbol.next
    函数： 

    static void lang_place_undefineds(void)：

    • 这是一个函数定义的开始，名为lang_place_undefineds。它是一个静态函数，意味着它仅限于当前的翻译单元。这个函数的目的是遍历未定义符号（ldlang_undef_chain_list_type）的列表，并为每个符号的名称调用insert_undefined。
    1. static void
    2. lang_place_undefineds (void)
    3. //   /* Add to the hash table all undefineds on the command line.  */
    4. {
    5.   ldlang_undef_chain_list_type *ptr;
    6.  
    7.   for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
    8.     insert_undefined (ptr->name);
    9. }

    static void insert_undefined(const char *name)：

    • 这是另一个静态函数定义，名为insert_undefined。它以字符串（name）作为参数。这个函数的目的是将未定义符号插入符号表中。它首先使用bfd_link_hash_lookup在哈希表中查找符号，如果找不到，则使用bfd_link_add_undef添加它。

     

    1. /* Insert NAME as undefined in the symbol table.  */
    2.  
    3. static void
    4. insert_undefined (const char *name)
    5. {
    6.   struct bfd_link_hash_entry *h;
    7.  
    8.   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
    9.   if (h == NULL)
    10.     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
    11.   if (h->type == bfd_link_hash_new)
    12.     {
    13.       h->type = bfd_link_hash_undefined;
    14.       h->u.undef.abfd = NULL;
    15.       bfd_link_add_undef (link_info.hash, h);
    16.     }
    17. }

    bfd_link_hash_lookup和bfd_hash_lookup函数：

    • 这些函数用于在哈希表中查找条目。bfd_link_hash_lookup似乎用于在符号哈希表中查找条目，而bfd_hash_lookup是一个更一般的哈希表查找函数。这些函数通过对输入字符串进行哈希并在哈希表中搜索相应的条目来工作。

    • bfd_hash_insert函数：

    • 此函数用于将新条目插入哈希表。它为条目分配内存，计算哈希值，并将条目插入哈希表的适当位置。如果需要，它还处理表的大小调整。
    1. struct bfd_link_hash_entry *
    2. bfd_link_hash_lookup (struct bfd_link_hash_table *table,
    3. 		      const char *string,
    4. 		      bfd_boolean create,  // T
    5. 		      bfd_boolean copy,  // F
    6. 		      bfd_boolean follow)  // T
    7. {
    8.   struct bfd_link_hash_entry *ret;
    9.  
    10.   ret = ((struct bfd_link_hash_entry *)
    11. 	 bfd_hash_lookup (&table->table, string, create, copy));
    12.  
    13.   if (follow && ret != NULL)
    14.     {
    15.       while (ret->type == bfd_link_hash_indirect
    16. 	     || ret->type == bfd_link_hash_warning)
    17. 	ret = ret->u.i.link;
    18.     }
    19.  
    20.   return ret;
    21. }
    1. struct bfd_hash_entry *
    2. bfd_hash_lookup (struct bfd_hash_table *table,
    3. 		 const char *string,
    4. 		 bfd_boolean create,  // T
    5. 		 bfd_boolean copy)  // F
    6. {
    7.   unsigned long hash;
    8.   struct bfd_hash_entry *hashp;
    9.   unsigned int len;
    10.   unsigned int _index;
    11.  
    12.   hash = bfd_hash_hash (string, &len);
    13.   _index = hash % table->size;
    14.   for (hashp = table->table[_index];
    15.        hashp != NULL;
    16.        hashp = hashp->next)
    17.     {
    18.       if (hashp->hash == hash
    19. 	  && strcmp (hashp->string, string) == 0)
    20. 	return hashp;
    21.     }
    22.  
    23.   if (! create)
    24.     return NULL;
    25.  
    26.   if (copy)
    27.     {
    28.       char *new_string;
    29.  
    30.       new_string = (char *) objalloc_alloc ((struct objalloc *) table->memory,
    31.                                             len + 1);
    32.       if (!new_string)
    33. 	{
    34. 	  bfd_set_error (bfd_error_no_memory);
    35. 	  return NULL;
    36. 	}
    37.       memcpy (new_string, string, len + 1);
    38.       string = new_string;
    39.     }
    40.  
    41.   return bfd_hash_insert (table, string, hash);
    42. }
    1. struct bfd_hash_entry *
    2. bfd_hash_insert (struct bfd_hash_table *table,
    3. 		 const char *string,
    4. 		 unsigned long hash)
    5. {
    6.   struct bfd_hash_entry *hashp;
    7.   unsigned int _index;
    8.  
    9.   hashp = (*table->newfunc) (NULL, table, string);
    10.   if (hashp == NULL)
    11.     return NULL;
    12.   hashp->string = string;
    13.   hashp->hash = hash;
    14.   _index = hash % table->size;
    15.   hashp->next = table->table[_index];
    16.   table->table[_index] = hashp;
    17.   table->count++;
    18.  
    19.   if (!table->frozen && table->count > table->size * 3 / 4)
    20.     {
    21.       unsigned long newsize = higher_prime_number (table->size);
    22.       struct bfd_hash_entry **newtable;
    23.       unsigned int hi;
    24.       unsigned long alloc = newsize * sizeof (struct bfd_hash_entry *);
    25.  
    26.       /* If we can't find a higher prime, or we can't possibly alloc
    27. 	 that much memory, don't try to grow the table.  */
    28.       if (newsize == 0 || alloc / sizeof (struct bfd_hash_entry *) != newsize)
    29. 	{
    30. 	  table->frozen = 1;
    31. 	  return hashp;
    32. 	}
    33.  
    34.       newtable = ((struct bfd_hash_entry **)
    35. 		  objalloc_alloc ((struct objalloc *) table->memory, alloc));
    36.       if (newtable == NULL)
    37. 	{
    38. 	  table->frozen = 1;
    39. 	  return hashp;
    40. 	}
    41.       memset (newtable, 0, alloc);
    42.  
    43.       for (hi = 0; hi < table->size; hi ++)
    44. 	while (table->table[hi])
    45. 	  {
    46. 	    struct bfd_hash_entry *chain = table->table[hi];
    47. 	    struct bfd_hash_entry *chain_end = chain;
    48.  
    49. 	    while (chain_end->next && chain_end->next->hash == chain->hash)
    50. 	      chain_end = chain_end->next;
    51.  
    52. 	    table->table[hi] = chain_end->next;
    53. 	    _index = chain->hash % newsize;
    54. 	    chain_end->next = newtable[_index];
    55. 	    newtable[_index] = chain;
    56. 	  }
    57.       table->table = newtable;
    58.       table->size = newsize;
    59.     }
    60.  
    61.   return hashp;
    62. }

  • 相关阅读:
    牛客小白月赛62
    【笔记】大话设计模式-567
    设计模式之建造者模式
    非母语玩家如何撰写英文研究性论文：1 Introduction
    java正则表达式 及应用场景爬虫,捕获分组非捕获分组
    Session会话追踪的实现机制
    基于SSM 实现增删查改
    2. 一步步搭建多层神经网络及应用
    生产经验篇(2)——真实环境的MySQL机器配置规划
    LLM 大模型技术图谱（LLM Tech Map）
  • 原文地址：https://blog.csdn.net/leimeili/article/details/134186284