daily update
[binutils.git] / bfd / elf-bfd.h
blobc457a399f34f0e9157b95a2c2891590447e616d3
1 /* BFD back-end data structures for ELF files.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
11 (at your option) any later version.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #ifndef _LIBELF_H_
23 #define _LIBELF_H_ 1
25 #include "elf/common.h"
26 #include "elf/internal.h"
27 #include "elf/external.h"
28 #include "bfdlink.h"
30 /* The number of entries in a section is its size divided by the size
31 of a single entry. This is normally only applicable to reloc and
32 symbol table sections. */
33 #define NUM_SHDR_ENTRIES(shdr) ((shdr)->sh_size / (shdr)->sh_entsize)
35 /* If size isn't specified as 64 or 32, NAME macro should fail. */
36 #ifndef NAME
37 #if ARCH_SIZE == 64
38 #define NAME(x, y) x ## 64 ## _ ## y
39 #endif
40 #if ARCH_SIZE == 32
41 #define NAME(x, y) x ## 32 ## _ ## y
42 #endif
43 #endif
45 #ifndef NAME
46 #define NAME(x, y) x ## NOSIZE ## _ ## y
47 #endif
49 #define ElfNAME(X) NAME(Elf,X)
50 #define elfNAME(X) NAME(elf,X)
52 /* Information held for an ELF symbol. The first field is the
53 corresponding asymbol. Every symbol is an ELF file is actually a
54 pointer to this structure, although it is often handled as a
55 pointer to an asymbol. */
57 typedef struct
59 /* The BFD symbol. */
60 asymbol symbol;
61 /* ELF symbol information. */
62 Elf_Internal_Sym internal_elf_sym;
63 /* Backend specific information. */
64 union
66 unsigned int hppa_arg_reloc;
67 void *mips_extr;
68 void *any;
70 tc_data;
72 /* Version information. This is from an Elf_Internal_Versym
73 structure in a SHT_GNU_versym section. It is zero if there is no
74 version information. */
75 unsigned short version;
77 } elf_symbol_type;
79 struct elf_strtab_hash;
80 struct got_entry;
81 struct plt_entry;
83 /* ELF linker hash table entries. */
85 struct elf_link_hash_entry
87 struct bfd_link_hash_entry root;
89 /* Symbol index in output file. This is initialized to -1. It is
90 set to -2 if the symbol is used by a reloc. */
91 long indx;
93 /* Symbol index as a dynamic symbol. Initialized to -1, and remains
94 -1 if this is not a dynamic symbol. */
95 /* ??? Note that this is consistently used as a synonym for tests
96 against whether we can perform various simplifying transformations
97 to the code. (E.g. changing a pc-relative jump to a PLT entry
98 into a pc-relative jump to the target function.) That test, which
99 is often relatively complex, and someplaces wrong or incomplete,
100 should really be replaced by a predicate in elflink.c.
102 End result: this field -1 does not indicate that the symbol is
103 not in the dynamic symbol table, but rather that the symbol is
104 not visible outside this DSO. */
105 long dynindx;
107 /* String table index in .dynstr if this is a dynamic symbol. */
108 unsigned long dynstr_index;
110 /* Hash value of the name computed using the ELF hash function. */
111 unsigned long elf_hash_value;
113 /* If this is a weak defined symbol from a dynamic object, this
114 field points to a defined symbol with the same value, if there is
115 one. Otherwise it is NULL. */
116 struct elf_link_hash_entry *weakdef;
118 /* Version information. */
119 union
121 /* This field is used for a symbol which is not defined in a
122 regular object. It points to the version information read in
123 from the dynamic object. */
124 Elf_Internal_Verdef *verdef;
125 /* This field is used for a symbol which is defined in a regular
126 object. It is set up in size_dynamic_sections. It points to
127 the version information we should write out for this symbol. */
128 struct bfd_elf_version_tree *vertree;
129 } verinfo;
131 /* Virtual table entry use information. This array is nominally of size
132 size/sizeof(target_void_pointer), though we have to be able to assume
133 and track a size while the symbol is still undefined. It is indexed
134 via offset/sizeof(target_void_pointer). */
135 size_t vtable_entries_size;
136 bfd_boolean *vtable_entries_used;
138 /* Virtual table derivation info. */
139 struct elf_link_hash_entry *vtable_parent;
141 /* If this symbol requires an entry in the global offset table, the
142 processor specific backend uses this field to track usage and
143 final offset. Two schemes are supported: The first assumes that
144 a symbol may only have one GOT entry, and uses REFCOUNT until
145 size_dynamic_sections, at which point the contents of the .got is
146 fixed. Afterward, if OFFSET is -1, then the symbol does not
147 require a global offset table entry. The second scheme allows
148 multiple GOT entries per symbol, managed via a linked list
149 pointed to by GLIST. */
150 union gotplt_union
152 bfd_signed_vma refcount;
153 bfd_vma offset;
154 struct got_entry *glist;
155 struct plt_entry *plist;
156 } got;
158 /* Same, but tracks a procedure linkage table entry. */
159 union gotplt_union plt;
161 /* Symbol size. */
162 bfd_size_type size;
164 /* Symbol type (STT_NOTYPE, STT_OBJECT, etc.). */
165 char type;
167 /* Symbol st_other value, symbol visibility. */
168 unsigned char other;
170 /* Some flags; legal values follow. */
171 unsigned short elf_link_hash_flags;
172 /* Symbol is referenced by a non-shared object. */
173 #define ELF_LINK_HASH_REF_REGULAR 01
174 /* Symbol is defined by a non-shared object. */
175 #define ELF_LINK_HASH_DEF_REGULAR 02
176 /* Symbol is referenced by a shared object. */
177 #define ELF_LINK_HASH_REF_DYNAMIC 04
178 /* Symbol is defined by a shared object. */
179 #define ELF_LINK_HASH_DEF_DYNAMIC 010
180 /* Symbol has a non-weak reference from a non-shared object. */
181 #define ELF_LINK_HASH_REF_REGULAR_NONWEAK 020
182 /* Dynamic symbol has been adjustd. */
183 #define ELF_LINK_HASH_DYNAMIC_ADJUSTED 040
184 /* Symbol needs a copy reloc. */
185 #define ELF_LINK_HASH_NEEDS_COPY 0100
186 /* Symbol needs a procedure linkage table entry. */
187 #define ELF_LINK_HASH_NEEDS_PLT 0200
188 /* Symbol appears in a non-ELF input file. */
189 #define ELF_LINK_NON_ELF 0400
190 /* Symbol should be marked as hidden in the version information. */
191 #define ELF_LINK_HIDDEN 01000
192 /* Symbol was forced to local scope due to a version script file. */
193 #define ELF_LINK_FORCED_LOCAL 02000
194 /* Symbol was marked during garbage collection. */
195 #define ELF_LINK_HASH_MARK 04000
196 /* Symbol is referenced by a non-GOT/non-PLT relocation. This is
197 not currently set by all the backends. */
198 #define ELF_LINK_NON_GOT_REF 010000
199 /* Symbol has a definition in a shared object. */
200 #define ELF_LINK_DYNAMIC_DEF 020000
201 /* Symbol is weak in all shared objects. */
202 #define ELF_LINK_DYNAMIC_WEAK 040000
203 /* Symbol is referenced with a relocation where C/C++ pointer equality
204 matters. */
205 #define ELF_LINK_POINTER_EQUALITY_NEEDED 0100000
208 /* Will references to this symbol always reference the symbol
209 in this object? STV_PROTECTED is excluded from the visibility test
210 here so that function pointer comparisons work properly. Since
211 function symbols not defined in an app are set to their .plt entry,
212 it's necessary for shared libs to also reference the .plt even
213 though the symbol is really local to the shared lib. */
214 #define SYMBOL_REFERENCES_LOCAL(INFO, H) \
215 _bfd_elf_symbol_refs_local_p (H, INFO, 0)
217 /* Will _calls_ to this symbol always call the version in this object? */
218 #define SYMBOL_CALLS_LOCAL(INFO, H) \
219 _bfd_elf_symbol_refs_local_p (H, INFO, 1)
221 /* Records local symbols to be emitted in the dynamic symbol table. */
223 struct elf_link_local_dynamic_entry
225 struct elf_link_local_dynamic_entry *next;
227 /* The input bfd this symbol came from. */
228 bfd *input_bfd;
230 /* The index of the local symbol being copied. */
231 long input_indx;
233 /* The index in the outgoing dynamic symbol table. */
234 long dynindx;
236 /* A copy of the input symbol. */
237 Elf_Internal_Sym isym;
240 struct elf_link_loaded_list
242 struct elf_link_loaded_list *next;
243 bfd *abfd;
246 /* Structures used by the eh_frame optimization code. */
247 struct cie_header
249 unsigned int length;
250 unsigned int id;
253 struct cie
255 struct cie_header hdr;
256 unsigned char version;
257 unsigned char augmentation[20];
258 unsigned int code_align;
259 int data_align;
260 unsigned int ra_column;
261 unsigned int augmentation_size;
262 struct elf_link_hash_entry *personality;
263 unsigned char per_encoding;
264 unsigned char lsda_encoding;
265 unsigned char fde_encoding;
266 unsigned char initial_insn_length;
267 unsigned char make_relative;
268 unsigned char make_lsda_relative;
269 unsigned char initial_instructions[50];
272 struct eh_cie_fde
274 unsigned int offset;
275 unsigned int size;
276 asection *sec;
277 unsigned int new_offset;
278 unsigned char fde_encoding;
279 unsigned char lsda_encoding;
280 unsigned char lsda_offset;
281 unsigned char cie : 1;
282 unsigned char removed : 1;
283 unsigned char make_relative : 1;
284 unsigned char make_lsda_relative : 1;
285 unsigned char per_encoding_relative : 1;
288 struct eh_frame_sec_info
290 unsigned int count;
291 unsigned int alloced;
292 struct eh_cie_fde entry[1];
295 struct eh_frame_array_ent
297 bfd_vma initial_loc;
298 bfd_vma fde;
301 struct eh_frame_hdr_info
303 struct cie last_cie;
304 asection *last_cie_sec;
305 asection *hdr_sec;
306 unsigned int last_cie_offset;
307 unsigned int fde_count, array_count;
308 struct eh_frame_array_ent *array;
309 /* TRUE if .eh_frame_hdr should contain the sorted search table.
310 We build it if we successfully read all .eh_frame input sections
311 and recognize them. */
312 bfd_boolean table;
315 /* ELF linker hash table. */
317 struct elf_link_hash_table
319 struct bfd_link_hash_table root;
321 /* Whether we have created the special dynamic sections required
322 when linking against or generating a shared object. */
323 bfd_boolean dynamic_sections_created;
325 /* The BFD used to hold special sections created by the linker.
326 This will be the first BFD found which requires these sections to
327 be created. */
328 bfd *dynobj;
330 /* The value to use when initialising got.refcount/offset and
331 plt.refcount/offset in an elf_link_hash_entry. Set to zero when
332 the values are refcounts. Set to init_offset in
333 size_dynamic_sections when the values may be offsets. */
334 union gotplt_union init_refcount;
336 /* The value to use for got.refcount/offset and plt.refcount/offset
337 when the values may be offsets. Normally (bfd_vma) -1. */
338 union gotplt_union init_offset;
340 /* The number of symbols found in the link which must be put into
341 the .dynsym section. */
342 bfd_size_type dynsymcount;
344 /* The string table of dynamic symbols, which becomes the .dynstr
345 section. */
346 struct elf_strtab_hash *dynstr;
348 /* The number of buckets in the hash table in the .hash section.
349 This is based on the number of dynamic symbols. */
350 bfd_size_type bucketcount;
352 /* A linked list of DT_NEEDED names found in dynamic objects
353 included in the link. */
354 struct bfd_link_needed_list *needed;
356 /* The _GLOBAL_OFFSET_TABLE_ symbol. */
357 struct elf_link_hash_entry *hgot;
359 /* A pointer to information used to link stabs in sections. */
360 void *stab_info;
362 /* A pointer to information used to merge SEC_MERGE sections. */
363 void *merge_info;
365 /* Used by eh_frame code when editing .eh_frame. */
366 struct eh_frame_hdr_info eh_info;
368 /* A linked list of local symbols to be added to .dynsym. */
369 struct elf_link_local_dynamic_entry *dynlocal;
371 /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic
372 objects included in the link. */
373 struct bfd_link_needed_list *runpath;
375 /* Cached first output tls section and size of PT_TLS segment. */
376 asection *tls_sec;
377 bfd_size_type tls_size;
379 /* A linked list of BFD's loaded in the link. */
380 struct elf_link_loaded_list *loaded;
383 /* Look up an entry in an ELF linker hash table. */
385 #define elf_link_hash_lookup(table, string, create, copy, follow) \
386 ((struct elf_link_hash_entry *) \
387 bfd_link_hash_lookup (&(table)->root, (string), (create), \
388 (copy), (follow)))
390 /* Traverse an ELF linker hash table. */
392 #define elf_link_hash_traverse(table, func, info) \
393 (bfd_link_hash_traverse \
394 (&(table)->root, \
395 (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func), \
396 (info)))
398 /* Get the ELF linker hash table from a link_info structure. */
400 #define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))
402 /* Returns TRUE if the hash table is a struct elf_link_hash_table. */
403 #define is_elf_hash_table(htab) \
404 (((struct bfd_link_hash_table *) (htab))->type == bfd_link_elf_hash_table)
406 /* Used by bfd_section_from_r_symndx to cache a small number of local
407 symbol to section mappings. */
408 #define LOCAL_SYM_CACHE_SIZE 32
409 struct sym_sec_cache
411 bfd *abfd;
412 unsigned long indx[LOCAL_SYM_CACHE_SIZE];
413 asection *sec[LOCAL_SYM_CACHE_SIZE];
416 /* Constant information held for an ELF backend. */
418 struct elf_size_info {
419 unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr;
420 unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note;
422 /* The size of entries in the .hash section. */
423 unsigned char sizeof_hash_entry;
425 /* The number of internal relocations to allocate per external
426 relocation entry. */
427 unsigned char int_rels_per_ext_rel;
428 /* We use some fixed size arrays. This should be large enough to
429 handle all back-ends. */
430 #define MAX_INT_RELS_PER_EXT_REL 3
432 unsigned char arch_size, log_file_align;
433 unsigned char elfclass, ev_current;
434 int (*write_out_phdrs)
435 (bfd *, const Elf_Internal_Phdr *, unsigned int);
436 bfd_boolean
437 (*write_shdrs_and_ehdr) (bfd *);
438 void (*write_relocs)
439 (bfd *, asection *, void *);
440 void (*swap_symbol_in)
441 (bfd *, const void *, const void *, Elf_Internal_Sym *);
442 void (*swap_symbol_out)
443 (bfd *, const Elf_Internal_Sym *, void *, void *);
444 bfd_boolean (*slurp_reloc_table)
445 (bfd *, asection *, asymbol **, bfd_boolean);
446 long (*slurp_symbol_table)
447 (bfd *, asymbol **, bfd_boolean);
448 void (*swap_dyn_in)
449 (bfd *, const void *, Elf_Internal_Dyn *);
450 void (*swap_dyn_out)
451 (bfd *, const Elf_Internal_Dyn *, void *);
453 /* This function is called to swap in a REL relocation. If an
454 external relocation corresponds to more than one internal
455 relocation, then all relocations are swapped in at once. */
456 void (*swap_reloc_in)
457 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
459 /* This function is called to swap out a REL relocation. */
460 void (*swap_reloc_out)
461 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
463 /* This function is called to swap in a RELA relocation. If an
464 external relocation corresponds to more than one internal
465 relocation, then all relocations are swapped in at once. */
466 void (*swap_reloca_in)
467 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
469 /* This function is called to swap out a RELA relocation. */
470 void (*swap_reloca_out)
471 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
474 #define elf_symbol_from(ABFD,S) \
475 (((S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \
476 && (S)->the_bfd->tdata.elf_obj_data != 0) \
477 ? (elf_symbol_type *) (S) \
478 : 0)
480 enum elf_reloc_type_class {
481 reloc_class_normal,
482 reloc_class_relative,
483 reloc_class_plt,
484 reloc_class_copy
487 struct elf_reloc_cookie
489 Elf_Internal_Rela *rels, *rel, *relend;
490 Elf_Internal_Sym *locsyms;
491 bfd *abfd;
492 size_t locsymcount;
493 size_t extsymoff;
494 struct elf_link_hash_entry **sym_hashes;
495 bfd_boolean bad_symtab;
498 /* The level of IRIX compatibility we're striving for. */
500 typedef enum {
501 ict_none,
502 ict_irix5,
503 ict_irix6
504 } irix_compat_t;
506 /* Mapping of ELF section names and types. */
507 struct bfd_elf_special_section
509 const char *prefix;
510 int prefix_length;
511 /* 0 means name must match PREFIX exactly.
512 -1 means name must start with PREFIX followed by an arbitrary string.
513 -2 means name must match PREFIX exactly or consist of PREFIX followed
514 by a dot then anything.
515 > 0 means name must start with the first PREFIX_LENGTH chars of
516 PREFIX and finish with the last SUFFIX_LENGTH chars of PREFIX. */
517 int suffix_length;
518 int type;
519 int attr;
522 struct elf_backend_data
524 /* The architecture for this backend. */
525 enum bfd_architecture arch;
527 /* The ELF machine code (EM_xxxx) for this backend. */
528 int elf_machine_code;
530 /* The maximum page size for this backend. */
531 bfd_vma maxpagesize;
533 /* A function to translate an ELF RELA relocation to a BFD arelent
534 structure. */
535 void (*elf_info_to_howto)
536 (bfd *, arelent *, Elf_Internal_Rela *);
538 /* A function to translate an ELF REL relocation to a BFD arelent
539 structure. */
540 void (*elf_info_to_howto_rel)
541 (bfd *, arelent *, Elf_Internal_Rela *);
543 /* A function to determine whether a symbol is global when
544 partitioning the symbol table into local and global symbols.
545 This should be NULL for most targets, in which case the correct
546 thing will be done. MIPS ELF, at least on the Irix 5, has
547 special requirements. */
548 bfd_boolean (*elf_backend_sym_is_global)
549 (bfd *, asymbol *);
551 /* The remaining functions are hooks which are called only if they
552 are not NULL. */
554 /* A function to permit a backend specific check on whether a
555 particular BFD format is relevant for an object file, and to
556 permit the backend to set any global information it wishes. When
557 this is called elf_elfheader is set, but anything else should be
558 used with caution. If this returns FALSE, the check_format
559 routine will return a bfd_error_wrong_format error. */
560 bfd_boolean (*elf_backend_object_p)
561 (bfd *);
563 /* A function to do additional symbol processing when reading the
564 ELF symbol table. This is where any processor-specific special
565 section indices are handled. */
566 void (*elf_backend_symbol_processing)
567 (bfd *, asymbol *);
569 /* A function to do additional symbol processing after reading the
570 entire ELF symbol table. */
571 bfd_boolean (*elf_backend_symbol_table_processing)
572 (bfd *, elf_symbol_type *, unsigned int);
574 /* A function to set the type of the info field. Processor-specific
575 types should be handled here. */
576 int (*elf_backend_get_symbol_type)
577 (Elf_Internal_Sym *, int);
579 /* A function to do additional processing on the ELF section header
580 just before writing it out. This is used to set the flags and
581 type fields for some sections, or to actually write out data for
582 unusual sections. */
583 bfd_boolean (*elf_backend_section_processing)
584 (bfd *, Elf_Internal_Shdr *);
586 /* A function to handle unusual section types when creating BFD
587 sections from ELF sections. */
588 bfd_boolean (*elf_backend_section_from_shdr)
589 (bfd *, Elf_Internal_Shdr *, const char *);
591 /* A function to convert machine dependent section header flags to
592 BFD internal section header flags. */
593 bfd_boolean (*elf_backend_section_flags)
594 (flagword *, Elf_Internal_Shdr *);
596 /* A function to handle unusual program segment types when creating BFD
597 sections from ELF program segments. */
598 bfd_boolean (*elf_backend_section_from_phdr)
599 (bfd *, Elf_Internal_Phdr *, int);
601 /* A function to set up the ELF section header for a BFD section in
602 preparation for writing it out. This is where the flags and type
603 fields are set for unusual sections. */
604 bfd_boolean (*elf_backend_fake_sections)
605 (bfd *, Elf_Internal_Shdr *, asection *);
607 /* A function to get the ELF section index for a BFD section. If
608 this returns TRUE, the section was found. If it is a normal ELF
609 section, *RETVAL should be left unchanged. If it is not a normal
610 ELF section *RETVAL should be set to the SHN_xxxx index. */
611 bfd_boolean (*elf_backend_section_from_bfd_section)
612 (bfd *, asection *, int *retval);
614 /* If this field is not NULL, it is called by the add_symbols phase
615 of a link just before adding a symbol to the global linker hash
616 table. It may modify any of the fields as it wishes. If *NAME
617 is set to NULL, the symbol will be skipped rather than being
618 added to the hash table. This function is responsible for
619 handling all processor dependent symbol bindings and section
620 indices, and must set at least *FLAGS and *SEC for each processor
621 dependent case; failure to do so will cause a link error. */
622 bfd_boolean (*elf_add_symbol_hook)
623 (bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *,
624 const char **name, flagword *flags, asection **sec, bfd_vma *value);
626 /* If this field is not NULL, it is called by the elf_link_output_sym
627 phase of a link for each symbol which will appear in the object file. */
628 bfd_boolean (*elf_backend_link_output_symbol_hook)
629 (struct bfd_link_info *info, const char *, Elf_Internal_Sym *,
630 asection *, struct elf_link_hash_entry *);
632 /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend
633 linker the first time it encounters a dynamic object in the link.
634 This function must create any sections required for dynamic
635 linking. The ABFD argument is a dynamic object. The .interp,
636 .dynamic, .dynsym, .dynstr, and .hash functions have already been
637 created, and this function may modify the section flags if
638 desired. This function will normally create the .got and .plt
639 sections, but different backends have different requirements. */
640 bfd_boolean (*elf_backend_create_dynamic_sections)
641 (bfd *abfd, struct bfd_link_info *info);
643 /* The CHECK_RELOCS function is called by the add_symbols phase of
644 the ELF backend linker. It is called once for each section with
645 relocs of an object file, just after the symbols for the object
646 file have been added to the global linker hash table. The
647 function must look through the relocs and do any special handling
648 required. This generally means allocating space in the global
649 offset table, and perhaps allocating space for a reloc. The
650 relocs are always passed as Rela structures; if the section
651 actually uses Rel structures, the r_addend field will always be
652 zero. */
653 bfd_boolean (*check_relocs)
654 (bfd *abfd, struct bfd_link_info *info, asection *o,
655 const Elf_Internal_Rela *relocs);
657 /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend
658 linker for every symbol which is defined by a dynamic object and
659 referenced by a regular object. This is called after all the
660 input files have been seen, but before the SIZE_DYNAMIC_SECTIONS
661 function has been called. The hash table entry should be
662 bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be
663 defined in a section from a dynamic object. Dynamic object
664 sections are not included in the final link, and this function is
665 responsible for changing the value to something which the rest of
666 the link can deal with. This will normally involve adding an
667 entry to the .plt or .got or some such section, and setting the
668 symbol to point to that. */
669 bfd_boolean (*elf_backend_adjust_dynamic_symbol)
670 (struct bfd_link_info *info, struct elf_link_hash_entry *h);
672 /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker
673 after all the linker input files have been seen but before the
674 section sizes have been set. This is called after
675 ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS. */
676 bfd_boolean (*elf_backend_always_size_sections)
677 (bfd *output_bfd, struct bfd_link_info *info);
679 /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend
680 linker after all the linker input files have been seen but before
681 the sections sizes have been set. This is called after
682 ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols.
683 It is only called when linking against a dynamic object. It must
684 set the sizes of the dynamic sections, and may fill in their
685 contents as well. The generic ELF linker can handle the .dynsym,
686 .dynstr and .hash sections. This function must handle the
687 .interp section and any sections created by the
688 CREATE_DYNAMIC_SECTIONS entry point. */
689 bfd_boolean (*elf_backend_size_dynamic_sections)
690 (bfd *output_bfd, struct bfd_link_info *info);
692 /* The RELOCATE_SECTION function is called by the ELF backend linker
693 to handle the relocations for a section.
695 The relocs are always passed as Rela structures; if the section
696 actually uses Rel structures, the r_addend field will always be
697 zero.
699 This function is responsible for adjust the section contents as
700 necessary, and (if using Rela relocs and generating a
701 relocatable output file) adjusting the reloc addend as
702 necessary.
704 This function does not have to worry about setting the reloc
705 address or the reloc symbol index.
707 LOCAL_SYMS is a pointer to the swapped in local symbols.
709 LOCAL_SECTIONS is an array giving the section in the input file
710 corresponding to the st_shndx field of each local symbol.
712 The global hash table entry for the global symbols can be found
713 via elf_sym_hashes (input_bfd).
715 When generating relocatable output, this function must handle
716 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
717 going to be the section symbol corresponding to the output
718 section, which means that the addend must be adjusted
719 accordingly. */
720 bfd_boolean (*elf_backend_relocate_section)
721 (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
722 asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs,
723 Elf_Internal_Sym *local_syms, asection **local_sections);
725 /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend
726 linker just before it writes a symbol out to the .dynsym section.
727 The processor backend may make any required adjustment to the
728 symbol. It may also take the opportunity to set contents of the
729 dynamic sections. Note that FINISH_DYNAMIC_SYMBOL is called on
730 all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called
731 on those symbols which are defined by a dynamic object. */
732 bfd_boolean (*elf_backend_finish_dynamic_symbol)
733 (bfd *output_bfd, struct bfd_link_info *info,
734 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym);
736 /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend
737 linker just before it writes all the dynamic sections out to the
738 output file. The FINISH_DYNAMIC_SYMBOL will have been called on
739 all dynamic symbols. */
740 bfd_boolean (*elf_backend_finish_dynamic_sections)
741 (bfd *output_bfd, struct bfd_link_info *info);
743 /* A function to do any beginning processing needed for the ELF file
744 before building the ELF headers and computing file positions. */
745 void (*elf_backend_begin_write_processing)
746 (bfd *, struct bfd_link_info *);
748 /* A function to do any final processing needed for the ELF file
749 before writing it out. The LINKER argument is TRUE if this BFD
750 was created by the ELF backend linker. */
751 void (*elf_backend_final_write_processing)
752 (bfd *, bfd_boolean linker);
754 /* This function is called by get_program_header_size. It should
755 return the number of additional program segments which this BFD
756 will need. It should return -1 on error. */
757 int (*elf_backend_additional_program_headers)
758 (bfd *);
760 /* This function is called to modify an existing segment map in a
761 backend specific fashion. */
762 bfd_boolean (*elf_backend_modify_segment_map)
763 (bfd *, struct bfd_link_info *);
765 /* This function is called during section gc to discover the section a
766 particular relocation refers to. */
767 asection * (*gc_mark_hook)
768 (asection *sec, struct bfd_link_info *, Elf_Internal_Rela *,
769 struct elf_link_hash_entry *h, Elf_Internal_Sym *);
771 /* This function, if defined, is called during the sweep phase of gc
772 in order that a backend might update any data structures it might
773 be maintaining. */
774 bfd_boolean (*gc_sweep_hook)
775 (bfd *abfd, struct bfd_link_info *info, asection *o,
776 const Elf_Internal_Rela *relocs);
778 /* This function, if defined, is called after the ELF headers have
779 been created. This allows for things like the OS and ABI versions
780 to be changed. */
781 void (*elf_backend_post_process_headers)
782 (bfd *, struct bfd_link_info *);
784 /* This function, if defined, prints a symbol to file and returns the
785 name of the symbol to be printed. It should return NULL to fall
786 back to default symbol printing. */
787 const char *(*elf_backend_print_symbol_all)
788 (bfd *, void *, asymbol *);
790 /* This function, if defined, is called after all local symbols and
791 global symbols converted to locals are emitted into the symtab
792 section. It allows the backend to emit special global symbols
793 not handled in the hash table. */
794 bfd_boolean (*elf_backend_output_arch_syms)
795 (bfd *, struct bfd_link_info *, void *,
796 bfd_boolean (*) (void *, const char *, Elf_Internal_Sym *, asection *,
797 struct elf_link_hash_entry *));
799 /* Copy any information related to dynamic linking from a pre-existing
800 symbol to a newly created symbol. Also called to copy flags and
801 other back-end info to a weakdef, in which case the symbol is not
802 newly created and plt/got refcounts and dynamic indices should not
803 be copied. */
804 void (*elf_backend_copy_indirect_symbol)
805 (const struct elf_backend_data *, struct elf_link_hash_entry *,
806 struct elf_link_hash_entry *);
808 /* Modify any information related to dynamic linking such that the
809 symbol is not exported. */
810 void (*elf_backend_hide_symbol)
811 (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
813 /* Merge the backend specific symbol attribute. */
814 void (*elf_backend_merge_symbol_attribute)
815 (struct elf_link_hash_entry *, const Elf_Internal_Sym *, bfd_boolean,
816 bfd_boolean);
818 /* Emit relocations. Overrides default routine for emitting relocs,
819 except during a relocatable link, or if all relocs are being emitted. */
820 bfd_boolean (*elf_backend_emit_relocs)
821 (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
823 /* Count relocations. Not called for relocatable links
824 or if all relocs are being preserved in the output. */
825 unsigned int (*elf_backend_count_relocs)
826 (asection *, Elf_Internal_Rela *);
828 /* This function, if defined, is called when an NT_PRSTATUS note is found
829 in a core file. */
830 bfd_boolean (*elf_backend_grok_prstatus)
831 (bfd *, Elf_Internal_Note *);
833 /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO
834 note is found in a core file. */
835 bfd_boolean (*elf_backend_grok_psinfo)
836 (bfd *, Elf_Internal_Note *);
838 /* Functions to print VMAs. Special code to handle 64 bit ELF files. */
839 void (* elf_backend_sprintf_vma)
840 (bfd *, char *, bfd_vma);
841 void (* elf_backend_fprintf_vma)
842 (bfd *, void *, bfd_vma);
844 /* This function returns class of a reloc type. */
845 enum elf_reloc_type_class (*elf_backend_reloc_type_class)
846 (const Elf_Internal_Rela *);
848 /* This function, if defined, removes information about discarded functions
849 from other sections which mention them. */
850 bfd_boolean (*elf_backend_discard_info)
851 (bfd *, struct elf_reloc_cookie *, struct bfd_link_info *);
853 /* This function, if defined, signals that the function above has removed
854 the discarded relocations for this section. */
855 bfd_boolean (*elf_backend_ignore_discarded_relocs)
856 (asection *);
858 /* This function, if defined, may write out the given section.
859 Returns TRUE if it did so and FALSE if the caller should. */
860 bfd_boolean (*elf_backend_write_section)
861 (bfd *, asection *, bfd_byte *);
863 /* The level of IRIX compatibility we're striving for.
864 MIPS ELF specific function. */
865 irix_compat_t (*elf_backend_mips_irix_compat)
866 (bfd *);
868 reloc_howto_type *(*elf_backend_mips_rtype_to_howto)
869 (unsigned int, bfd_boolean);
871 /* The swapping table to use when dealing with ECOFF information.
872 Used for the MIPS ELF .mdebug section. */
873 const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap;
875 /* This function implements `bfd_elf_bfd_from_remote_memory';
876 see elf.c, elfcode.h. */
877 bfd *(*elf_backend_bfd_from_remote_memory)
878 (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
879 int (*target_read_memory) (bfd_vma vma, char *myaddr, int len));
881 /* Alternate EM_xxxx machine codes for this backend. */
882 int elf_machine_alt1;
883 int elf_machine_alt2;
885 const struct elf_size_info *s;
887 /* An array of target specific special section map. */
888 const struct bfd_elf_special_section *special_sections;
890 /* offset of the _GLOBAL_OFFSET_TABLE_ symbol from the start of the
891 .got section */
892 bfd_vma got_symbol_offset;
894 /* The size in bytes of the header for the GOT. This includes the
895 so-called reserved entries on some systems. */
896 bfd_vma got_header_size;
898 /* This is TRUE if the linker should act like collect and gather
899 global constructors and destructors by name. This is TRUE for
900 MIPS ELF because the Irix 5 tools can not handle the .init
901 section. */
902 unsigned collect : 1;
904 /* This is TRUE if the linker should ignore changes to the type of a
905 symbol. This is TRUE for MIPS ELF because some Irix 5 objects
906 record undefined functions as STT_OBJECT although the definitions
907 are STT_FUNC. */
908 unsigned type_change_ok : 1;
910 /* Whether the backend may use REL relocations. (Some backends use
911 both REL and RELA relocations, and this flag is set for those
912 backends.) */
913 unsigned may_use_rel_p : 1;
915 /* Whether the backend may use RELA relocations. (Some backends use
916 both REL and RELA relocations, and this flag is set for those
917 backends.) */
918 unsigned may_use_rela_p : 1;
920 /* Whether the default relocation type is RELA. If a backend with
921 this flag set wants REL relocations for a particular section,
922 it must note that explicitly. Similarly, if this flag is clear,
923 and the backend wants RELA relocations for a particular
924 section. */
925 unsigned default_use_rela_p : 1;
927 /* Set if RELA relocations for a relocatable link can be handled by
928 generic code. Backends that set this flag need do nothing in the
929 backend relocate_section routine for relocatable linking. */
930 unsigned rela_normal : 1;
932 /* TRUE if addresses "naturally" sign extend. This is used when
933 swapping in from Elf32 when BFD64. */
934 unsigned sign_extend_vma : 1;
936 unsigned want_got_plt : 1;
937 unsigned plt_readonly : 1;
938 unsigned want_plt_sym : 1;
939 unsigned plt_not_loaded : 1;
940 unsigned plt_alignment : 4;
941 unsigned can_gc_sections : 1;
942 unsigned can_refcount : 1;
943 unsigned want_got_sym : 1;
944 unsigned want_dynbss : 1;
945 /* Targets which do not support physical addressing often require
946 that the p_paddr field in the section header to be set to zero.
947 This field indicates whether this behavior is required. */
948 unsigned want_p_paddr_set_to_zero : 1;
951 /* Information stored for each BFD section in an ELF file. This
952 structure is allocated by elf_new_section_hook. */
954 struct bfd_elf_section_data
956 /* The ELF header for this section. */
957 Elf_Internal_Shdr this_hdr;
959 /* The ELF header for the reloc section associated with this
960 section, if any. */
961 Elf_Internal_Shdr rel_hdr;
963 /* If there is a second reloc section associated with this section,
964 as can happen on Irix 6, this field points to the header. */
965 Elf_Internal_Shdr *rel_hdr2;
967 /* The number of relocations currently assigned to REL_HDR. */
968 unsigned int rel_count;
970 /* The number of relocations currently assigned to REL_HDR2. */
971 unsigned int rel_count2;
973 /* The ELF section number of this section. Only used for an output
974 file. */
975 int this_idx;
977 /* The ELF section number of the reloc section indicated by
978 REL_HDR if any. Only used for an output file. */
979 int rel_idx;
981 /* The ELF section number of the reloc section indicated by
982 REL_HDR2 if any. Only used for an output file. */
983 int rel_idx2;
985 /* Used by the backend linker when generating a shared library to
986 record the dynamic symbol index for a section symbol
987 corresponding to this section. A value of 0 means that there is
988 no dynamic symbol for this section. */
989 int dynindx;
991 /* Used by the backend linker to store the symbol hash table entries
992 associated with relocs against global symbols. */
993 struct elf_link_hash_entry **rel_hashes;
995 /* A pointer to the swapped relocs. If the section uses REL relocs,
996 rather than RELA, all the r_addend fields will be zero. This
997 pointer may be NULL. It is used by the backend linker. */
998 Elf_Internal_Rela *relocs;
1000 /* A pointer to a linked list tracking dynamic relocs copied for
1001 local symbols. */
1002 void *local_dynrel;
1004 /* A pointer to the bfd section used for dynamic relocs. */
1005 asection *sreloc;
1007 union {
1008 /* Group name, if this section is a member of a group. */
1009 const char *name;
1011 /* Group signature sym, if this is the SHT_GROUP section. */
1012 struct bfd_symbol *id;
1013 } group;
1015 /* A linked list of sections in the group. Circular when used by
1016 the linker. */
1017 asection *next_in_group;
1019 /* A pointer used for various section optimizations. */
1020 void *sec_info;
1023 #define elf_section_data(sec) ((struct bfd_elf_section_data*)sec->used_by_bfd)
1024 #define elf_section_type(sec) (elf_section_data(sec)->this_hdr.sh_type)
1025 #define elf_section_flags(sec) (elf_section_data(sec)->this_hdr.sh_flags)
1026 #define elf_group_name(sec) (elf_section_data(sec)->group.name)
1027 #define elf_group_id(sec) (elf_section_data(sec)->group.id)
1028 #define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group)
1030 /* Return TRUE if section has been discarded. */
1031 #define elf_discarded_section(sec) \
1032 (!bfd_is_abs_section (sec) \
1033 && bfd_is_abs_section ((sec)->output_section) \
1034 && sec->sec_info_type != ELF_INFO_TYPE_MERGE \
1035 && sec->sec_info_type != ELF_INFO_TYPE_JUST_SYMS)
1037 #define get_elf_backend_data(abfd) \
1038 ((const struct elf_backend_data *) (abfd)->xvec->backend_data)
1040 /* This struct is used to pass information to routines called via
1041 elf_link_hash_traverse which must return failure. */
1043 struct elf_info_failed
1045 bfd_boolean failed;
1046 struct bfd_link_info *info;
1047 struct bfd_elf_version_tree *verdefs;
1050 /* This structure is used to pass information to
1051 _bfd_elf_link_assign_sym_version. */
1053 struct elf_assign_sym_version_info
1055 /* Output BFD. */
1056 bfd *output_bfd;
1057 /* General link information. */
1058 struct bfd_link_info *info;
1059 /* Version tree. */
1060 struct bfd_elf_version_tree *verdefs;
1061 /* Whether we had a failure. */
1062 bfd_boolean failed;
1065 /* This structure is used to pass information to
1066 _bfd_elf_link_find_version_dependencies. */
1068 struct elf_find_verdep_info
1070 /* Output BFD. */
1071 bfd *output_bfd;
1072 /* General link information. */
1073 struct bfd_link_info *info;
1074 /* The number of dependencies. */
1075 unsigned int vers;
1076 /* Whether we had a failure. */
1077 bfd_boolean failed;
1080 /* Some private data is stashed away for future use using the tdata pointer
1081 in the bfd structure. */
1083 struct elf_obj_tdata
1085 Elf_Internal_Ehdr elf_header[1]; /* Actual data, but ref like ptr */
1086 Elf_Internal_Shdr **elf_sect_ptr;
1087 Elf_Internal_Phdr *phdr;
1088 struct elf_segment_map *segment_map;
1089 struct elf_strtab_hash *strtab_ptr;
1090 int num_locals;
1091 int num_globals;
1092 unsigned int num_elf_sections; /* elf_sect_ptr size */
1093 int num_section_syms;
1094 asymbol **section_syms; /* STT_SECTION symbols for each section */
1095 Elf_Internal_Shdr symtab_hdr;
1096 Elf_Internal_Shdr shstrtab_hdr;
1097 Elf_Internal_Shdr strtab_hdr;
1098 Elf_Internal_Shdr dynsymtab_hdr;
1099 Elf_Internal_Shdr dynstrtab_hdr;
1100 Elf_Internal_Shdr dynversym_hdr;
1101 Elf_Internal_Shdr dynverref_hdr;
1102 Elf_Internal_Shdr dynverdef_hdr;
1103 Elf_Internal_Shdr symtab_shndx_hdr;
1104 unsigned int symtab_section, shstrtab_section;
1105 unsigned int strtab_section, dynsymtab_section;
1106 unsigned int symtab_shndx_section;
1107 unsigned int dynversym_section, dynverdef_section, dynverref_section;
1108 file_ptr next_file_pos;
1109 bfd_vma gp; /* The gp value */
1110 unsigned int gp_size; /* The gp size */
1112 Elf_Internal_Shdr **group_sect_ptr;
1113 int num_group;
1115 /* Information grabbed from an elf core file. */
1116 int core_signal;
1117 int core_pid;
1118 int core_lwpid;
1119 char* core_program;
1120 char* core_command;
1122 /* This is set to TRUE if the object was created by the backend
1123 linker. */
1124 bfd_boolean linker;
1126 /* A mapping from external symbols to entries in the linker hash
1127 table, used when linking. This is indexed by the symbol index
1128 minus the sh_info field of the symbol table header. */
1129 struct elf_link_hash_entry **sym_hashes;
1131 /* Track usage and final offsets of GOT entries for local symbols.
1132 This array is indexed by symbol index. Elements are used
1133 identically to "got" in struct elf_link_hash_entry. */
1134 union
1136 bfd_signed_vma *refcounts;
1137 bfd_vma *offsets;
1138 struct got_entry **ents;
1139 } local_got;
1141 /* The linker ELF emulation code needs to let the backend ELF linker
1142 know what filename should be used for a dynamic object if the
1143 dynamic object is found using a search. The emulation code then
1144 sometimes needs to know what name was actually used. Until the
1145 file has been added to the linker symbol table, this field holds
1146 the name the linker wants. After it has been added, it holds the
1147 name actually used, which will be the DT_SONAME entry if there is
1148 one. */
1149 const char *dt_name;
1151 /* When a reference in a regular object is resolved by a shared
1152 object is loaded into via the DT_NEEDED entries by the linker
1153 ELF emulation code, we need to add the shared object to the
1154 DT_NEEDED list of the resulting binary to indicate the dependency
1155 as if the -l option is passed to the linker. This field holds the
1156 name of the loaded shared object. */
1157 const char *dt_soname;
1159 /* Irix 5 often screws up the symbol table, sorting local symbols
1160 after global symbols. This flag is set if the symbol table in
1161 this BFD appears to be screwed up. If it is, we ignore the
1162 sh_info field in the symbol table header, and always read all the
1163 symbols. */
1164 bfd_boolean bad_symtab;
1166 /* Records the result of `get_program_header_size'. */
1167 bfd_size_type program_header_size;
1169 /* Used by find_nearest_line entry point. */
1170 void *line_info;
1172 /* Used by MIPS ELF find_nearest_line entry point. The structure
1173 could be included directly in this one, but there's no point to
1174 wasting the memory just for the infrequently called
1175 find_nearest_line. */
1176 struct mips_elf_find_line *find_line_info;
1178 /* A place to stash dwarf1 info for this bfd. */
1179 struct dwarf1_debug *dwarf1_find_line_info;
1181 /* A place to stash dwarf2 info for this bfd. */
1182 void *dwarf2_find_line_info;
1184 /* An array of stub sections indexed by symbol number, used by the
1185 MIPS ELF linker. FIXME: We should figure out some way to only
1186 include this field for a MIPS ELF target. */
1187 asection **local_stubs;
1189 /* Used to determine if PT_GNU_EH_FRAME segment header should be
1190 created. */
1191 asection *eh_frame_hdr;
1193 /* Used to determine if the e_flags field has been initialized */
1194 bfd_boolean flags_init;
1196 /* Number of symbol version definitions we are about to emit. */
1197 unsigned int cverdefs;
1199 /* Number of symbol version references we are about to emit. */
1200 unsigned int cverrefs;
1202 /* Segment flags for the PT_GNU_STACK segment. */
1203 unsigned int stack_flags;
1205 /* Symbol version definitions in external objects. */
1206 Elf_Internal_Verdef *verdef;
1208 /* Symbol version references to external objects. */
1209 Elf_Internal_Verneed *verref;
1211 /* The Irix 5 support uses two virtual sections, which represent
1212 text/data symbols defined in dynamic objects. */
1213 asymbol *elf_data_symbol;
1214 asymbol *elf_text_symbol;
1215 asection *elf_data_section;
1216 asection *elf_text_section;
1219 #define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data)
1220 #define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header)
1221 #define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr)
1222 #define elf_numsections(bfd) (elf_tdata(bfd) -> num_elf_sections)
1223 #define elf_shstrtab(bfd) (elf_tdata(bfd) -> strtab_ptr)
1224 #define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section)
1225 #define elf_symtab_shndx(bfd) (elf_tdata(bfd) -> symtab_shndx_section)
1226 #define elf_dynsymtab(bfd) (elf_tdata(bfd) -> dynsymtab_section)
1227 #define elf_dynversym(bfd) (elf_tdata(bfd) -> dynversym_section)
1228 #define elf_dynverdef(bfd) (elf_tdata(bfd) -> dynverdef_section)
1229 #define elf_dynverref(bfd) (elf_tdata(bfd) -> dynverref_section)
1230 #define elf_num_locals(bfd) (elf_tdata(bfd) -> num_locals)
1231 #define elf_num_globals(bfd) (elf_tdata(bfd) -> num_globals)
1232 #define elf_section_syms(bfd) (elf_tdata(bfd) -> section_syms)
1233 #define elf_num_section_syms(bfd) (elf_tdata(bfd) -> num_section_syms)
1234 #define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo)
1235 #define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus)
1236 #define elf_gp(bfd) (elf_tdata(bfd) -> gp)
1237 #define elf_gp_size(bfd) (elf_tdata(bfd) -> gp_size)
1238 #define elf_sym_hashes(bfd) (elf_tdata(bfd) -> sym_hashes)
1239 #define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts)
1240 #define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets)
1241 #define elf_local_got_ents(bfd) (elf_tdata(bfd) -> local_got.ents)
1242 #define elf_dt_name(bfd) (elf_tdata(bfd) -> dt_name)
1243 #define elf_dt_soname(bfd) (elf_tdata(bfd) -> dt_soname)
1244 #define elf_bad_symtab(bfd) (elf_tdata(bfd) -> bad_symtab)
1245 #define elf_flags_init(bfd) (elf_tdata(bfd) -> flags_init)
1247 extern void _bfd_elf_swap_verdef_in
1248 (bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *);
1249 extern void _bfd_elf_swap_verdef_out
1250 (bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *);
1251 extern void _bfd_elf_swap_verdaux_in
1252 (bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *);
1253 extern void _bfd_elf_swap_verdaux_out
1254 (bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *);
1255 extern void _bfd_elf_swap_verneed_in
1256 (bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *);
1257 extern void _bfd_elf_swap_verneed_out
1258 (bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *);
1259 extern void _bfd_elf_swap_vernaux_in
1260 (bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *);
1261 extern void _bfd_elf_swap_vernaux_out
1262 (bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *);
1263 extern void _bfd_elf_swap_versym_in
1264 (bfd *, const Elf_External_Versym *, Elf_Internal_Versym *);
1265 extern void _bfd_elf_swap_versym_out
1266 (bfd *, const Elf_Internal_Versym *, Elf_External_Versym *);
1268 extern int _bfd_elf_section_from_bfd_section
1269 (bfd *, asection *);
1270 extern char *bfd_elf_string_from_elf_section
1271 (bfd *, unsigned, unsigned);
1272 extern char *bfd_elf_get_str_section
1273 (bfd *, unsigned);
1274 extern Elf_Internal_Sym *bfd_elf_get_elf_syms
1275 (bfd *, Elf_Internal_Shdr *, size_t, size_t, Elf_Internal_Sym *, void *,
1276 Elf_External_Sym_Shndx *);
1277 extern const char *bfd_elf_local_sym_name
1278 (bfd *, Elf_Internal_Sym *);
1280 extern bfd_boolean _bfd_elf_copy_private_bfd_data
1281 (bfd *, bfd *);
1282 extern bfd_boolean _bfd_elf_print_private_bfd_data
1283 (bfd *, void *);
1284 extern void bfd_elf_print_symbol
1285 (bfd *, void *, asymbol *, bfd_print_symbol_type);
1287 #define elf_string_from_elf_strtab(abfd, strindex) \
1288 bfd_elf_string_from_elf_section (abfd, elf_elfheader(abfd)->e_shstrndx, \
1289 strindex)
1291 #define bfd_elf32_print_symbol bfd_elf_print_symbol
1292 #define bfd_elf64_print_symbol bfd_elf_print_symbol
1294 extern void _bfd_elf_sprintf_vma
1295 (bfd *, char *, bfd_vma);
1296 extern void _bfd_elf_fprintf_vma
1297 (bfd *, void *, bfd_vma);
1299 extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
1300 (const Elf_Internal_Rela *);
1301 extern bfd_vma _bfd_elf_rela_local_sym
1302 (bfd *, Elf_Internal_Sym *, asection **, Elf_Internal_Rela *);
1303 extern bfd_vma _bfd_elf_rel_local_sym
1304 (bfd *, Elf_Internal_Sym *, asection **, bfd_vma);
1305 extern bfd_vma _bfd_elf_section_offset
1306 (bfd *, struct bfd_link_info *, asection *, bfd_vma);
1308 extern unsigned long bfd_elf_hash
1309 (const char *);
1311 extern bfd_reloc_status_type bfd_elf_generic_reloc
1312 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
1313 extern bfd_boolean bfd_elf_mkobject
1314 (bfd *);
1315 extern bfd_boolean bfd_elf_mkcorefile
1316 (bfd *);
1317 extern Elf_Internal_Shdr *bfd_elf_find_section
1318 (bfd *, char *);
1319 extern bfd_boolean _bfd_elf_make_section_from_shdr
1320 (bfd *, Elf_Internal_Shdr *, const char *);
1321 extern bfd_boolean _bfd_elf_make_section_from_phdr
1322 (bfd *, Elf_Internal_Phdr *, int, const char *);
1323 extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc
1324 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
1325 extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create
1326 (bfd *);
1327 extern void _bfd_elf_link_hash_copy_indirect
1328 (const struct elf_backend_data *, struct elf_link_hash_entry *,
1329 struct elf_link_hash_entry *);
1330 extern void _bfd_elf_link_hash_hide_symbol
1331 (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
1332 extern bfd_boolean _bfd_elf_link_hash_table_init
1333 (struct elf_link_hash_table *, bfd *,
1334 struct bfd_hash_entry *(*)
1335 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
1336 extern bfd_boolean _bfd_elf_slurp_version_tables
1337 (bfd *);
1338 extern bfd_boolean _bfd_elf_merge_sections
1339 (bfd *, struct bfd_link_info *);
1340 extern bfd_boolean bfd_elf_discard_group
1341 (bfd *, struct bfd_section *);
1342 extern void bfd_elf_set_group_contents
1343 (bfd *, asection *, void *);
1344 extern void _bfd_elf_link_just_syms
1345 (asection *, struct bfd_link_info *);
1346 extern bfd_boolean _bfd_elf_copy_private_symbol_data
1347 (bfd *, asymbol *, bfd *, asymbol *);
1348 extern bfd_boolean _bfd_elf_copy_private_section_data
1349 (bfd *, asection *, bfd *, asection *);
1350 extern bfd_boolean _bfd_elf_write_object_contents
1351 (bfd *);
1352 extern bfd_boolean _bfd_elf_write_corefile_contents
1353 (bfd *);
1354 extern bfd_boolean _bfd_elf_set_section_contents
1355 (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type);
1356 extern long _bfd_elf_get_symtab_upper_bound
1357 (bfd *);
1358 extern long _bfd_elf_canonicalize_symtab
1359 (bfd *, asymbol **);
1360 extern long _bfd_elf_get_dynamic_symtab_upper_bound
1361 (bfd *);
1362 extern long _bfd_elf_canonicalize_dynamic_symtab
1363 (bfd *, asymbol **);
1364 extern long _bfd_elf_get_reloc_upper_bound
1365 (bfd *, sec_ptr);
1366 extern long _bfd_elf_canonicalize_reloc
1367 (bfd *, sec_ptr, arelent **, asymbol **);
1368 extern long _bfd_elf_get_dynamic_reloc_upper_bound
1369 (bfd *);
1370 extern long _bfd_elf_canonicalize_dynamic_reloc
1371 (bfd *, arelent **, asymbol **);
1372 extern asymbol *_bfd_elf_make_empty_symbol
1373 (bfd *);
1374 extern void _bfd_elf_get_symbol_info
1375 (bfd *, asymbol *, symbol_info *);
1376 extern bfd_boolean _bfd_elf_is_local_label_name
1377 (bfd *, const char *);
1378 extern alent *_bfd_elf_get_lineno
1379 (bfd *, asymbol *);
1380 extern bfd_boolean _bfd_elf_set_arch_mach
1381 (bfd *, enum bfd_architecture, unsigned long);
1382 extern bfd_boolean _bfd_elf_find_nearest_line
1383 (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **,
1384 unsigned int *);
1385 #define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols
1386 #define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1387 extern int _bfd_elf_sizeof_headers
1388 (bfd *, bfd_boolean);
1389 extern bfd_boolean _bfd_elf_new_section_hook
1390 (bfd *, asection *);
1391 extern bfd_boolean _bfd_elf_init_reloc_shdr
1392 (bfd *, Elf_Internal_Shdr *, asection *, bfd_boolean);
1393 extern const struct bfd_elf_special_section *_bfd_elf_get_sec_type_attr
1394 (bfd *, const char *);
1396 /* If the target doesn't have reloc handling written yet: */
1397 extern void _bfd_elf_no_info_to_howto
1398 (bfd *, arelent *, Elf_Internal_Rela *);
1400 extern bfd_boolean bfd_section_from_shdr
1401 (bfd *, unsigned int shindex);
1402 extern bfd_boolean bfd_section_from_phdr
1403 (bfd *, Elf_Internal_Phdr *, int);
1405 extern int _bfd_elf_symbol_from_bfd_symbol
1406 (bfd *, asymbol **);
1408 extern asection *bfd_section_from_r_symndx
1409 (bfd *, struct sym_sec_cache *, asection *, unsigned long);
1410 extern asection *bfd_section_from_elf_index
1411 (bfd *, unsigned int);
1412 extern struct bfd_strtab_hash *_bfd_elf_stringtab_init
1413 (void);
1415 extern struct elf_strtab_hash * _bfd_elf_strtab_init
1416 (void);
1417 extern void _bfd_elf_strtab_free
1418 (struct elf_strtab_hash *);
1419 extern bfd_size_type _bfd_elf_strtab_add
1420 (struct elf_strtab_hash *, const char *, bfd_boolean);
1421 extern void _bfd_elf_strtab_addref
1422 (struct elf_strtab_hash *, bfd_size_type);
1423 extern void _bfd_elf_strtab_delref
1424 (struct elf_strtab_hash *, bfd_size_type);
1425 extern void _bfd_elf_strtab_clear_all_refs
1426 (struct elf_strtab_hash *);
1427 extern bfd_size_type _bfd_elf_strtab_size
1428 (struct elf_strtab_hash *);
1429 extern bfd_size_type _bfd_elf_strtab_offset
1430 (struct elf_strtab_hash *, bfd_size_type);
1431 extern bfd_boolean _bfd_elf_strtab_emit
1432 (bfd *, struct elf_strtab_hash *);
1433 extern void _bfd_elf_strtab_finalize
1434 (struct elf_strtab_hash *);
1436 extern bfd_boolean _bfd_elf_discard_section_eh_frame
1437 (bfd *, struct bfd_link_info *, asection *,
1438 bfd_boolean (*) (bfd_vma, void *), struct elf_reloc_cookie *);
1439 extern bfd_boolean _bfd_elf_discard_section_eh_frame_hdr
1440 (bfd *, struct bfd_link_info *);
1441 extern bfd_vma _bfd_elf_eh_frame_section_offset
1442 (bfd *, asection *, bfd_vma);
1443 extern bfd_boolean _bfd_elf_write_section_eh_frame
1444 (bfd *, struct bfd_link_info *, asection *, bfd_byte *);
1445 extern bfd_boolean _bfd_elf_write_section_eh_frame_hdr
1446 (bfd *, struct bfd_link_info *);
1447 extern bfd_boolean _bfd_elf_maybe_strip_eh_frame_hdr
1448 (struct bfd_link_info *);
1450 extern bfd_boolean _bfd_elf_merge_symbol
1451 (bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *,
1452 asection **, bfd_vma *, struct elf_link_hash_entry **, bfd_boolean *,
1453 bfd_boolean *, bfd_boolean *, bfd_boolean *, bfd_boolean);
1455 extern bfd_boolean _bfd_elf_add_default_symbol
1456 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
1457 const char *, Elf_Internal_Sym *, asection **, bfd_vma *,
1458 bfd_boolean *, bfd_boolean, bfd_boolean);
1460 extern bfd_boolean _bfd_elf_export_symbol
1461 (struct elf_link_hash_entry *, void *);
1463 extern bfd_boolean _bfd_elf_link_find_version_dependencies
1464 (struct elf_link_hash_entry *, void *);
1466 extern bfd_boolean _bfd_elf_link_assign_sym_version
1467 (struct elf_link_hash_entry *, void *);
1469 extern bfd_boolean _bfd_elf_link_record_dynamic_symbol
1470 (struct bfd_link_info *, struct elf_link_hash_entry *);
1471 extern long _bfd_elf_link_lookup_local_dynindx
1472 (struct bfd_link_info *, bfd *, long);
1473 extern bfd_boolean _bfd_elf_compute_section_file_positions
1474 (bfd *, struct bfd_link_info *);
1475 extern void _bfd_elf_assign_file_positions_for_relocs
1476 (bfd *);
1477 extern file_ptr _bfd_elf_assign_file_position_for_section
1478 (Elf_Internal_Shdr *, file_ptr, bfd_boolean);
1480 extern bfd_boolean _bfd_elf_validate_reloc
1481 (bfd *, arelent *);
1483 extern bfd_boolean _bfd_elf_link_create_dynamic_sections
1484 (bfd *, struct bfd_link_info *);
1485 extern bfd_boolean _bfd_elf_create_dynamic_sections
1486 (bfd *, struct bfd_link_info *);
1487 extern bfd_boolean _bfd_elf_create_got_section
1488 (bfd *, struct bfd_link_info *);
1489 extern unsigned long _bfd_elf_link_renumber_dynsyms
1490 (bfd *, struct bfd_link_info *);
1492 extern bfd_boolean _bfd_elfcore_make_pseudosection
1493 (bfd *, char *, size_t, ufile_ptr);
1494 extern char *_bfd_elfcore_strndup
1495 (bfd *, char *, size_t);
1497 extern Elf_Internal_Rela *_bfd_elf_link_read_relocs
1498 (bfd *, asection *, void *, Elf_Internal_Rela *, bfd_boolean);
1500 extern bfd_boolean _bfd_elf_link_size_reloc_section
1501 (bfd *, Elf_Internal_Shdr *, asection *);
1503 extern bfd_boolean _bfd_elf_link_output_relocs
1504 (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
1506 extern bfd_boolean _bfd_elf_fix_symbol_flags
1507 (struct elf_link_hash_entry *, struct elf_info_failed *);
1509 extern bfd_boolean _bfd_elf_adjust_dynamic_symbol
1510 (struct elf_link_hash_entry *, void *);
1512 extern bfd_boolean _bfd_elf_link_sec_merge_syms
1513 (struct elf_link_hash_entry *, void *);
1515 extern bfd_boolean _bfd_elf_dynamic_symbol_p
1516 (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
1518 extern bfd_boolean _bfd_elf_symbol_refs_local_p
1519 (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
1521 extern const bfd_target *bfd_elf32_object_p
1522 (bfd *);
1523 extern const bfd_target *bfd_elf32_core_file_p
1524 (bfd *);
1525 extern char *bfd_elf32_core_file_failing_command
1526 (bfd *);
1527 extern int bfd_elf32_core_file_failing_signal
1528 (bfd *);
1529 extern bfd_boolean bfd_elf32_core_file_matches_executable_p
1530 (bfd *, bfd *);
1532 extern bfd_boolean bfd_elf32_bfd_link_add_symbols
1533 (bfd *, struct bfd_link_info *);
1534 extern bfd_boolean bfd_elf32_bfd_final_link
1535 (bfd *, struct bfd_link_info *);
1537 extern void bfd_elf32_swap_symbol_in
1538 (bfd *, const void *, const void *, Elf_Internal_Sym *);
1539 extern void bfd_elf32_swap_symbol_out
1540 (bfd *, const Elf_Internal_Sym *, void *, void *);
1541 extern void bfd_elf32_swap_reloc_in
1542 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1543 extern void bfd_elf32_swap_reloc_out
1544 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1545 extern void bfd_elf32_swap_reloca_in
1546 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1547 extern void bfd_elf32_swap_reloca_out
1548 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1549 extern void bfd_elf32_swap_phdr_in
1550 (bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *);
1551 extern void bfd_elf32_swap_phdr_out
1552 (bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *);
1553 extern void bfd_elf32_swap_dyn_in
1554 (bfd *, const void *, Elf_Internal_Dyn *);
1555 extern void bfd_elf32_swap_dyn_out
1556 (bfd *, const Elf_Internal_Dyn *, void *);
1557 extern long bfd_elf32_slurp_symbol_table
1558 (bfd *, asymbol **, bfd_boolean);
1559 extern bfd_boolean bfd_elf32_write_shdrs_and_ehdr
1560 (bfd *);
1561 extern int bfd_elf32_write_out_phdrs
1562 (bfd *, const Elf_Internal_Phdr *, unsigned int);
1563 extern void bfd_elf32_write_relocs
1564 (bfd *, asection *, void *);
1565 extern bfd_boolean bfd_elf32_slurp_reloc_table
1566 (bfd *, asection *, asymbol **, bfd_boolean);
1567 extern bfd_boolean bfd_elf32_add_dynamic_entry
1568 (struct bfd_link_info *, bfd_vma, bfd_vma);
1570 extern const bfd_target *bfd_elf64_object_p
1571 (bfd *);
1572 extern const bfd_target *bfd_elf64_core_file_p
1573 (bfd *);
1574 extern char *bfd_elf64_core_file_failing_command
1575 (bfd *);
1576 extern int bfd_elf64_core_file_failing_signal
1577 (bfd *);
1578 extern bfd_boolean bfd_elf64_core_file_matches_executable_p
1579 (bfd *, bfd *);
1580 extern bfd_boolean bfd_elf64_bfd_link_add_symbols
1581 (bfd *, struct bfd_link_info *);
1582 extern bfd_boolean bfd_elf64_bfd_final_link
1583 (bfd *, struct bfd_link_info *);
1585 extern void bfd_elf64_swap_symbol_in
1586 (bfd *, const void *, const void *, Elf_Internal_Sym *);
1587 extern void bfd_elf64_swap_symbol_out
1588 (bfd *, const Elf_Internal_Sym *, void *, void *);
1589 extern void bfd_elf64_swap_reloc_in
1590 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1591 extern void bfd_elf64_swap_reloc_out
1592 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1593 extern void bfd_elf64_swap_reloca_in
1594 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1595 extern void bfd_elf64_swap_reloca_out
1596 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1597 extern void bfd_elf64_swap_phdr_in
1598 (bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *);
1599 extern void bfd_elf64_swap_phdr_out
1600 (bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *);
1601 extern void bfd_elf64_swap_dyn_in
1602 (bfd *, const void *, Elf_Internal_Dyn *);
1603 extern void bfd_elf64_swap_dyn_out
1604 (bfd *, const Elf_Internal_Dyn *, void *);
1605 extern long bfd_elf64_slurp_symbol_table
1606 (bfd *, asymbol **, bfd_boolean);
1607 extern bfd_boolean bfd_elf64_write_shdrs_and_ehdr
1608 (bfd *);
1609 extern int bfd_elf64_write_out_phdrs
1610 (bfd *, const Elf_Internal_Phdr *, unsigned int);
1611 extern void bfd_elf64_write_relocs
1612 (bfd *, asection *, void *);
1613 extern bfd_boolean bfd_elf64_slurp_reloc_table
1614 (bfd *, asection *, asymbol **, bfd_boolean);
1615 extern bfd_boolean bfd_elf64_add_dynamic_entry
1616 (struct bfd_link_info *, bfd_vma, bfd_vma);
1618 #define bfd_elf32_link_record_dynamic_symbol \
1619 _bfd_elf_link_record_dynamic_symbol
1620 #define bfd_elf64_link_record_dynamic_symbol \
1621 _bfd_elf_link_record_dynamic_symbol
1623 extern int elf_link_record_local_dynamic_symbol
1624 (struct bfd_link_info *, bfd *, long);
1625 #define _bfd_elf32_link_record_local_dynamic_symbol \
1626 elf_link_record_local_dynamic_symbol
1627 #define _bfd_elf64_link_record_local_dynamic_symbol \
1628 elf_link_record_local_dynamic_symbol
1630 extern bfd_boolean _bfd_elf_close_and_cleanup
1631 (bfd *);
1632 extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn
1633 (bfd *, arelent *, struct bfd_symbol *, void *,
1634 asection *, bfd *, char **);
1636 extern bfd_boolean _bfd_elf32_gc_sections
1637 (bfd *, struct bfd_link_info *);
1638 extern bfd_boolean _bfd_elf32_gc_common_finalize_got_offsets
1639 (bfd *, struct bfd_link_info *);
1640 extern bfd_boolean _bfd_elf32_gc_common_final_link
1641 (bfd *, struct bfd_link_info *);
1642 extern bfd_boolean _bfd_elf32_gc_record_vtinherit
1643 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1644 extern bfd_boolean _bfd_elf32_gc_record_vtentry
1645 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1647 extern bfd_boolean _bfd_elf64_gc_sections
1648 (bfd *, struct bfd_link_info *);
1649 extern bfd_boolean _bfd_elf64_gc_common_finalize_got_offsets
1650 (bfd *, struct bfd_link_info *);
1651 extern bfd_boolean _bfd_elf64_gc_common_final_link
1652 (bfd *, struct bfd_link_info *);
1653 extern bfd_boolean _bfd_elf64_gc_record_vtinherit
1654 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1655 extern bfd_boolean _bfd_elf64_gc_record_vtentry
1656 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1658 extern bfd_boolean _bfd_elf32_reloc_symbol_deleted_p
1659 (bfd_vma, void *);
1660 extern bfd_boolean _bfd_elf64_reloc_symbol_deleted_p
1661 (bfd_vma, void *);
1663 /* Exported interface for writing elf corefile notes. */
1664 extern char *elfcore_write_note
1665 (bfd *, char *, int *, const char *, int, const void *, int);
1666 extern char *elfcore_write_prpsinfo
1667 (bfd *, char *, int *, const char *, const char *);
1668 extern char *elfcore_write_prstatus
1669 (bfd *, char *, int *, long, int, const void *);
1670 extern char * elfcore_write_pstatus
1671 (bfd *, char *, int *, long, int, const void *);
1672 extern char *elfcore_write_prfpreg
1673 (bfd *, char *, int *, const void *, int);
1674 extern char *elfcore_write_prxfpreg
1675 (bfd *, char *, int *, const void *, int);
1676 extern char *elfcore_write_lwpstatus
1677 (bfd *, char *, int *, long, int, const void *);
1679 extern bfd *_bfd_elf32_bfd_from_remote_memory
1680 (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
1681 int (*target_read_memory) (bfd_vma, char *, int));
1682 extern bfd *_bfd_elf64_bfd_from_remote_memory
1683 (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
1684 int (*target_read_memory) (bfd_vma, char *, int));
1686 /* SH ELF specific routine. */
1688 extern bfd_boolean _sh_elf_set_mach_from_flags
1689 (bfd *);
1691 /* This macro is to avoid lots of duplicated code in the body
1692 of xxx_relocate_section() in the various elfxx-xxxx.c files. */
1693 #define RELOC_FOR_GLOBAL_SYMBOL(h, sym_hashes, r_symndx, symtab_hdr, relocation, sec, unresolved_reloc, info, warned) \
1694 do \
1696 /* It seems this can happen with erroneous or unsupported \
1697 input (mixing a.out and elf in an archive, for example.) */ \
1698 if (sym_hashes == NULL) \
1699 return FALSE; \
1701 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; \
1703 while (h->root.type == bfd_link_hash_indirect \
1704 || h->root.type == bfd_link_hash_warning) \
1705 h = (struct elf_link_hash_entry *) h->root.u.i.link; \
1707 warned = FALSE; \
1708 unresolved_reloc = FALSE; \
1709 relocation = 0; \
1710 if (h->root.type == bfd_link_hash_defined \
1711 || h->root.type == bfd_link_hash_defweak) \
1713 sec = h->root.u.def.section; \
1714 if (sec == NULL \
1715 || sec->output_section == NULL) \
1716 /* Set a flag that will be cleared later if we find a \
1717 relocation value for this symbol. output_section \
1718 is typically NULL for symbols satisfied by a shared \
1719 library. */ \
1720 unresolved_reloc = TRUE; \
1721 else \
1722 relocation = (h->root.u.def.value \
1723 + sec->output_section->vma \
1724 + sec->output_offset); \
1726 else if (h->root.type == bfd_link_hash_undefweak) \
1728 else if (!info->executable \
1729 && info->unresolved_syms_in_objects == RM_IGNORE \
1730 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) \
1732 else \
1734 if (! info->callbacks->undefined_symbol \
1735 (info, h->root.root.string, input_bfd, \
1736 input_section, rel->r_offset, \
1737 ((info->shared && info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR) \
1738 || (!info->shared && info->unresolved_syms_in_objects == RM_GENERATE_ERROR) \
1739 || ELF_ST_VISIBILITY (h->other)) \
1740 )) \
1741 return FALSE; \
1742 warned = TRUE; \
1745 while (0)
1747 #endif /* _LIBELF_H_ */