Lines Matching defs:table
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);
466 /* Initialize a link hash table. The BFD argument is the one
467 responsible for creating this table. */
471 (struct bfd_link_hash_table *table,
478 table->creator = abfd->xvec;
479 table->undefs = NULL;
480 table->undefs_tail = NULL;
481 table->type = bfd_link_generic_hash_table;
483 return bfd_hash_table_init (&table->table, newfunc, entsize);
486 /* Look up a symbol in a link hash table. If follow is TRUE, we
491 bfd_link_hash_lookup (struct bfd_link_hash_table *table,
500 bfd_hash_lookup (&table->table, string, create, copy));
512 /* Look up a symbol in the main linker hash table if the symbol might
599 /* Traverse a generic link hash table. The only reason this is not a
607 (struct bfd_link_hash_table *table,
611 bfd_hash_traverse (&table->table,
616 /* Add a symbol to the linker hash table undefs list. */
619 bfd_link_add_undef (struct bfd_link_hash_table *table,
623 if (table->undefs_tail != NULL)
624 table->undefs_tail->u.undef.next = h;
625 if (table->undefs == NULL)
626 table->undefs = h;
627 table->undefs_tail = h;
638 bfd_link_repair_undef_list (struct bfd_link_hash_table *table)
642 pun = &table->undefs;
652 if (h == table->undefs_tail)
654 if (pun == &table->undefs)
655 table->undefs_tail = NULL;
659 table->undefs_tail = (struct bfd_link_hash_entry *)
670 /* Routine to create an entry in a generic link hash table. */
674 struct bfd_hash_table *table,
682 bfd_hash_allocate (table, sizeof (struct generic_link_hash_entry));
688 entry = _bfd_link_hash_newfunc (entry, table, string);
702 /* Create a generic link hash table. */
729 bfd_hash_table_free (&ret->root.table);
737 the hash table pointing to different instances of the symbol
765 global hash table. This version does not automatically collect
775 hash table. This version automatically collects constructors by
799 /* Add symbols from an object file to the global hash table. */
828 /* Add symbols from an object file to the global hash table. */
846 /* We build a hash table of all symbols defined in an archive. */
857 /* An entry in an archive hash table. */
866 /* An archive hash table itself. */
870 struct bfd_hash_table table;
873 /* Create a new entry for an archive hash table. */
877 struct bfd_hash_table *table,
885 ret = bfd_hash_allocate (table, sizeof (struct archive_hash_entry));
891 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
902 /* Initialize an archive hash table. */
906 (struct archive_hash_table *table,
912 return bfd_hash_table_init (&table->table, newfunc, entsize);
915 /* Look up an entry in an archive hash table. */
919 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
921 /* Allocate space in an archive hash table. */
923 #define archive_hash_allocate(t, size) bfd_hash_allocate (&(t)->table, (size))
925 /* Free an archive hash table. */
927 #define archive_hash_table_free(t) bfd_hash_table_free (&(t)->table)
930 hash file. This function presumes that the archive symbol table
933 common symbols and searches the archive symbol table for them. If
937 The old linker looked through the archive symbol table for
942 re-search the symbol table each time a new object file was added.
948 to the global hash table. CHECKFN should only return FALSE if some
989 this archive, we build a hash table of the symbols. */
1249 bfd_hash_allocate (&info->hash->table,
1284 /* Add the symbols from an object file to the global hash table. ABFD
1364 hash table other than the generic hash table, so we only
1365 do this if we are certain that the hash table is a
1384 table entry for the benefit of relaxation code until
1396 /* We use a state table to deal with adding symbols from an object
1397 file. The first index into the state table describes the symbol
1398 from the object file. The second index into the state table is the
1399 type of the symbol in the hash table. */
1419 /* The actions to take in the state table. */
1447 /* The state table itself. The first index is a link_row and the
1463 /* Most of the entries in the LINK_ACTION table are straightforward,
1509 /* Add a symbol to the global hash table.
1523 HASHP, if not NULL, is a place to store the created hash table
1525 the hash table entry, and stored it in *HASHP. */
1702 bfd_hash_allocate (&info->hash->table,
1968 ((*info->hash->table.newfunc)
1969 (NULL, &info->hash->table, h->root.string)));
1982 w = bfd_hash_allocate (&info->hash->table, len);
1989 bfd_hash_replace (&info->hash->table,
2025 /* Build the output symbol table. */
2250 this routine will be called with a hash table
2251 other than a generic hash table, so we double
2395 hash table entry. */
2456 This is called for each symbol in the hash table. */
2907 /* The hash table. */
2911 /* Support routines for the hash table used by section_already_linked,
2912 initialize the table, traverse, lookup, fill in an entry and remove
2913 the table. */
2941 /* Allocate the memory from the same obstack as the hash table is
2951 struct bfd_hash_table *table,
2955 bfd_hash_allocate (table, sizeof *ret);