* sh.h (R_SH_SWITCH8, R_SH_GNU_VTINHERIT, R_SH_GNU_VTENTRY,
[binutils.git] / bfd / elf-bfd.h
blob99036949adf5f6973543b708fb6a3b79f6527375
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
205 /* Will references to this symbol always reference the symbol
206 in this object? STV_PROTECTED is excluded from the visibility test
207 here so that function pointer comparisons work properly. Since
208 function symbols not defined in an app are set to their .plt entry,
209 it's necessary for shared libs to also reference the .plt even
210 though the symbol is really local to the shared lib. */
211 #define SYMBOL_REFERENCES_LOCAL(INFO, H) \
212 _bfd_elf_symbol_refs_local_p (H, INFO, 0)
214 /* Will _calls_ to this symbol always call the version in this object? */
215 #define SYMBOL_CALLS_LOCAL(INFO, H) \
216 _bfd_elf_symbol_refs_local_p (H, INFO, 1)
218 /* Records local symbols to be emitted in the dynamic symbol table. */
220 struct elf_link_local_dynamic_entry
222 struct elf_link_local_dynamic_entry *next;
224 /* The input bfd this symbol came from. */
225 bfd *input_bfd;
227 /* The index of the local symbol being copied. */
228 long input_indx;
230 /* The index in the outgoing dynamic symbol table. */
231 long dynindx;
233 /* A copy of the input symbol. */
234 Elf_Internal_Sym isym;
237 struct elf_link_loaded_list
239 struct elf_link_loaded_list *next;
240 bfd *abfd;
243 /* Structures used by the eh_frame optimization code. */
244 struct cie_header
246 unsigned int length;
247 unsigned int id;
250 struct cie
252 struct cie_header hdr;
253 unsigned char version;
254 unsigned char augmentation[20];
255 unsigned int code_align;
256 int data_align;
257 unsigned int ra_column;
258 unsigned int augmentation_size;
259 struct elf_link_hash_entry *personality;
260 unsigned char per_encoding;
261 unsigned char lsda_encoding;
262 unsigned char fde_encoding;
263 unsigned char initial_insn_length;
264 unsigned char make_relative;
265 unsigned char make_lsda_relative;
266 unsigned char initial_instructions[50];
269 struct eh_cie_fde
271 unsigned int offset;
272 unsigned int size;
273 asection *sec;
274 unsigned int new_offset;
275 unsigned char fde_encoding;
276 unsigned char lsda_encoding;
277 unsigned char lsda_offset;
278 unsigned char cie : 1;
279 unsigned char removed : 1;
280 unsigned char make_relative : 1;
281 unsigned char make_lsda_relative : 1;
282 unsigned char per_encoding_relative : 1;
285 struct eh_frame_sec_info
287 unsigned int count;
288 unsigned int alloced;
289 struct eh_cie_fde entry[1];
292 struct eh_frame_array_ent
294 bfd_vma initial_loc;
295 bfd_vma fde;
298 struct eh_frame_hdr_info
300 struct cie last_cie;
301 asection *last_cie_sec;
302 asection *hdr_sec;
303 unsigned int last_cie_offset;
304 unsigned int fde_count, array_count;
305 struct eh_frame_array_ent *array;
306 /* TRUE if .eh_frame_hdr should contain the sorted search table.
307 We build it if we successfully read all .eh_frame input sections
308 and recognize them. */
309 bfd_boolean table;
312 /* Cached start, size and alignment of PT_TLS segment. */
313 struct elf_link_tls_segment
315 bfd_vma start;
316 bfd_size_type size;
317 unsigned int align;
320 /* ELF linker hash table. */
322 struct elf_link_hash_table
324 struct bfd_link_hash_table root;
326 /* Whether we have created the special dynamic sections required
327 when linking against or generating a shared object. */
328 bfd_boolean dynamic_sections_created;
330 /* The BFD used to hold special sections created by the linker.
331 This will be the first BFD found which requires these sections to
332 be created. */
333 bfd *dynobj;
335 /* The value to use when initialising got.refcount/offset and
336 plt.refcount/offset in an elf_link_hash_entry. Set to zero when
337 the values are refcounts. Set to init_offset in
338 size_dynamic_sections when the values may be offsets. */
339 union gotplt_union init_refcount;
341 /* The value to use for got.refcount/offset and plt.refcount/offset
342 when the values may be offsets. Normally (bfd_vma) -1. */
343 union gotplt_union init_offset;
345 /* The number of symbols found in the link which must be put into
346 the .dynsym section. */
347 bfd_size_type dynsymcount;
349 /* The string table of dynamic symbols, which becomes the .dynstr
350 section. */
351 struct elf_strtab_hash *dynstr;
353 /* The number of buckets in the hash table in the .hash section.
354 This is based on the number of dynamic symbols. */
355 bfd_size_type bucketcount;
357 /* A linked list of DT_NEEDED names found in dynamic objects
358 included in the link. */
359 struct bfd_link_needed_list *needed;
361 /* The _GLOBAL_OFFSET_TABLE_ symbol. */
362 struct elf_link_hash_entry *hgot;
364 /* A pointer to information used to link stabs in sections. */
365 void *stab_info;
367 /* A pointer to information used to merge SEC_MERGE sections. */
368 void *merge_info;
370 /* Used by eh_frame code when editing .eh_frame. */
371 struct eh_frame_hdr_info eh_info;
373 /* A linked list of local symbols to be added to .dynsym. */
374 struct elf_link_local_dynamic_entry *dynlocal;
376 /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic
377 objects included in the link. */
378 struct bfd_link_needed_list *runpath;
380 /* Cached start, size and alignment of PT_TLS segment. */
381 struct elf_link_tls_segment *tls_segment;
383 /* A linked list of BFD's loaded in the link. */
384 struct elf_link_loaded_list *loaded;
387 /* Look up an entry in an ELF linker hash table. */
389 #define elf_link_hash_lookup(table, string, create, copy, follow) \
390 ((struct elf_link_hash_entry *) \
391 bfd_link_hash_lookup (&(table)->root, (string), (create), \
392 (copy), (follow)))
394 /* Traverse an ELF linker hash table. */
396 #define elf_link_hash_traverse(table, func, info) \
397 (bfd_link_hash_traverse \
398 (&(table)->root, \
399 (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func), \
400 (info)))
402 /* Get the ELF linker hash table from a link_info structure. */
404 #define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))
406 /* Returns TRUE if the hash table is a struct elf_link_hash_table. */
407 #define is_elf_hash_table(p) \
408 ((p)->hash->type == bfd_link_elf_hash_table)
410 /* Used by bfd_section_from_r_symndx to cache a small number of local
411 symbol to section mappings. */
412 #define LOCAL_SYM_CACHE_SIZE 32
413 struct sym_sec_cache
415 bfd *abfd;
416 unsigned long indx[LOCAL_SYM_CACHE_SIZE];
417 asection *sec[LOCAL_SYM_CACHE_SIZE];
420 /* Constant information held for an ELF backend. */
422 struct elf_size_info {
423 unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr;
424 unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note;
426 /* The size of entries in the .hash section. */
427 unsigned char sizeof_hash_entry;
429 /* The number of internal relocations to allocate per external
430 relocation entry. */
431 unsigned char int_rels_per_ext_rel;
432 /* We use some fixed size arrays. This should be large enough to
433 handle all back-ends. */
434 #define MAX_INT_RELS_PER_EXT_REL 3
436 unsigned char arch_size, log_file_align;
437 unsigned char elfclass, ev_current;
438 int (*write_out_phdrs)
439 (bfd *, const Elf_Internal_Phdr *, unsigned int);
440 bfd_boolean
441 (*write_shdrs_and_ehdr) (bfd *);
442 void (*write_relocs)
443 (bfd *, asection *, void *);
444 void (*swap_symbol_in)
445 (bfd *, const void *, const void *, Elf_Internal_Sym *);
446 void (*swap_symbol_out)
447 (bfd *, const Elf_Internal_Sym *, void *, void *);
448 bfd_boolean (*slurp_reloc_table)
449 (bfd *, asection *, asymbol **, bfd_boolean);
450 long (*slurp_symbol_table)
451 (bfd *, asymbol **, bfd_boolean);
452 void (*swap_dyn_in)
453 (bfd *, const void *, Elf_Internal_Dyn *);
454 void (*swap_dyn_out)
455 (bfd *, const Elf_Internal_Dyn *, void *);
457 /* This function is called to swap in a REL relocation. If an
458 external relocation corresponds to more than one internal
459 relocation, then all relocations are swapped in at once. */
460 void (*swap_reloc_in)
461 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
463 /* This function is called to swap out a REL relocation. */
464 void (*swap_reloc_out)
465 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
467 /* This function is called to swap in a RELA relocation. If an
468 external relocation corresponds to more than one internal
469 relocation, then all relocations are swapped in at once. */
470 void (*swap_reloca_in)
471 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
473 /* This function is called to swap out a RELA relocation. */
474 void (*swap_reloca_out)
475 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
478 #define elf_symbol_from(ABFD,S) \
479 (((S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \
480 && (S)->the_bfd->tdata.elf_obj_data != 0) \
481 ? (elf_symbol_type *) (S) \
482 : 0)
484 enum elf_reloc_type_class {
485 reloc_class_normal,
486 reloc_class_relative,
487 reloc_class_plt,
488 reloc_class_copy
491 struct elf_reloc_cookie
493 Elf_Internal_Rela *rels, *rel, *relend;
494 Elf_Internal_Sym *locsyms;
495 bfd *abfd;
496 size_t locsymcount;
497 size_t extsymoff;
498 struct elf_link_hash_entry **sym_hashes;
499 bfd_boolean bad_symtab;
502 /* The level of IRIX compatibility we're striving for. */
504 typedef enum {
505 ict_none,
506 ict_irix5,
507 ict_irix6
508 } irix_compat_t;
510 /* Mapping of ELF section names and types. */
511 struct bfd_elf_special_section
513 const char *prefix;
514 int prefix_length;
515 /* 0 means name must match PREFIX exactly.
516 -1 means name must start with PREFIX followed by an arbitrary string.
517 -2 means name must match PREFIX exactly or consist of PREFIX followed
518 by a dot then anything.
519 > 0 means name must start with the first PREFIX_LENGTH chars of
520 PREFIX and finish with the last SUFFIX_LENGTH chars of PREFIX. */
521 int suffix_length;
522 int type;
523 int attr;
526 struct elf_backend_data
528 /* The architecture for this backend. */
529 enum bfd_architecture arch;
531 /* The ELF machine code (EM_xxxx) for this backend. */
532 int elf_machine_code;
534 /* The maximum page size for this backend. */
535 bfd_vma maxpagesize;
537 /* A function to translate an ELF RELA relocation to a BFD arelent
538 structure. */
539 void (*elf_info_to_howto)
540 (bfd *, arelent *, Elf_Internal_Rela *);
542 /* A function to translate an ELF REL relocation to a BFD arelent
543 structure. */
544 void (*elf_info_to_howto_rel)
545 (bfd *, arelent *, Elf_Internal_Rela *);
547 /* A function to determine whether a symbol is global when
548 partitioning the symbol table into local and global symbols.
549 This should be NULL for most targets, in which case the correct
550 thing will be done. MIPS ELF, at least on the Irix 5, has
551 special requirements. */
552 bfd_boolean (*elf_backend_sym_is_global)
553 (bfd *, asymbol *);
555 /* The remaining functions are hooks which are called only if they
556 are not NULL. */
558 /* A function to permit a backend specific check on whether a
559 particular BFD format is relevant for an object file, and to
560 permit the backend to set any global information it wishes. When
561 this is called elf_elfheader is set, but anything else should be
562 used with caution. If this returns FALSE, the check_format
563 routine will return a bfd_error_wrong_format error. */
564 bfd_boolean (*elf_backend_object_p)
565 (bfd *);
567 /* A function to do additional symbol processing when reading the
568 ELF symbol table. This is where any processor-specific special
569 section indices are handled. */
570 void (*elf_backend_symbol_processing)
571 (bfd *, asymbol *);
573 /* A function to do additional symbol processing after reading the
574 entire ELF symbol table. */
575 bfd_boolean (*elf_backend_symbol_table_processing)
576 (bfd *, elf_symbol_type *, unsigned int);
578 /* A function to set the type of the info field. Processor-specific
579 types should be handled here. */
580 int (*elf_backend_get_symbol_type)
581 (Elf_Internal_Sym *, int);
583 /* A function to do additional processing on the ELF section header
584 just before writing it out. This is used to set the flags and
585 type fields for some sections, or to actually write out data for
586 unusual sections. */
587 bfd_boolean (*elf_backend_section_processing)
588 (bfd *, Elf_Internal_Shdr *);
590 /* A function to handle unusual section types when creating BFD
591 sections from ELF sections. */
592 bfd_boolean (*elf_backend_section_from_shdr)
593 (bfd *, Elf_Internal_Shdr *, const char *);
595 /* A function to convert machine dependent section header flags to
596 BFD internal section header flags. */
597 bfd_boolean (*elf_backend_section_flags)
598 (flagword *, Elf_Internal_Shdr *);
600 /* A function to handle unusual program segment types when creating BFD
601 sections from ELF program segments. */
602 bfd_boolean (*elf_backend_section_from_phdr)
603 (bfd *, Elf_Internal_Phdr *, int);
605 /* A function to set up the ELF section header for a BFD section in
606 preparation for writing it out. This is where the flags and type
607 fields are set for unusual sections. */
608 bfd_boolean (*elf_backend_fake_sections)
609 (bfd *, Elf_Internal_Shdr *, asection *);
611 /* A function to get the ELF section index for a BFD section. If
612 this returns TRUE, the section was found. If it is a normal ELF
613 section, *RETVAL should be left unchanged. If it is not a normal
614 ELF section *RETVAL should be set to the SHN_xxxx index. */
615 bfd_boolean (*elf_backend_section_from_bfd_section)
616 (bfd *, asection *, int *retval);
618 /* If this field is not NULL, it is called by the add_symbols phase
619 of a link just before adding a symbol to the global linker hash
620 table. It may modify any of the fields as it wishes. If *NAME
621 is set to NULL, the symbol will be skipped rather than being
622 added to the hash table. This function is responsible for
623 handling all processor dependent symbol bindings and section
624 indices, and must set at least *FLAGS and *SEC for each processor
625 dependent case; failure to do so will cause a link error. */
626 bfd_boolean (*elf_add_symbol_hook)
627 (bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *,
628 const char **name, flagword *flags, asection **sec, bfd_vma *value);
630 /* If this field is not NULL, it is called by the elf_link_output_sym
631 phase of a link for each symbol which will appear in the object file. */
632 bfd_boolean (*elf_backend_link_output_symbol_hook)
633 (bfd *, struct bfd_link_info *info, const char *, Elf_Internal_Sym *,
634 asection *);
636 /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend
637 linker the first time it encounters a dynamic object in the link.
638 This function must create any sections required for dynamic
639 linking. The ABFD argument is a dynamic object. The .interp,
640 .dynamic, .dynsym, .dynstr, and .hash functions have already been
641 created, and this function may modify the section flags if
642 desired. This function will normally create the .got and .plt
643 sections, but different backends have different requirements. */
644 bfd_boolean (*elf_backend_create_dynamic_sections)
645 (bfd *abfd, struct bfd_link_info *info);
647 /* The CHECK_RELOCS function is called by the add_symbols phase of
648 the ELF backend linker. It is called once for each section with
649 relocs of an object file, just after the symbols for the object
650 file have been added to the global linker hash table. The
651 function must look through the relocs and do any special handling
652 required. This generally means allocating space in the global
653 offset table, and perhaps allocating space for a reloc. The
654 relocs are always passed as Rela structures; if the section
655 actually uses Rel structures, the r_addend field will always be
656 zero. */
657 bfd_boolean (*check_relocs)
658 (bfd *abfd, struct bfd_link_info *info, asection *o,
659 const Elf_Internal_Rela *relocs);
661 /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend
662 linker for every symbol which is defined by a dynamic object and
663 referenced by a regular object. This is called after all the
664 input files have been seen, but before the SIZE_DYNAMIC_SECTIONS
665 function has been called. The hash table entry should be
666 bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be
667 defined in a section from a dynamic object. Dynamic object
668 sections are not included in the final link, and this function is
669 responsible for changing the value to something which the rest of
670 the link can deal with. This will normally involve adding an
671 entry to the .plt or .got or some such section, and setting the
672 symbol to point to that. */
673 bfd_boolean (*elf_backend_adjust_dynamic_symbol)
674 (struct bfd_link_info *info, struct elf_link_hash_entry *h);
676 /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker
677 after all the linker input files have been seen but before the
678 section sizes have been set. This is called after
679 ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS. */
680 bfd_boolean (*elf_backend_always_size_sections)
681 (bfd *output_bfd, struct bfd_link_info *info);
683 /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend
684 linker after all the linker input files have been seen but before
685 the sections sizes have been set. This is called after
686 ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols.
687 It is only called when linking against a dynamic object. It must
688 set the sizes of the dynamic sections, and may fill in their
689 contents as well. The generic ELF linker can handle the .dynsym,
690 .dynstr and .hash sections. This function must handle the
691 .interp section and any sections created by the
692 CREATE_DYNAMIC_SECTIONS entry point. */
693 bfd_boolean (*elf_backend_size_dynamic_sections)
694 (bfd *output_bfd, struct bfd_link_info *info);
696 /* The RELOCATE_SECTION function is called by the ELF backend linker
697 to handle the relocations for a section.
699 The relocs are always passed as Rela structures; if the section
700 actually uses Rel structures, the r_addend field will always be
701 zero.
703 This function is responsible for adjust the section contents as
704 necessary, and (if using Rela relocs and generating a
705 relocatable output file) adjusting the reloc addend as
706 necessary.
708 This function does not have to worry about setting the reloc
709 address or the reloc symbol index.
711 LOCAL_SYMS is a pointer to the swapped in local symbols.
713 LOCAL_SECTIONS is an array giving the section in the input file
714 corresponding to the st_shndx field of each local symbol.
716 The global hash table entry for the global symbols can be found
717 via elf_sym_hashes (input_bfd).
719 When generating relocatable output, this function must handle
720 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
721 going to be the section symbol corresponding to the output
722 section, which means that the addend must be adjusted
723 accordingly. */
724 bfd_boolean (*elf_backend_relocate_section)
725 (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
726 asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs,
727 Elf_Internal_Sym *local_syms, asection **local_sections);
729 /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend
730 linker just before it writes a symbol out to the .dynsym section.
731 The processor backend may make any required adjustment to the
732 symbol. It may also take the opportunity to set contents of the
733 dynamic sections. Note that FINISH_DYNAMIC_SYMBOL is called on
734 all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called
735 on those symbols which are defined by a dynamic object. */
736 bfd_boolean (*elf_backend_finish_dynamic_symbol)
737 (bfd *output_bfd, struct bfd_link_info *info,
738 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym);
740 /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend
741 linker just before it writes all the dynamic sections out to the
742 output file. The FINISH_DYNAMIC_SYMBOL will have been called on
743 all dynamic symbols. */
744 bfd_boolean (*elf_backend_finish_dynamic_sections)
745 (bfd *output_bfd, struct bfd_link_info *info);
747 /* A function to do any beginning processing needed for the ELF file
748 before building the ELF headers and computing file positions. */
749 void (*elf_backend_begin_write_processing)
750 (bfd *, struct bfd_link_info *);
752 /* A function to do any final processing needed for the ELF file
753 before writing it out. The LINKER argument is TRUE if this BFD
754 was created by the ELF backend linker. */
755 void (*elf_backend_final_write_processing)
756 (bfd *, bfd_boolean linker);
758 /* This function is called by get_program_header_size. It should
759 return the number of additional program segments which this BFD
760 will need. It should return -1 on error. */
761 int (*elf_backend_additional_program_headers)
762 (bfd *);
764 /* This function is called to modify an existing segment map in a
765 backend specific fashion. */
766 bfd_boolean (*elf_backend_modify_segment_map)
767 (bfd *);
769 /* This function is called during section gc to discover the section a
770 particular relocation refers to. */
771 asection * (*gc_mark_hook)
772 (asection *sec, struct bfd_link_info *, Elf_Internal_Rela *,
773 struct elf_link_hash_entry *h, Elf_Internal_Sym *);
775 /* This function, if defined, is called during the sweep phase of gc
776 in order that a backend might update any data structures it might
777 be maintaining. */
778 bfd_boolean (*gc_sweep_hook)
779 (bfd *abfd, struct bfd_link_info *info, asection *o,
780 const Elf_Internal_Rela *relocs);
782 /* This function, if defined, is called after the ELF headers have
783 been created. This allows for things like the OS and ABI versions
784 to be changed. */
785 void (*elf_backend_post_process_headers)
786 (bfd *, struct bfd_link_info *);
788 /* This function, if defined, prints a symbol to file and returns the
789 name of the symbol to be printed. It should return NULL to fall
790 back to default symbol printing. */
791 const char *(*elf_backend_print_symbol_all)
792 (bfd *, void *, asymbol *);
794 /* This function, if defined, is called after all local symbols and
795 global symbols converted to locals are emited into the symtab
796 section. It allows the backend to emit special global symbols
797 not handled in the hash table. */
798 bfd_boolean (*elf_backend_output_arch_syms)
799 (bfd *, struct bfd_link_info *, void *,
800 bfd_boolean (*) (void *, const char *, Elf_Internal_Sym *, asection *));
802 /* Copy any information related to dynamic linking from a pre-existing
803 symbol to a newly created symbol. Also called to copy flags and
804 other back-end info to a weakdef, in which case the symbol is not
805 newly created and plt/got refcounts and dynamic indices should not
806 be copied. */
807 void (*elf_backend_copy_indirect_symbol)
808 (const struct elf_backend_data *, struct elf_link_hash_entry *,
809 struct elf_link_hash_entry *);
811 /* Modify any information related to dynamic linking such that the
812 symbol is not exported. */
813 void (*elf_backend_hide_symbol)
814 (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
816 /* Emit relocations. Overrides default routine for emitting relocs,
817 except during a relocatable link, or if all relocs are being emitted. */
818 bfd_boolean (*elf_backend_emit_relocs)
819 (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
821 /* Count relocations. Not called for relocatable links
822 or if all relocs are being preserved in the output. */
823 unsigned int (*elf_backend_count_relocs)
824 (asection *, Elf_Internal_Rela *);
826 /* This function, if defined, is called when an NT_PRSTATUS note is found
827 in a core file. */
828 bfd_boolean (*elf_backend_grok_prstatus)
829 (bfd *, Elf_Internal_Note *);
831 /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO
832 note is found in a core file. */
833 bfd_boolean (*elf_backend_grok_psinfo)
834 (bfd *, Elf_Internal_Note *);
836 /* Functions to print VMAs. Special code to handle 64 bit ELF files. */
837 void (* elf_backend_sprintf_vma)
838 (bfd *, char *, bfd_vma);
839 void (* elf_backend_fprintf_vma)
840 (bfd *, void *, bfd_vma);
842 /* This function returns class of a reloc type. */
843 enum elf_reloc_type_class (*elf_backend_reloc_type_class)
844 (const Elf_Internal_Rela *);
846 /* This function, if defined, removes information about discarded functions
847 from other sections which mention them. */
848 bfd_boolean (*elf_backend_discard_info)
849 (bfd *, struct elf_reloc_cookie *, struct bfd_link_info *);
851 /* This function, if defined, signals that the function above has removed
852 the discarded relocations for this section. */
853 bfd_boolean (*elf_backend_ignore_discarded_relocs)
854 (asection *);
856 /* This function, if defined, may write out the given section.
857 Returns TRUE if it did so and FALSE if the caller should. */
858 bfd_boolean (*elf_backend_write_section)
859 (bfd *, asection *, bfd_byte *);
861 /* The level of IRIX compatibility we're striving for.
862 MIPS ELF specific function. */
863 irix_compat_t (*elf_backend_mips_irix_compat)
864 (bfd *);
866 reloc_howto_type *(*elf_backend_mips_rtype_to_howto)
867 (unsigned int, bfd_boolean);
869 /* The swapping table to use when dealing with ECOFF information.
870 Used for the MIPS ELF .mdebug section. */
871 const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap;
873 /* This function implements `bfd_elf_bfd_from_remote_memory';
874 see elf.c, elfcode.h. */
875 bfd *(*elf_backend_bfd_from_remote_memory)
876 (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
877 int (*target_read_memory) (bfd_vma vma, char *myaddr, int len));
879 /* Alternate EM_xxxx machine codes for this backend. */
880 int elf_machine_alt1;
881 int elf_machine_alt2;
883 const struct elf_size_info *s;
885 /* An array of target specific special section map. */
886 const struct bfd_elf_special_section *special_sections;
888 /* offset of the _GLOBAL_OFFSET_TABLE_ symbol from the start of the
889 .got section */
890 bfd_vma got_symbol_offset;
892 /* The size in bytes of the headers for the GOT and PLT. This includes
893 the so-called reserved entries on some systems. */
894 bfd_vma got_header_size;
895 bfd_vma plt_header_size;
897 /* This is TRUE if the linker should act like collect and gather
898 global constructors and destructors by name. This is TRUE for
899 MIPS ELF because the Irix 5 tools can not handle the .init
900 section. */
901 unsigned collect : 1;
903 /* This is TRUE if the linker should ignore changes to the type of a
904 symbol. This is TRUE for MIPS ELF because some Irix 5 objects
905 record undefined functions as STT_OBJECT although the definitions
906 are STT_FUNC. */
907 unsigned type_change_ok : 1;
909 /* Whether the backend may use REL relocations. (Some backends use
910 both REL and RELA relocations, and this flag is set for those
911 backends.) */
912 unsigned may_use_rel_p : 1;
914 /* Whether the backend may use RELA relocations. (Some backends use
915 both REL and RELA relocations, and this flag is set for those
916 backends.) */
917 unsigned may_use_rela_p : 1;
919 /* Whether the default relocation type is RELA. If a backend with
920 this flag set wants REL relocations for a particular section,
921 it must note that explicitly. Similarly, if this flag is clear,
922 and the backend wants RELA relocations for a particular
923 section. */
924 unsigned default_use_rela_p : 1;
926 /* Set if RELA relocations for a relocatable link can be handled by
927 generic code. Backends that set this flag need do nothing in the
928 backend relocate_section routine for relocatable linking. */
929 unsigned rela_normal : 1;
931 /* TRUE if addresses "naturally" sign extend. This is used when
932 swapping in from Elf32 when BFD64. */
933 unsigned sign_extend_vma : 1;
935 unsigned want_got_plt : 1;
936 unsigned plt_readonly : 1;
937 unsigned want_plt_sym : 1;
938 unsigned plt_not_loaded : 1;
939 unsigned plt_alignment : 4;
940 unsigned can_gc_sections : 1;
941 unsigned can_refcount : 1;
942 unsigned want_got_sym : 1;
943 unsigned want_dynbss : 1;
944 /* Targets which do not support physical addressing often require
945 that the p_paddr field in the section header to be set to zero.
946 This field indicates whether this behavior is required. */
947 unsigned want_p_paddr_set_to_zero : 1;
950 /* Information stored for each BFD section in an ELF file. This
951 structure is allocated by elf_new_section_hook. */
953 struct bfd_elf_section_data
955 /* The ELF header for this section. */
956 Elf_Internal_Shdr this_hdr;
958 /* The ELF header for the reloc section associated with this
959 section, if any. */
960 Elf_Internal_Shdr rel_hdr;
962 /* If there is a second reloc section associated with this section,
963 as can happen on Irix 6, this field points to the header. */
964 Elf_Internal_Shdr *rel_hdr2;
966 /* The number of relocations currently assigned to REL_HDR. */
967 unsigned int rel_count;
969 /* The number of relocations currently assigned to REL_HDR2. */
970 unsigned int rel_count2;
972 /* The ELF section number of this section. Only used for an output
973 file. */
974 int this_idx;
976 /* The ELF section number of the reloc section indicated by
977 REL_HDR if any. Only used for an output file. */
978 int rel_idx;
980 /* The ELF section number of the reloc section indicated by
981 REL_HDR2 if any. Only used for an output file. */
982 int rel_idx2;
984 /* Used by the backend linker when generating a shared library to
985 record the dynamic symbol index for a section symbol
986 corresponding to this section. A value of 0 means that there is
987 no dynamic symbol for this section. */
988 int dynindx;
990 /* Used by the backend linker to store the symbol hash table entries
991 associated with relocs against global symbols. */
992 struct elf_link_hash_entry **rel_hashes;
994 /* A pointer to the swapped relocs. If the section uses REL relocs,
995 rather than RELA, all the r_addend fields will be zero. This
996 pointer may be NULL. It is used by the backend linker. */
997 Elf_Internal_Rela *relocs;
999 /* A pointer to a linked list tracking dynamic relocs copied for
1000 local symbols. */
1001 void *local_dynrel;
1003 /* A pointer to the bfd section used for dynamic relocs. */
1004 asection *sreloc;
1006 union {
1007 /* Group name, if this section is a member of a group. */
1008 const char *name;
1010 /* Group signature sym, if this is the SHT_GROUP section. */
1011 struct symbol_cache_entry *id;
1012 } group;
1014 /* A linked list of sections in the group. Circular when used by
1015 the linker. */
1016 asection *next_in_group;
1018 /* A pointer used for various section optimizations. */
1019 void *sec_info;
1022 #define elf_section_data(sec) ((struct bfd_elf_section_data*)sec->used_by_bfd)
1023 #define elf_section_type(sec) (elf_section_data(sec)->this_hdr.sh_type)
1024 #define elf_section_flags(sec) (elf_section_data(sec)->this_hdr.sh_flags)
1025 #define elf_group_name(sec) (elf_section_data(sec)->group.name)
1026 #define elf_group_id(sec) (elf_section_data(sec)->group.id)
1027 #define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group)
1029 /* Return TRUE if section has been discarded. */
1030 #define elf_discarded_section(sec) \
1031 (!bfd_is_abs_section (sec) \
1032 && bfd_is_abs_section ((sec)->output_section) \
1033 && sec->sec_info_type != ELF_INFO_TYPE_MERGE \
1034 && sec->sec_info_type != ELF_INFO_TYPE_JUST_SYMS)
1036 #define get_elf_backend_data(abfd) \
1037 ((const struct elf_backend_data *) (abfd)->xvec->backend_data)
1039 /* This struct is used to pass information to routines called via
1040 elf_link_hash_traverse which must return failure. */
1042 struct elf_info_failed
1044 bfd_boolean failed;
1045 struct bfd_link_info *info;
1046 struct bfd_elf_version_tree *verdefs;
1049 /* This structure is used to pass information to
1050 _bfd_elf_link_assign_sym_version. */
1052 struct elf_assign_sym_version_info
1054 /* Output BFD. */
1055 bfd *output_bfd;
1056 /* General link information. */
1057 struct bfd_link_info *info;
1058 /* Version tree. */
1059 struct bfd_elf_version_tree *verdefs;
1060 /* Whether we had a failure. */
1061 bfd_boolean failed;
1064 /* This structure is used to pass information to
1065 _bfd_elf_link_find_version_dependencies. */
1067 struct elf_find_verdep_info
1069 /* Output BFD. */
1070 bfd *output_bfd;
1071 /* General link information. */
1072 struct bfd_link_info *info;
1073 /* The number of dependencies. */
1074 unsigned int vers;
1075 /* Whether we had a failure. */
1076 bfd_boolean failed;
1079 /* Some private data is stashed away for future use using the tdata pointer
1080 in the bfd structure. */
1082 struct elf_obj_tdata
1084 Elf_Internal_Ehdr elf_header[1]; /* Actual data, but ref like ptr */
1085 Elf_Internal_Shdr **elf_sect_ptr;
1086 Elf_Internal_Phdr *phdr;
1087 struct elf_segment_map *segment_map;
1088 struct elf_strtab_hash *strtab_ptr;
1089 int num_locals;
1090 int num_globals;
1091 unsigned int num_elf_sections; /* elf_sect_ptr size */
1092 int num_section_syms;
1093 asymbol **section_syms; /* STT_SECTION symbols for each section */
1094 Elf_Internal_Shdr symtab_hdr;
1095 Elf_Internal_Shdr shstrtab_hdr;
1096 Elf_Internal_Shdr strtab_hdr;
1097 Elf_Internal_Shdr dynsymtab_hdr;
1098 Elf_Internal_Shdr dynstrtab_hdr;
1099 Elf_Internal_Shdr dynversym_hdr;
1100 Elf_Internal_Shdr dynverref_hdr;
1101 Elf_Internal_Shdr dynverdef_hdr;
1102 Elf_Internal_Shdr symtab_shndx_hdr;
1103 unsigned int symtab_section, shstrtab_section;
1104 unsigned int strtab_section, dynsymtab_section;
1105 unsigned int symtab_shndx_section;
1106 unsigned int dynversym_section, dynverdef_section, dynverref_section;
1107 file_ptr next_file_pos;
1108 bfd_vma gp; /* The gp value */
1109 unsigned int gp_size; /* The gp size */
1111 Elf_Internal_Shdr **group_sect_ptr;
1112 int num_group;
1114 /* Information grabbed from an elf core file. */
1115 int core_signal;
1116 int core_pid;
1117 int core_lwpid;
1118 char* core_program;
1119 char* core_command;
1121 /* This is set to TRUE if the object was created by the backend
1122 linker. */
1123 bfd_boolean linker;
1125 /* A mapping from external symbols to entries in the linker hash
1126 table, used when linking. This is indexed by the symbol index
1127 minus the sh_info field of the symbol table header. */
1128 struct elf_link_hash_entry **sym_hashes;
1130 /* Track usage and final offsets of GOT entries for local symbols.
1131 This array is indexed by symbol index. Elements are used
1132 identically to "got" in struct elf_link_hash_entry. */
1133 union
1135 bfd_signed_vma *refcounts;
1136 bfd_vma *offsets;
1137 struct got_entry **ents;
1138 } local_got;
1140 /* The linker ELF emulation code needs to let the backend ELF linker
1141 know what filename should be used for a dynamic object if the
1142 dynamic object is found using a search. The emulation code then
1143 sometimes needs to know what name was actually used. Until the
1144 file has been added to the linker symbol table, this field holds
1145 the name the linker wants. After it has been added, it holds the
1146 name actually used, which will be the DT_SONAME entry if there is
1147 one. */
1148 const char *dt_name;
1150 /* When a reference in a regular object is resolved by a shared
1151 object is loaded into via the DT_NEEDED entries by the linker
1152 ELF emulation code, we need to add the shared object to the
1153 DT_NEEDED list of the resulting binary to indicate the dependency
1154 as if the -l option is passed to the linker. This field holds the
1155 name of the loaded shared object. */
1156 const char *dt_soname;
1158 /* Irix 5 often screws up the symbol table, sorting local symbols
1159 after global symbols. This flag is set if the symbol table in
1160 this BFD appears to be screwed up. If it is, we ignore the
1161 sh_info field in the symbol table header, and always read all the
1162 symbols. */
1163 bfd_boolean bad_symtab;
1165 /* Records the result of `get_program_header_size'. */
1166 bfd_size_type program_header_size;
1168 /* Used by find_nearest_line entry point. */
1169 void *line_info;
1171 /* Used by MIPS ELF find_nearest_line entry point. The structure
1172 could be included directly in this one, but there's no point to
1173 wasting the memory just for the infrequently called
1174 find_nearest_line. */
1175 struct mips_elf_find_line *find_line_info;
1177 /* A place to stash dwarf1 info for this bfd. */
1178 struct dwarf1_debug *dwarf1_find_line_info;
1180 /* A place to stash dwarf2 info for this bfd. */
1181 void *dwarf2_find_line_info;
1183 /* An array of stub sections indexed by symbol number, used by the
1184 MIPS ELF linker. FIXME: We should figure out some way to only
1185 include this field for a MIPS ELF target. */
1186 asection **local_stubs;
1188 /* Used to determine if PT_GNU_EH_FRAME segment header should be
1189 created. */
1190 asection *eh_frame_hdr;
1192 /* Used to determine if the e_flags field has been initialized */
1193 bfd_boolean flags_init;
1195 /* Number of symbol version definitions we are about to emit. */
1196 unsigned int cverdefs;
1198 /* Number of symbol version references we are about to emit. */
1199 unsigned int cverrefs;
1201 /* Segment flags for the PT_GNU_STACK segment. */
1202 unsigned int stack_flags;
1204 /* Symbol version definitions in external objects. */
1205 Elf_Internal_Verdef *verdef;
1207 /* Symbol version references to external objects. */
1208 Elf_Internal_Verneed *verref;
1210 /* The Irix 5 support uses two virtual sections, which represent
1211 text/data symbols defined in dynamic objects. */
1212 asymbol *elf_data_symbol;
1213 asymbol *elf_text_symbol;
1214 asection *elf_data_section;
1215 asection *elf_text_section;
1218 #define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data)
1219 #define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header)
1220 #define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr)
1221 #define elf_numsections(bfd) (elf_tdata(bfd) -> num_elf_sections)
1222 #define elf_shstrtab(bfd) (elf_tdata(bfd) -> strtab_ptr)
1223 #define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section)
1224 #define elf_symtab_shndx(bfd) (elf_tdata(bfd) -> symtab_shndx_section)
1225 #define elf_dynsymtab(bfd) (elf_tdata(bfd) -> dynsymtab_section)
1226 #define elf_dynversym(bfd) (elf_tdata(bfd) -> dynversym_section)
1227 #define elf_dynverdef(bfd) (elf_tdata(bfd) -> dynverdef_section)
1228 #define elf_dynverref(bfd) (elf_tdata(bfd) -> dynverref_section)
1229 #define elf_num_locals(bfd) (elf_tdata(bfd) -> num_locals)
1230 #define elf_num_globals(bfd) (elf_tdata(bfd) -> num_globals)
1231 #define elf_section_syms(bfd) (elf_tdata(bfd) -> section_syms)
1232 #define elf_num_section_syms(bfd) (elf_tdata(bfd) -> num_section_syms)
1233 #define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo)
1234 #define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus)
1235 #define elf_gp(bfd) (elf_tdata(bfd) -> gp)
1236 #define elf_gp_size(bfd) (elf_tdata(bfd) -> gp_size)
1237 #define elf_sym_hashes(bfd) (elf_tdata(bfd) -> sym_hashes)
1238 #define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts)
1239 #define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets)
1240 #define elf_local_got_ents(bfd) (elf_tdata(bfd) -> local_got.ents)
1241 #define elf_dt_name(bfd) (elf_tdata(bfd) -> dt_name)
1242 #define elf_dt_soname(bfd) (elf_tdata(bfd) -> dt_soname)
1243 #define elf_bad_symtab(bfd) (elf_tdata(bfd) -> bad_symtab)
1244 #define elf_flags_init(bfd) (elf_tdata(bfd) -> flags_init)
1246 extern void _bfd_elf_swap_verdef_in
1247 (bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *);
1248 extern void _bfd_elf_swap_verdef_out
1249 (bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *);
1250 extern void _bfd_elf_swap_verdaux_in
1251 (bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *);
1252 extern void _bfd_elf_swap_verdaux_out
1253 (bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *);
1254 extern void _bfd_elf_swap_verneed_in
1255 (bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *);
1256 extern void _bfd_elf_swap_verneed_out
1257 (bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *);
1258 extern void _bfd_elf_swap_vernaux_in
1259 (bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *);
1260 extern void _bfd_elf_swap_vernaux_out
1261 (bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *);
1262 extern void _bfd_elf_swap_versym_in
1263 (bfd *, const Elf_External_Versym *, Elf_Internal_Versym *);
1264 extern void _bfd_elf_swap_versym_out
1265 (bfd *, const Elf_Internal_Versym *, Elf_External_Versym *);
1267 extern int _bfd_elf_section_from_bfd_section
1268 (bfd *, asection *);
1269 extern char *bfd_elf_string_from_elf_section
1270 (bfd *, unsigned, unsigned);
1271 extern char *bfd_elf_get_str_section
1272 (bfd *, unsigned);
1273 extern Elf_Internal_Sym *bfd_elf_get_elf_syms
1274 (bfd *, Elf_Internal_Shdr *, size_t, size_t, Elf_Internal_Sym *, void *,
1275 Elf_External_Sym_Shndx *);
1276 extern const char *bfd_elf_local_sym_name
1277 (bfd *, Elf_Internal_Sym *);
1279 extern bfd_boolean _bfd_elf_copy_private_bfd_data
1280 (bfd *, bfd *);
1281 extern bfd_boolean _bfd_elf_print_private_bfd_data
1282 (bfd *, void *);
1283 extern void bfd_elf_print_symbol
1284 (bfd *, void *, asymbol *, bfd_print_symbol_type);
1286 #define elf_string_from_elf_strtab(abfd, strindex) \
1287 bfd_elf_string_from_elf_section (abfd, elf_elfheader(abfd)->e_shstrndx, \
1288 strindex)
1290 #define bfd_elf32_print_symbol bfd_elf_print_symbol
1291 #define bfd_elf64_print_symbol bfd_elf_print_symbol
1293 extern void _bfd_elf_sprintf_vma
1294 (bfd *, char *, bfd_vma);
1295 extern void _bfd_elf_fprintf_vma
1296 (bfd *, void *, bfd_vma);
1298 extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
1299 (const Elf_Internal_Rela *);
1300 extern bfd_vma _bfd_elf_rela_local_sym
1301 (bfd *, Elf_Internal_Sym *, asection *, Elf_Internal_Rela *);
1302 extern bfd_vma _bfd_elf_rel_local_sym
1303 (bfd *, Elf_Internal_Sym *, asection **, bfd_vma);
1304 extern bfd_vma _bfd_elf_section_offset
1305 (bfd *, struct bfd_link_info *, asection *, bfd_vma);
1307 extern unsigned long bfd_elf_hash
1308 (const char *);
1310 extern bfd_reloc_status_type bfd_elf_generic_reloc
1311 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
1312 extern bfd_boolean bfd_elf_mkobject
1313 (bfd *);
1314 extern bfd_boolean bfd_elf_mkcorefile
1315 (bfd *);
1316 extern Elf_Internal_Shdr *bfd_elf_find_section
1317 (bfd *, char *);
1318 extern bfd_boolean _bfd_elf_make_section_from_shdr
1319 (bfd *, Elf_Internal_Shdr *, const char *);
1320 extern bfd_boolean _bfd_elf_make_section_from_phdr
1321 (bfd *, Elf_Internal_Phdr *, int, const char *);
1322 extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc
1323 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
1324 extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create
1325 (bfd *);
1326 extern void _bfd_elf_link_hash_copy_indirect
1327 (const struct elf_backend_data *, struct elf_link_hash_entry *,
1328 struct elf_link_hash_entry *);
1329 extern void _bfd_elf_link_hash_hide_symbol
1330 (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
1331 extern bfd_boolean _bfd_elf_link_hash_table_init
1332 (struct elf_link_hash_table *, bfd *,
1333 struct bfd_hash_entry *(*)
1334 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
1335 extern bfd_boolean _bfd_elf_slurp_version_tables
1336 (bfd *);
1337 extern bfd_boolean _bfd_elf_merge_sections
1338 (bfd *, struct bfd_link_info *);
1339 extern bfd_boolean bfd_elf_discard_group
1340 (bfd *, struct sec *);
1341 extern void bfd_elf_set_group_contents
1342 (bfd *, asection *, void *);
1343 extern void _bfd_elf_link_just_syms
1344 (asection *, struct bfd_link_info *);
1345 extern bfd_boolean _bfd_elf_copy_private_symbol_data
1346 (bfd *, asymbol *, bfd *, asymbol *);
1347 extern bfd_boolean _bfd_elf_copy_private_section_data
1348 (bfd *, asection *, bfd *, asection *);
1349 extern bfd_boolean _bfd_elf_write_object_contents
1350 (bfd *);
1351 extern bfd_boolean _bfd_elf_write_corefile_contents
1352 (bfd *);
1353 extern bfd_boolean _bfd_elf_set_section_contents
1354 (bfd *, sec_ptr, void *, file_ptr, bfd_size_type);
1355 extern long _bfd_elf_get_symtab_upper_bound
1356 (bfd *);
1357 extern long _bfd_elf_get_symtab
1358 (bfd *, asymbol **);
1359 extern long _bfd_elf_get_dynamic_symtab_upper_bound
1360 (bfd *);
1361 extern long _bfd_elf_canonicalize_dynamic_symtab
1362 (bfd *, asymbol **);
1363 extern long _bfd_elf_get_reloc_upper_bound
1364 (bfd *, sec_ptr);
1365 extern long _bfd_elf_canonicalize_reloc
1366 (bfd *, sec_ptr, arelent **, asymbol **);
1367 extern long _bfd_elf_get_dynamic_reloc_upper_bound
1368 (bfd *);
1369 extern long _bfd_elf_canonicalize_dynamic_reloc
1370 (bfd *, arelent **, asymbol **);
1371 extern asymbol *_bfd_elf_make_empty_symbol
1372 (bfd *);
1373 extern void _bfd_elf_get_symbol_info
1374 (bfd *, asymbol *, symbol_info *);
1375 extern bfd_boolean _bfd_elf_is_local_label_name
1376 (bfd *, const char *);
1377 extern alent *_bfd_elf_get_lineno
1378 (bfd *, asymbol *);
1379 extern bfd_boolean _bfd_elf_set_arch_mach
1380 (bfd *, enum bfd_architecture, unsigned long);
1381 extern bfd_boolean _bfd_elf_find_nearest_line
1382 (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **,
1383 unsigned int *);
1384 #define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols
1385 #define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1386 extern int _bfd_elf_sizeof_headers
1387 (bfd *, bfd_boolean);
1388 extern bfd_boolean _bfd_elf_new_section_hook
1389 (bfd *, asection *);
1390 extern bfd_boolean _bfd_elf_init_reloc_shdr
1391 (bfd *, Elf_Internal_Shdr *, asection *, bfd_boolean);
1392 extern const struct bfd_elf_special_section *_bfd_elf_get_sec_type_attr
1393 (bfd *, const char *);
1395 /* If the target doesn't have reloc handling written yet: */
1396 extern void _bfd_elf_no_info_to_howto
1397 (bfd *, arelent *, Elf_Internal_Rela *);
1399 extern bfd_boolean bfd_section_from_shdr
1400 (bfd *, unsigned int shindex);
1401 extern bfd_boolean bfd_section_from_phdr
1402 (bfd *, Elf_Internal_Phdr *, int);
1404 extern int _bfd_elf_symbol_from_bfd_symbol
1405 (bfd *, asymbol **);
1407 extern asection *bfd_section_from_r_symndx
1408 (bfd *, struct sym_sec_cache *, asection *, unsigned long);
1409 extern asection *bfd_section_from_elf_index
1410 (bfd *, unsigned int);
1411 extern struct bfd_strtab_hash *_bfd_elf_stringtab_init
1412 (void);
1414 extern struct elf_strtab_hash * _bfd_elf_strtab_init
1415 (void);
1416 extern void _bfd_elf_strtab_free
1417 (struct elf_strtab_hash *);
1418 extern bfd_size_type _bfd_elf_strtab_add
1419 (struct elf_strtab_hash *, const char *, bfd_boolean);
1420 extern void _bfd_elf_strtab_addref
1421 (struct elf_strtab_hash *, bfd_size_type);
1422 extern void _bfd_elf_strtab_delref
1423 (struct elf_strtab_hash *, bfd_size_type);
1424 extern void _bfd_elf_strtab_clear_all_refs
1425 (struct elf_strtab_hash *);
1426 extern bfd_size_type _bfd_elf_strtab_size
1427 (struct elf_strtab_hash *);
1428 extern bfd_size_type _bfd_elf_strtab_offset
1429 (struct elf_strtab_hash *, bfd_size_type);
1430 extern bfd_boolean _bfd_elf_strtab_emit
1431 (bfd *, struct elf_strtab_hash *);
1432 extern void _bfd_elf_strtab_finalize
1433 (struct elf_strtab_hash *);
1435 extern bfd_boolean _bfd_elf_discard_section_eh_frame
1436 (bfd *, struct bfd_link_info *, asection *,
1437 bfd_boolean (*) (bfd_vma, void *), struct elf_reloc_cookie *);
1438 extern bfd_boolean _bfd_elf_discard_section_eh_frame_hdr
1439 (bfd *, struct bfd_link_info *);
1440 extern bfd_vma _bfd_elf_eh_frame_section_offset
1441 (bfd *, asection *, bfd_vma);
1442 extern bfd_boolean _bfd_elf_write_section_eh_frame
1443 (bfd *, struct bfd_link_info *, asection *, bfd_byte *);
1444 extern bfd_boolean _bfd_elf_write_section_eh_frame_hdr
1445 (bfd *, struct bfd_link_info *);
1446 extern bfd_boolean _bfd_elf_maybe_strip_eh_frame_hdr
1447 (struct bfd_link_info *);
1449 extern bfd_boolean _bfd_elf_merge_symbol
1450 (bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *,
1451 asection **, bfd_vma *, struct elf_link_hash_entry **, bfd_boolean *,
1452 bfd_boolean *, bfd_boolean *, bfd_boolean *, bfd_boolean);
1454 extern bfd_boolean _bfd_elf_add_default_symbol
1455 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
1456 const char *, Elf_Internal_Sym *, asection **, bfd_vma *,
1457 bfd_boolean *, bfd_boolean, bfd_boolean);
1459 extern bfd_boolean _bfd_elf_export_symbol
1460 (struct elf_link_hash_entry *, void *);
1462 extern bfd_boolean _bfd_elf_link_find_version_dependencies
1463 (struct elf_link_hash_entry *, void *);
1465 extern bfd_boolean _bfd_elf_link_assign_sym_version
1466 (struct elf_link_hash_entry *, void *);
1468 extern bfd_boolean _bfd_elf_link_record_dynamic_symbol
1469 (struct bfd_link_info *, struct elf_link_hash_entry *);
1470 extern long _bfd_elf_link_lookup_local_dynindx
1471 (struct bfd_link_info *, bfd *, long);
1472 extern bfd_boolean _bfd_elf_compute_section_file_positions
1473 (bfd *, struct bfd_link_info *);
1474 extern void _bfd_elf_assign_file_positions_for_relocs
1475 (bfd *);
1476 extern file_ptr _bfd_elf_assign_file_position_for_section
1477 (Elf_Internal_Shdr *, file_ptr, bfd_boolean);
1479 extern bfd_boolean _bfd_elf_validate_reloc
1480 (bfd *, arelent *);
1482 extern bfd_boolean _bfd_elf_link_create_dynamic_sections
1483 (bfd *, struct bfd_link_info *);
1484 extern bfd_boolean _bfd_elf_create_dynamic_sections
1485 (bfd *, struct bfd_link_info *);
1486 extern bfd_boolean _bfd_elf_create_got_section
1487 (bfd *, struct bfd_link_info *);
1488 extern unsigned long _bfd_elf_link_renumber_dynsyms
1489 (bfd *, struct bfd_link_info *);
1491 extern bfd_boolean _bfd_elfcore_make_pseudosection
1492 (bfd *, char *, size_t, ufile_ptr);
1493 extern char *_bfd_elfcore_strndup
1494 (bfd *, char *, size_t);
1496 extern Elf_Internal_Rela *_bfd_elf_link_read_relocs
1497 (bfd *, asection *, void *, Elf_Internal_Rela *, bfd_boolean);
1499 extern bfd_boolean _bfd_elf_link_size_reloc_section
1500 (bfd *, Elf_Internal_Shdr *, asection *);
1502 extern bfd_boolean _bfd_elf_link_output_relocs
1503 (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
1505 extern bfd_boolean _bfd_elf_fix_symbol_flags
1506 (struct elf_link_hash_entry *, struct elf_info_failed *);
1508 extern bfd_boolean _bfd_elf_adjust_dynamic_symbol
1509 (struct elf_link_hash_entry *, void *);
1511 extern bfd_boolean _bfd_elf_link_sec_merge_syms
1512 (struct elf_link_hash_entry *, void *);
1514 extern bfd_boolean _bfd_elf_dynamic_symbol_p
1515 (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
1517 extern bfd_boolean _bfd_elf_symbol_refs_local_p
1518 (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
1520 extern const bfd_target *bfd_elf32_object_p
1521 (bfd *);
1522 extern const bfd_target *bfd_elf32_core_file_p
1523 (bfd *);
1524 extern char *bfd_elf32_core_file_failing_command
1525 (bfd *);
1526 extern int bfd_elf32_core_file_failing_signal
1527 (bfd *);
1528 extern bfd_boolean bfd_elf32_core_file_matches_executable_p
1529 (bfd *, bfd *);
1531 extern bfd_boolean bfd_elf32_bfd_link_add_symbols
1532 (bfd *, struct bfd_link_info *);
1533 extern bfd_boolean bfd_elf32_bfd_final_link
1534 (bfd *, struct bfd_link_info *);
1536 extern void bfd_elf32_swap_symbol_in
1537 (bfd *, const void *, const void *, Elf_Internal_Sym *);
1538 extern void bfd_elf32_swap_symbol_out
1539 (bfd *, const Elf_Internal_Sym *, void *, void *);
1540 extern void bfd_elf32_swap_reloc_in
1541 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1542 extern void bfd_elf32_swap_reloc_out
1543 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1544 extern void bfd_elf32_swap_reloca_in
1545 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1546 extern void bfd_elf32_swap_reloca_out
1547 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1548 extern void bfd_elf32_swap_phdr_in
1549 (bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *);
1550 extern void bfd_elf32_swap_phdr_out
1551 (bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *);
1552 extern void bfd_elf32_swap_dyn_in
1553 (bfd *, const void *, Elf_Internal_Dyn *);
1554 extern void bfd_elf32_swap_dyn_out
1555 (bfd *, const Elf_Internal_Dyn *, void *);
1556 extern long bfd_elf32_slurp_symbol_table
1557 (bfd *, asymbol **, bfd_boolean);
1558 extern bfd_boolean bfd_elf32_write_shdrs_and_ehdr
1559 (bfd *);
1560 extern int bfd_elf32_write_out_phdrs
1561 (bfd *, const Elf_Internal_Phdr *, unsigned int);
1562 extern void bfd_elf32_write_relocs
1563 (bfd *, asection *, void *);
1564 extern bfd_boolean bfd_elf32_slurp_reloc_table
1565 (bfd *, asection *, asymbol **, bfd_boolean);
1566 extern bfd_boolean bfd_elf32_add_dynamic_entry
1567 (struct bfd_link_info *, bfd_vma, bfd_vma);
1569 extern const bfd_target *bfd_elf64_object_p
1570 (bfd *);
1571 extern const bfd_target *bfd_elf64_core_file_p
1572 (bfd *);
1573 extern char *bfd_elf64_core_file_failing_command
1574 (bfd *);
1575 extern int bfd_elf64_core_file_failing_signal
1576 (bfd *);
1577 extern bfd_boolean bfd_elf64_core_file_matches_executable_p
1578 (bfd *, bfd *);
1579 extern bfd_boolean bfd_elf64_bfd_link_add_symbols
1580 (bfd *, struct bfd_link_info *);
1581 extern bfd_boolean bfd_elf64_bfd_final_link
1582 (bfd *, struct bfd_link_info *);
1584 extern void bfd_elf64_swap_symbol_in
1585 (bfd *, const void *, const void *, Elf_Internal_Sym *);
1586 extern void bfd_elf64_swap_symbol_out
1587 (bfd *, const Elf_Internal_Sym *, void *, void *);
1588 extern void bfd_elf64_swap_reloc_in
1589 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1590 extern void bfd_elf64_swap_reloc_out
1591 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1592 extern void bfd_elf64_swap_reloca_in
1593 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1594 extern void bfd_elf64_swap_reloca_out
1595 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1596 extern void bfd_elf64_swap_phdr_in
1597 (bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *);
1598 extern void bfd_elf64_swap_phdr_out
1599 (bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *);
1600 extern void bfd_elf64_swap_dyn_in
1601 (bfd *, const void *, Elf_Internal_Dyn *);
1602 extern void bfd_elf64_swap_dyn_out
1603 (bfd *, const Elf_Internal_Dyn *, void *);
1604 extern long bfd_elf64_slurp_symbol_table
1605 (bfd *, asymbol **, bfd_boolean);
1606 extern bfd_boolean bfd_elf64_write_shdrs_and_ehdr
1607 (bfd *);
1608 extern int bfd_elf64_write_out_phdrs
1609 (bfd *, const Elf_Internal_Phdr *, unsigned int);
1610 extern void bfd_elf64_write_relocs
1611 (bfd *, asection *, void *);
1612 extern bfd_boolean bfd_elf64_slurp_reloc_table
1613 (bfd *, asection *, asymbol **, bfd_boolean);
1614 extern bfd_boolean bfd_elf64_add_dynamic_entry
1615 (struct bfd_link_info *, bfd_vma, bfd_vma);
1617 #define bfd_elf32_link_record_dynamic_symbol \
1618 _bfd_elf_link_record_dynamic_symbol
1619 #define bfd_elf64_link_record_dynamic_symbol \
1620 _bfd_elf_link_record_dynamic_symbol
1622 extern int elf_link_record_local_dynamic_symbol
1623 (struct bfd_link_info *, bfd *, long);
1624 #define _bfd_elf32_link_record_local_dynamic_symbol \
1625 elf_link_record_local_dynamic_symbol
1626 #define _bfd_elf64_link_record_local_dynamic_symbol \
1627 elf_link_record_local_dynamic_symbol
1629 extern bfd_boolean _bfd_elf_close_and_cleanup
1630 (bfd *);
1631 extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn
1632 (bfd *, arelent *, struct symbol_cache_entry *, void *,
1633 asection *, bfd *, char **);
1635 extern bfd_boolean _bfd_elf32_gc_sections
1636 (bfd *, struct bfd_link_info *);
1637 extern bfd_boolean _bfd_elf32_gc_common_finalize_got_offsets
1638 (bfd *, struct bfd_link_info *);
1639 extern bfd_boolean _bfd_elf32_gc_common_final_link
1640 (bfd *, struct bfd_link_info *);
1641 extern bfd_boolean _bfd_elf32_gc_record_vtinherit
1642 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1643 extern bfd_boolean _bfd_elf32_gc_record_vtentry
1644 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1646 extern bfd_boolean _bfd_elf64_gc_sections
1647 (bfd *, struct bfd_link_info *);
1648 extern bfd_boolean _bfd_elf64_gc_common_finalize_got_offsets
1649 (bfd *, struct bfd_link_info *);
1650 extern bfd_boolean _bfd_elf64_gc_common_final_link
1651 (bfd *, struct bfd_link_info *);
1652 extern bfd_boolean _bfd_elf64_gc_record_vtinherit
1653 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1654 extern bfd_boolean _bfd_elf64_gc_record_vtentry
1655 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1657 extern bfd_boolean _bfd_elf32_reloc_symbol_deleted_p
1658 (bfd_vma, void *);
1659 extern bfd_boolean _bfd_elf64_reloc_symbol_deleted_p
1660 (bfd_vma, void *);
1662 /* Exported interface for writing elf corefile notes. */
1663 extern char *elfcore_write_note
1664 (bfd *, char *, int *, const char *, int, const void *, int);
1665 extern char *elfcore_write_prpsinfo
1666 (bfd *, char *, int *, const char *, const char *);
1667 extern char *elfcore_write_prstatus
1668 (bfd *, char *, int *, long, int, const void *);
1669 extern char * elfcore_write_pstatus
1670 (bfd *, char *, int *, long, int, const void *);
1671 extern char *elfcore_write_prfpreg
1672 (bfd *, char *, int *, const void *, int);
1673 extern char *elfcore_write_prxfpreg
1674 (bfd *, char *, int *, const void *, int);
1675 extern char *elfcore_write_lwpstatus
1676 (bfd *, char *, int *, long, int, const void *);
1678 extern bfd *_bfd_elf32_bfd_from_remote_memory
1679 (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
1680 int (*target_read_memory) (bfd_vma, char *, int));
1681 extern bfd *_bfd_elf64_bfd_from_remote_memory
1682 (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
1683 int (*target_read_memory) (bfd_vma, char *, int));
1685 /* SH ELF specific routine. */
1687 extern bfd_boolean _sh_elf_set_mach_from_flags
1688 (bfd *);
1690 /* This macro is to avoid lots of duplicated code in the body
1691 of xxx_relocate_section() in the various elfxx-xxxx.c files. */
1692 #define RELOC_FOR_GLOBAL_SYMBOL(h, sym_hashes, r_symndx, symtab_hdr, relocation, sec, unresolved_reloc, info, warned) \
1693 do \
1695 /* It seems this can happen with erroneous or unsupported \
1696 input (mixing a.out and elf in an archive, for example.) */ \
1697 if (sym_hashes == NULL) \
1698 return FALSE; \
1700 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; \
1702 while (h->root.type == bfd_link_hash_indirect \
1703 || h->root.type == bfd_link_hash_warning) \
1704 h = (struct elf_link_hash_entry *) h->root.u.i.link; \
1706 warned = FALSE; \
1707 unresolved_reloc = FALSE; \
1708 relocation = 0; \
1709 if (h->root.type == bfd_link_hash_defined \
1710 || h->root.type == bfd_link_hash_defweak) \
1712 sec = h->root.u.def.section; \
1713 if (sec == NULL \
1714 || sec->output_section == NULL) \
1715 /* Set a flag that will be cleared later if we find a \
1716 relocation value for this symbol. output_section \
1717 is typically NULL for symbols satisfied by a shared \
1718 library. */ \
1719 unresolved_reloc = TRUE; \
1720 else \
1721 relocation = (h->root.u.def.value \
1722 + sec->output_section->vma \
1723 + sec->output_offset); \
1725 else if (h->root.type == bfd_link_hash_undefweak) \
1727 else if (!info->executable \
1728 && info->unresolved_syms_in_objects == RM_IGNORE \
1729 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) \
1731 else \
1733 if (! info->callbacks->undefined_symbol \
1734 (info, h->root.root.string, input_bfd, \
1735 input_section, rel->r_offset, \
1736 ((info->shared && info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR) \
1737 || (!info->shared && info->unresolved_syms_in_objects == RM_GENERATE_ERROR) \
1738 || ELF_ST_VISIBILITY (h->other)) \
1739 )) \
1740 return FALSE; \
1741 warned = TRUE; \
1744 while (0)
1746 #endif /* _LIBELF_H_ */