binutils/bfd/linker.c

40 	The first routine creates a hash table used by the other
42 	file to the hash table.  The third routine takes all the
53 	including the linker hash table (which was created by the
72 	Creating a linker hash table
76 	The linker routines must create a hash table, which must be
79 	create a derived hash table.  This entry point is called using
83 	and initialize an instance of the desired hash table.  If the
85 	stored with the entries in the hash table, the entry point may
89 	For example, with each entry in the hash table the a.out
94 	defines the required structures and functions for a hash table
96 	hash table is created by the function
98 	space for the hash table, initializes it, and returns a
103 	you have finished.  You should simply create a new hash table
110 	Adding symbols to the hash table
120 	the hash table.  For an archive, BFD must determine which
143 	consequence: the function may not assume that the hash table
147 	table is that it is derived from <<struct
151 	some information in the hash table entry to be used by the
153 	field of the hash table must be checked to make sure that the
154 	hash table was created by an object file of the same format.
161 	of how a hash table entry is added, all the fields will be
162 	initialized to some sort of null value by the hash table entry
168 	hash table entry.
177 	object file to the hash table.  The actual work of adding the
178 	symbol to the hash table is normally handled by the function
212 	the hash table lookup routine to locate the entry.
224 	symbols from the object file to the linker hash table.
230 	function builds a hash table from the archive symbol table and
236 	symbols to the linker hash table.
244 	the elements symbols must be added to the linker hash table
258 	linker hash table.
262 	archives already contain a hash table of symbols.  The ECOFF
264 	creating a new hash table.
278 	It must build an output symbol table including any local
280 	hash table.  When producing relocatable output, it must
295 @* Writing the symbol table::
323 Relocating the section contents, Writing the symbol table, Information provided by the linker, Performing the Final Link
361 Writing the symbol table, , Relocating the section contents, Performing the Final Link
363 	Writing the symbol table
367 	all the symbols in the global hash table.  This must be
372 	entered into the linker hash table.  The <<_bfd_final_link>>
379 	hash table to gather all the externally visible symbols.  It
382 	but it is still necessary to traverse the hash table since the
390 	structure is a hash table of symbols to keep; each symbol
391 	should be looked up in this hash table, and only symbols which
403 	traversing the global hash table with the function
404 	<<aout_link_write_other_symbol>>.  It builds a string table
430 /* The link hash table structure is defined in bfdlink.h.  It provides
431    a base hash table which the backend specific hash tables are built
434 /* Routine to create an entry in the link hash table.  */
438 			struct bfd_hash_table *table,
445       entry = bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry));
451   entry = bfd_hash_newfunc (entry, table, string);
464 /* Initialize a link hash table.  The BFD argument is the one
465    responsible for creating this table.  */
469   (struct bfd_link_hash_table *table,
475   table->creator = abfd->xvec;
476   table->undefs = NULL;
477   table->undefs_tail = NULL;
478   table->type = bfd_link_generic_hash_table;
480   return bfd_hash_table_init (&table->table, newfunc);
483 /* Look up a symbol in a link hash table.  If follow is TRUE, we
488 bfd_link_hash_lookup (struct bfd_link_hash_table *table,
497 	 bfd_hash_lookup (&table->table, string, create, copy));
509 /* Look up a symbol in the main linker hash table if the symbol might
596 /* Traverse a generic link hash table.  The only reason this is not a
604   (struct bfd_link_hash_table *table,
608   bfd_hash_traverse (&table->table,
613 /* Add a symbol to the linker hash table undefs list.  */
616 bfd_link_add_undef (struct bfd_link_hash_table *table,
620   if (table->undefs_tail != NULL)
621     table->undefs_tail->und_next = h;
622   if (table->undefs == NULL)
623     table->undefs = h;
624   table->undefs_tail = h;
628 /* Routine to create an entry in a generic link hash table.  */
632 				struct bfd_hash_table *table,
640 	bfd_hash_allocate (table, sizeof (struct generic_link_hash_entry));
646   entry = _bfd_link_hash_newfunc (entry, table, string);
660 /* Create a generic link hash table.  */
686   bfd_hash_table_free (&ret->root.table);
694    the hash table pointing to different instances of the symbol
722    global hash table.  This version does not automatically collect
732    hash table.  This version automatically collects constructors by
756 /* Add symbols from an object file to the global hash table.  */
785 /* Add symbols from an object file to the global hash table.  */
803 /* We build a hash table of all symbols defined in an archive.  */
814 /* An entry in an archive hash table.  */
823 /* An archive hash table itself.  */
827   struct bfd_hash_table table;
830 /* Create a new entry for an archive hash table.  */
834 		      struct bfd_hash_table *table,
842     ret = bfd_hash_allocate (table, sizeof (struct archive_hash_entry));
848 	 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
859 /* Initialize an archive hash table.  */
863   (struct archive_hash_table *table,
868   return bfd_hash_table_init (&table->table, newfunc);
871 /* Look up an entry in an archive hash table.  */
875    bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
877 /* Allocate space in an archive hash table.  */
879 #define archive_hash_allocate(t, size) bfd_hash_allocate (&(t)->table, (size))
881 /* Free an archive hash table.  */
883 #define archive_hash_table_free(t) bfd_hash_table_free (&(t)->table)
886    hash file.  This function presumes that the archive symbol table
889    common symbols and searches the archive symbol table for them.  If
893    The old linker looked through the archive symbol table for
898    re-search the symbol table each time a new object file was added.
904    to the global hash table.  CHECKFN should only return FALSE if some
945      this archive, we build a hash table of the symbols.  */
1204 	    bfd_hash_allocate (&info->hash->table,
1239 /* Add the symbols from an object file to the global hash table.  ABFD
1319 	     hash table other than the generic hash table, so we only
1320 	     do this if we are certain that the hash table is a
1339 	     table entry for the benefit of relaxation code until
1351 /* We use a state table to deal with adding symbols from an object
1352    file.  The first index into the state table describes the symbol
1353    from the object file.  The second index into the state table is the
1354    type of the symbol in the hash table.  */
1374 /* The actions to take in the state table.  */
1402 /* The state table itself.  The first index is a link_row and the
1418 /* Most of the entries in the LINK_ACTION table are straightforward,
1464 /* Add a symbol to the global hash table.
1478    HASHP, if not NULL, is a place to store the created hash table
1480      the hash table entry, and stored it in *HASHP.  */
1657 	    bfd_hash_allocate (&info->hash->table,
1923 		   ((*info->hash->table.newfunc)
1924 		    (NULL, &info->hash->table, h->root.string)));
1937 		w = bfd_hash_allocate (&info->hash->table, len);
1944 	    bfd_hash_replace (&info->hash->table,
1980   /* Build the output symbol table.  */
2205 		 this routine will be called with a hash table
2206 		 other than a generic hash table, so we double
2351    hash table entry.  */
2412    This is called for each symbol in the hash table.  */