Unmap the buffer if plugin didn't claim the file
[deliverable/binutils-gdb.git] / bfd / elf-bfd.h
1 /* BFD back-end data structures for ELF files.
2 Copyright (C) 1992-2015 Free Software Foundation, Inc.
3 Written by Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #ifndef _LIBELF_H_
23 #define _LIBELF_H_ 1
24
25 #include "elf/common.h"
26 #include "elf/external.h"
27 #include "elf/internal.h"
28 #include "bfdlink.h"
29
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 PR 9934: It is possible to have relocations that do not refer to
34 symbols, thus it is also possible to have a relocation section in
35 an object file, but no symbol table. */
36 #define NUM_SHDR_ENTRIES(shdr) ((shdr)->sh_entsize > 0 ? (shdr)->sh_size / (shdr)->sh_entsize : 0)
37
38 /* If size isn't specified as 64 or 32, NAME macro should fail. */
39 #ifndef NAME
40 #if ARCH_SIZE == 64
41 #define NAME(x, y) x ## 64 ## _ ## y
42 #endif
43 #if ARCH_SIZE == 32
44 #define NAME(x, y) x ## 32 ## _ ## y
45 #endif
46 #endif
47
48 #ifndef NAME
49 #define NAME(x, y) x ## NOSIZE ## _ ## y
50 #endif
51
52 #define ElfNAME(X) NAME(Elf,X)
53 #define elfNAME(X) NAME(elf,X)
54
55 /* Information held for an ELF symbol. The first field is the
56 corresponding asymbol. Every symbol is an ELF file is actually a
57 pointer to this structure, although it is often handled as a
58 pointer to an asymbol. */
59
60 typedef struct
61 {
62 /* The BFD symbol. */
63 asymbol symbol;
64 /* ELF symbol information. */
65 Elf_Internal_Sym internal_elf_sym;
66 /* Backend specific information. */
67 union
68 {
69 unsigned int hppa_arg_reloc;
70 void *mips_extr;
71 void *any;
72 }
73 tc_data;
74
75 /* Version information. This is from an Elf_Internal_Versym
76 structure in a SHT_GNU_versym section. It is zero if there is no
77 version information. */
78 unsigned short version;
79
80 } elf_symbol_type;
81 \f
82 struct elf_strtab_hash;
83 struct got_entry;
84 struct plt_entry;
85
86 union gotplt_union
87 {
88 bfd_signed_vma refcount;
89 bfd_vma offset;
90 struct got_entry *glist;
91 struct plt_entry *plist;
92 };
93
94 struct elf_link_virtual_table_entry
95 {
96 /* Virtual table entry use information. This array is nominally of size
97 size/sizeof(target_void_pointer), though we have to be able to assume
98 and track a size while the symbol is still undefined. It is indexed
99 via offset/sizeof(target_void_pointer). */
100 size_t size;
101 bfd_boolean *used;
102
103 /* Virtual table derivation info. */
104 struct elf_link_hash_entry *parent;
105 };
106
107 /* ELF linker hash table entries. */
108
109 struct elf_link_hash_entry
110 {
111 struct bfd_link_hash_entry root;
112
113 /* Symbol index in output file. This is initialized to -1. It is
114 set to -2 if the symbol is used by a reloc. */
115 long indx;
116
117 /* Symbol index as a dynamic symbol. Initialized to -1, and remains
118 -1 if this is not a dynamic symbol. */
119 /* ??? Note that this is consistently used as a synonym for tests
120 against whether we can perform various simplifying transformations
121 to the code. (E.g. changing a pc-relative jump to a PLT entry
122 into a pc-relative jump to the target function.) That test, which
123 is often relatively complex, and someplaces wrong or incomplete,
124 should really be replaced by a predicate in elflink.c.
125
126 End result: this field -1 does not indicate that the symbol is
127 not in the dynamic symbol table, but rather that the symbol is
128 not visible outside this DSO. */
129 long dynindx;
130
131 /* If this symbol requires an entry in the global offset table, the
132 processor specific backend uses this field to track usage and
133 final offset. Two schemes are supported: The first assumes that
134 a symbol may only have one GOT entry, and uses REFCOUNT until
135 size_dynamic_sections, at which point the contents of the .got is
136 fixed. Afterward, if OFFSET is -1, then the symbol does not
137 require a global offset table entry. The second scheme allows
138 multiple GOT entries per symbol, managed via a linked list
139 pointed to by GLIST. */
140 union gotplt_union got;
141
142 /* Same, but tracks a procedure linkage table entry. */
143 union gotplt_union plt;
144
145 /* Symbol size. */
146 bfd_size_type size;
147
148 /* Symbol type (STT_NOTYPE, STT_OBJECT, etc.). */
149 unsigned int type : 8;
150
151 /* Symbol st_other value, symbol visibility. */
152 unsigned int other : 8;
153
154 /* The symbol's st_target_internal value (see Elf_Internal_Sym). */
155 unsigned int target_internal : 8;
156
157 /* Symbol is referenced by a non-shared object (other than the object
158 in which it is defined). */
159 unsigned int ref_regular : 1;
160 /* Symbol is defined by a non-shared object. */
161 unsigned int def_regular : 1;
162 /* Symbol is referenced by a shared object. */
163 unsigned int ref_dynamic : 1;
164 /* Symbol is defined by a shared object. */
165 unsigned int def_dynamic : 1;
166 /* Symbol has a non-weak reference from a non-shared object (other than
167 the object in which it is defined). */
168 unsigned int ref_regular_nonweak : 1;
169 /* Dynamic symbol has been adjustd. */
170 unsigned int dynamic_adjusted : 1;
171 /* Symbol needs a copy reloc. */
172 unsigned int needs_copy : 1;
173 /* Symbol needs a procedure linkage table entry. */
174 unsigned int needs_plt : 1;
175 /* Symbol appears in a non-ELF input file. */
176 unsigned int non_elf : 1;
177 /* Symbol should be marked as hidden in the version information. */
178 unsigned int hidden : 1;
179 /* Symbol was forced to local scope due to a version script file. */
180 unsigned int forced_local : 1;
181 /* Symbol was forced to be dynamic due to a version script file. */
182 unsigned int dynamic : 1;
183 /* Symbol was marked during garbage collection. */
184 unsigned int mark : 1;
185 /* Symbol is referenced by a non-GOT/non-PLT relocation. This is
186 not currently set by all the backends. */
187 unsigned int non_got_ref : 1;
188 /* Symbol has a definition in a shared object.
189 FIXME: There is no real need for this field if def_dynamic is never
190 cleared and all places that test def_dynamic also test def_regular. */
191 unsigned int dynamic_def : 1;
192 /* Symbol has a non-weak reference from a shared object. */
193 unsigned int ref_dynamic_nonweak : 1;
194 /* Symbol is referenced with a relocation where C/C++ pointer equality
195 matters. */
196 unsigned int pointer_equality_needed : 1;
197 /* Symbol is a unique global symbol. */
198 unsigned int unique_global : 1;
199 /* Symbol is defined with non-default visibility. */
200 unsigned int protected_def : 1;
201
202 /* String table index in .dynstr if this is a dynamic symbol. */
203 unsigned long dynstr_index;
204
205 union
206 {
207 /* If this is a weak defined symbol from a dynamic object, this
208 field points to a defined symbol with the same value, if there is
209 one. Otherwise it is NULL. */
210 struct elf_link_hash_entry *weakdef;
211
212 /* Hash value of the name computed using the ELF hash function.
213 Used part way through size_dynamic_sections, after we've finished
214 with weakdefs. */
215 unsigned long elf_hash_value;
216 } u;
217
218 /* Version information. */
219 union
220 {
221 /* This field is used for a symbol which is not defined in a
222 regular object. It points to the version information read in
223 from the dynamic object. */
224 Elf_Internal_Verdef *verdef;
225 /* This field is used for a symbol which is defined in a regular
226 object. It is set up in size_dynamic_sections. It points to
227 the version information we should write out for this symbol. */
228 struct bfd_elf_version_tree *vertree;
229 } verinfo;
230
231 struct elf_link_virtual_table_entry *vtable;
232 };
233
234 /* Will references to this symbol always reference the symbol
235 in this object? */
236 #define SYMBOL_REFERENCES_LOCAL(INFO, H) \
237 _bfd_elf_symbol_refs_local_p (H, INFO, 0)
238
239 /* Will _calls_ to this symbol always call the version in this object? */
240 #define SYMBOL_CALLS_LOCAL(INFO, H) \
241 _bfd_elf_symbol_refs_local_p (H, INFO, 1)
242
243 /* Common symbols that are turned into definitions don't have the
244 DEF_REGULAR flag set, so they might appear to be undefined.
245 Symbols defined in linker scripts also don't have DEF_REGULAR set. */
246 #define ELF_COMMON_DEF_P(H) \
247 (!(H)->def_regular \
248 && !(H)->def_dynamic \
249 && (H)->root.type == bfd_link_hash_defined)
250
251 /* Records local symbols to be emitted in the dynamic symbol table. */
252
253 struct elf_link_local_dynamic_entry
254 {
255 struct elf_link_local_dynamic_entry *next;
256
257 /* The input bfd this symbol came from. */
258 bfd *input_bfd;
259
260 /* The index of the local symbol being copied. */
261 long input_indx;
262
263 /* The index in the outgoing dynamic symbol table. */
264 long dynindx;
265
266 /* A copy of the input symbol. */
267 Elf_Internal_Sym isym;
268 };
269
270 struct elf_link_loaded_list
271 {
272 struct elf_link_loaded_list *next;
273 bfd *abfd;
274 };
275
276 /* Structures used by the eh_frame optimization code. */
277 struct eh_cie_fde
278 {
279 union {
280 struct {
281 /* If REMOVED == 1, this is the CIE that the FDE originally used.
282 The CIE belongs to the same .eh_frame input section as the FDE.
283
284 If REMOVED == 0, this is the CIE that we have chosen to use for
285 the output FDE. The CIE's REMOVED field is also 0, but the CIE
286 might belong to a different .eh_frame input section from the FDE.
287
288 May be NULL to signify that the FDE should be discarded. */
289 struct eh_cie_fde *cie_inf;
290 struct eh_cie_fde *next_for_section;
291 } fde;
292 struct {
293 /* CIEs have three states:
294
295 - REMOVED && !MERGED: Slated for removal because we haven't yet
296 proven that an FDE needs it. FULL_CIE, if nonnull, points to
297 more detailed information about the CIE.
298
299 - REMOVED && MERGED: We have merged this CIE with MERGED_WITH,
300 which may not belong to the same input section.
301
302 - !REMOVED: We have decided to keep this CIE. SEC is the
303 .eh_frame input section that contains the CIE. */
304 union {
305 struct cie *full_cie;
306 struct eh_cie_fde *merged_with;
307 asection *sec;
308 } u;
309
310 /* The offset of the personality data from the start of the CIE,
311 or 0 if the CIE doesn't have any. */
312 unsigned int personality_offset : 8;
313
314 /* True if we have marked relocations associated with this CIE. */
315 unsigned int gc_mark : 1;
316
317 /* True if we have decided to turn an absolute LSDA encoding into
318 a PC-relative one. */
319 unsigned int make_lsda_relative : 1;
320
321 /* True if we have decided to turn an absolute personality
322 encoding into a PC-relative one. */
323 unsigned int make_per_encoding_relative : 1;
324
325 /* True if the CIE contains personality data and if that
326 data uses a PC-relative encoding. Always true when
327 make_per_encoding_relative is. */
328 unsigned int per_encoding_relative : 1;
329
330 /* True if we need to add an 'R' (FDE encoding) entry to the
331 CIE's augmentation data. */
332 unsigned int add_fde_encoding : 1;
333
334 /* True if we have merged this CIE with another. */
335 unsigned int merged : 1;
336
337 /* Unused bits. */
338 unsigned int pad1 : 18;
339 } cie;
340 } u;
341 unsigned int reloc_index;
342 unsigned int size;
343 unsigned int offset;
344 unsigned int new_offset;
345 unsigned int fde_encoding : 8;
346 unsigned int lsda_encoding : 8;
347 unsigned int lsda_offset : 8;
348
349 /* True if this entry represents a CIE, false if it represents an FDE. */
350 unsigned int cie : 1;
351
352 /* True if this entry is currently marked for removal. */
353 unsigned int removed : 1;
354
355 /* True if we need to add a 'z' (augmentation size) entry to the CIE's
356 augmentation data, and an associated byte to each of the CIE's FDEs. */
357 unsigned int add_augmentation_size : 1;
358
359 /* True if we have decided to convert absolute FDE relocations into
360 relative ones. This applies to the first relocation in the FDE,
361 which is against the code that the FDE describes. */
362 unsigned int make_relative : 1;
363
364 /* Unused bits. */
365 unsigned int pad1 : 4;
366
367 unsigned int *set_loc;
368 };
369
370 struct eh_frame_sec_info
371 {
372 unsigned int count;
373 struct cie *cies;
374 struct eh_cie_fde entry[1];
375 };
376
377 struct eh_frame_array_ent
378 {
379 bfd_vma initial_loc;
380 bfd_size_type range;
381 bfd_vma fde;
382 };
383
384 struct htab;
385
386 struct eh_frame_hdr_info
387 {
388 struct htab *cies;
389 asection *hdr_sec;
390 unsigned int fde_count, array_count;
391 struct eh_frame_array_ent *array;
392 /* TRUE if .eh_frame_hdr should contain the sorted search table.
393 We build it if we successfully read all .eh_frame input sections
394 and recognize them. */
395 bfd_boolean table;
396 };
397
398 /* Enum used to identify target specific extensions to the elf_obj_tdata
399 and elf_link_hash_table structures. Note the enums deliberately start
400 from 1 so that we can detect an uninitialized field. The generic value
401 is last so that additions to this enum do not need to modify more than
402 one line. */
403 enum elf_target_id
404 {
405 AARCH64_ELF_DATA = 1,
406 ALPHA_ELF_DATA,
407 ARM_ELF_DATA,
408 AVR_ELF_DATA,
409 BFIN_ELF_DATA,
410 CRIS_ELF_DATA,
411 FRV_ELF_DATA,
412 HPPA32_ELF_DATA,
413 HPPA64_ELF_DATA,
414 I386_ELF_DATA,
415 IA64_ELF_DATA,
416 LM32_ELF_DATA,
417 M32R_ELF_DATA,
418 M68HC11_ELF_DATA,
419 M68K_ELF_DATA,
420 METAG_ELF_DATA,
421 MICROBLAZE_ELF_DATA,
422 MIPS_ELF_DATA,
423 MN10300_ELF_DATA,
424 NDS32_ELF_DATA,
425 NIOS2_ELF_DATA,
426 OR1K_ELF_DATA,
427 PPC32_ELF_DATA,
428 PPC64_ELF_DATA,
429 S390_ELF_DATA,
430 SH_ELF_DATA,
431 SPARC_ELF_DATA,
432 SPU_ELF_DATA,
433 TIC6X_ELF_DATA,
434 X86_64_ELF_DATA,
435 XTENSA_ELF_DATA,
436 XGATE_ELF_DATA,
437 TILEGX_ELF_DATA,
438 TILEPRO_ELF_DATA,
439 GENERIC_ELF_DATA
440 };
441
442 /* ELF linker hash table. */
443
444 struct elf_link_hash_table
445 {
446 struct bfd_link_hash_table root;
447
448 /* An identifier used to distinguish different target
449 specific extensions to this structure. */
450 enum elf_target_id hash_table_id;
451
452 /* Whether we have created the special dynamic sections required
453 when linking against or generating a shared object. */
454 bfd_boolean dynamic_sections_created;
455
456 /* True if this target has relocatable executables, so needs dynamic
457 section symbols. */
458 bfd_boolean is_relocatable_executable;
459
460 /* The BFD used to hold special sections created by the linker.
461 This will be the first BFD found which requires these sections to
462 be created. */
463 bfd *dynobj;
464
465 /* The value to use when initialising got.refcount/offset and
466 plt.refcount/offset in an elf_link_hash_entry. Set to zero when
467 the values are refcounts. Set to init_got_offset/init_plt_offset
468 in size_dynamic_sections when the values may be offsets. */
469 union gotplt_union init_got_refcount;
470 union gotplt_union init_plt_refcount;
471
472 /* The value to use for got.refcount/offset and plt.refcount/offset
473 when the values may be offsets. Normally (bfd_vma) -1. */
474 union gotplt_union init_got_offset;
475 union gotplt_union init_plt_offset;
476
477 /* The number of symbols found in the link which must be put into
478 the .dynsym section. */
479 bfd_size_type dynsymcount;
480
481 /* The string table of dynamic symbols, which becomes the .dynstr
482 section. */
483 struct elf_strtab_hash *dynstr;
484
485 /* The number of buckets in the hash table in the .hash section.
486 This is based on the number of dynamic symbols. */
487 bfd_size_type bucketcount;
488
489 /* A linked list of DT_NEEDED names found in dynamic objects
490 included in the link. */
491 struct bfd_link_needed_list *needed;
492
493 /* Sections in the output bfd that provides a section symbol
494 to be used by relocations emitted against local symbols.
495 Most targets will not use data_index_section. */
496 asection *text_index_section;
497 asection *data_index_section;
498
499 /* The _GLOBAL_OFFSET_TABLE_ symbol. */
500 struct elf_link_hash_entry *hgot;
501
502 /* The _PROCEDURE_LINKAGE_TABLE_ symbol. */
503 struct elf_link_hash_entry *hplt;
504
505 /* The _DYNAMIC symbol. */
506 struct elf_link_hash_entry *hdynamic;
507
508 /* A pointer to information used to merge SEC_MERGE sections. */
509 void *merge_info;
510
511 /* Used to link stabs in sections. */
512 struct stab_info stab_info;
513
514 /* Used by eh_frame code when editing .eh_frame. */
515 struct eh_frame_hdr_info eh_info;
516
517 /* A linked list of local symbols to be added to .dynsym. */
518 struct elf_link_local_dynamic_entry *dynlocal;
519
520 /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic
521 objects included in the link. */
522 struct bfd_link_needed_list *runpath;
523
524 /* Cached first output tls section and size of PT_TLS segment. */
525 asection *tls_sec;
526 bfd_size_type tls_size;
527
528 /* A linked list of BFD's loaded in the link. */
529 struct elf_link_loaded_list *loaded;
530
531 /* Short-cuts to get to dynamic linker sections. */
532 asection *sgot;
533 asection *sgotplt;
534 asection *srelgot;
535 asection *splt;
536 asection *srelplt;
537 asection *igotplt;
538 asection *iplt;
539 asection *irelplt;
540 asection *irelifunc;
541 };
542
543 /* Look up an entry in an ELF linker hash table. */
544
545 #define elf_link_hash_lookup(table, string, create, copy, follow) \
546 ((struct elf_link_hash_entry *) \
547 bfd_link_hash_lookup (&(table)->root, (string), (create), \
548 (copy), (follow)))
549
550 /* Traverse an ELF linker hash table. */
551
552 #define elf_link_hash_traverse(table, func, info) \
553 (bfd_link_hash_traverse \
554 (&(table)->root, \
555 (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func), \
556 (info)))
557
558 /* Get the ELF linker hash table from a link_info structure. */
559
560 #define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))
561
562 #define elf_hash_table_id(table) ((table) -> hash_table_id)
563
564 /* Returns TRUE if the hash table is a struct elf_link_hash_table. */
565 #define is_elf_hash_table(htab) \
566 (((struct bfd_link_hash_table *) (htab))->type == bfd_link_elf_hash_table)
567
568 /* Used by bfd_sym_from_r_symndx to cache a small number of local
569 symbols. */
570 #define LOCAL_SYM_CACHE_SIZE 32
571 struct sym_cache
572 {
573 bfd *abfd;
574 unsigned long indx[LOCAL_SYM_CACHE_SIZE];
575 Elf_Internal_Sym sym[LOCAL_SYM_CACHE_SIZE];
576 };
577 \f
578 /* Constant information held for an ELF backend. */
579
580 struct elf_size_info {
581 unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr;
582 unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note;
583
584 /* The size of entries in the .hash section. */
585 unsigned char sizeof_hash_entry;
586
587 /* The number of internal relocations to allocate per external
588 relocation entry. */
589 unsigned char int_rels_per_ext_rel;
590 /* We use some fixed size arrays. This should be large enough to
591 handle all back-ends. */
592 #define MAX_INT_RELS_PER_EXT_REL 3
593
594 unsigned char arch_size, log_file_align;
595 unsigned char elfclass, ev_current;
596 int (*write_out_phdrs)
597 (bfd *, const Elf_Internal_Phdr *, unsigned int);
598 bfd_boolean
599 (*write_shdrs_and_ehdr) (bfd *);
600 bfd_boolean (*checksum_contents)
601 (bfd * , void (*) (const void *, size_t, void *), void *);
602 void (*write_relocs)
603 (bfd *, asection *, void *);
604 bfd_boolean (*swap_symbol_in)
605 (bfd *, const void *, const void *, Elf_Internal_Sym *);
606 void (*swap_symbol_out)
607 (bfd *, const Elf_Internal_Sym *, void *, void *);
608 bfd_boolean (*slurp_reloc_table)
609 (bfd *, asection *, asymbol **, bfd_boolean);
610 long (*slurp_symbol_table)
611 (bfd *, asymbol **, bfd_boolean);
612 void (*swap_dyn_in)
613 (bfd *, const void *, Elf_Internal_Dyn *);
614 void (*swap_dyn_out)
615 (bfd *, const Elf_Internal_Dyn *, void *);
616
617 /* This function is called to swap in a REL relocation. If an
618 external relocation corresponds to more than one internal
619 relocation, then all relocations are swapped in at once. */
620 void (*swap_reloc_in)
621 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
622
623 /* This function is called to swap out a REL relocation. */
624 void (*swap_reloc_out)
625 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
626
627 /* This function is called to swap in a RELA relocation. If an
628 external relocation corresponds to more than one internal
629 relocation, then all relocations are swapped in at once. */
630 void (*swap_reloca_in)
631 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
632
633 /* This function is called to swap out a RELA relocation. */
634 void (*swap_reloca_out)
635 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
636 };
637
638 #define elf_symbol_from(ABFD,S) \
639 (((S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \
640 && (S)->the_bfd->tdata.elf_obj_data != 0) \
641 ? (elf_symbol_type *) (S) \
642 : 0)
643
644 enum elf_reloc_type_class {
645 reloc_class_normal,
646 reloc_class_relative,
647 reloc_class_plt,
648 reloc_class_copy,
649 reloc_class_ifunc
650 };
651
652 struct elf_reloc_cookie
653 {
654 Elf_Internal_Rela *rels, *rel, *relend;
655 Elf_Internal_Sym *locsyms;
656 bfd *abfd;
657 size_t locsymcount;
658 size_t extsymoff;
659 struct elf_link_hash_entry **sym_hashes;
660 int r_sym_shift;
661 bfd_boolean bad_symtab;
662 };
663
664 /* The level of IRIX compatibility we're striving for. */
665
666 typedef enum {
667 ict_none,
668 ict_irix5,
669 ict_irix6
670 } irix_compat_t;
671
672 /* Mapping of ELF section names and types. */
673 struct bfd_elf_special_section
674 {
675 const char *prefix;
676 int prefix_length;
677 /* 0 means name must match PREFIX exactly.
678 -1 means name must start with PREFIX followed by an arbitrary string.
679 -2 means name must match PREFIX exactly or consist of PREFIX followed
680 by a dot then anything.
681 > 0 means name must start with the first PREFIX_LENGTH chars of
682 PREFIX and finish with the last SUFFIX_LENGTH chars of PREFIX. */
683 int suffix_length;
684 int type;
685 bfd_vma attr;
686 };
687
688 enum action_discarded
689 {
690 COMPLAIN = 1,
691 PRETEND = 2
692 };
693
694 typedef asection * (*elf_gc_mark_hook_fn)
695 (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
696 struct elf_link_hash_entry *, Elf_Internal_Sym *);
697
698 struct elf_backend_data
699 {
700 /* The architecture for this backend. */
701 enum bfd_architecture arch;
702
703 /* An identifier used to distinguish different target specific
704 extensions to elf_obj_tdata and elf_link_hash_table structures. */
705 enum elf_target_id target_id;
706
707 /* The ELF machine code (EM_xxxx) for this backend. */
708 int elf_machine_code;
709
710 /* EI_OSABI. */
711 int elf_osabi;
712
713 /* The maximum page size for this backend. */
714 bfd_vma maxpagesize;
715
716 /* The minimum page size for this backend. An input object will not be
717 considered page aligned unless its sections are correctly aligned for
718 pages at least this large. May be smaller than maxpagesize. */
719 bfd_vma minpagesize;
720
721 /* The common page size for this backend. */
722 bfd_vma commonpagesize;
723
724 /* The BFD flags applied to sections created for dynamic linking. */
725 flagword dynamic_sec_flags;
726
727 /* Architecture-specific data for this backend.
728 This is actually a pointer to some type like struct elf_ARCH_data. */
729 const void *arch_data;
730
731 /* A function to translate an ELF RELA relocation to a BFD arelent
732 structure. */
733 void (*elf_info_to_howto)
734 (bfd *, arelent *, Elf_Internal_Rela *);
735
736 /* A function to translate an ELF REL relocation to a BFD arelent
737 structure. */
738 void (*elf_info_to_howto_rel)
739 (bfd *, arelent *, Elf_Internal_Rela *);
740
741 /* A function to determine whether a symbol is global when
742 partitioning the symbol table into local and global symbols.
743 This should be NULL for most targets, in which case the correct
744 thing will be done. MIPS ELF, at least on the Irix 5, has
745 special requirements. */
746 bfd_boolean (*elf_backend_sym_is_global)
747 (bfd *, asymbol *);
748
749 /* The remaining functions are hooks which are called only if they
750 are not NULL. */
751
752 /* A function to permit a backend specific check on whether a
753 particular BFD format is relevant for an object file, and to
754 permit the backend to set any global information it wishes. When
755 this is called elf_elfheader is set, but anything else should be
756 used with caution. If this returns FALSE, the check_format
757 routine will return a bfd_error_wrong_format error. */
758 bfd_boolean (*elf_backend_object_p)
759 (bfd *);
760
761 /* A function to do additional symbol processing when reading the
762 ELF symbol table. This is where any processor-specific special
763 section indices are handled. */
764 void (*elf_backend_symbol_processing)
765 (bfd *, asymbol *);
766
767 /* A function to do additional symbol processing after reading the
768 entire ELF symbol table. */
769 bfd_boolean (*elf_backend_symbol_table_processing)
770 (bfd *, elf_symbol_type *, unsigned int);
771
772 /* A function to set the type of the info field. Processor-specific
773 types should be handled here. */
774 int (*elf_backend_get_symbol_type)
775 (Elf_Internal_Sym *, int);
776
777 /* A function to return the linker hash table entry of a symbol that
778 might be satisfied by an archive symbol. */
779 struct elf_link_hash_entry * (*elf_backend_archive_symbol_lookup)
780 (bfd *, struct bfd_link_info *, const char *);
781
782 /* Return true if local section symbols should have a non-null st_name.
783 NULL implies false. */
784 bfd_boolean (*elf_backend_name_local_section_symbols)
785 (bfd *);
786
787 /* A function to do additional processing on the ELF section header
788 just before writing it out. This is used to set the flags and
789 type fields for some sections, or to actually write out data for
790 unusual sections. */
791 bfd_boolean (*elf_backend_section_processing)
792 (bfd *, Elf_Internal_Shdr *);
793
794 /* A function to handle unusual section types when creating BFD
795 sections from ELF sections. */
796 bfd_boolean (*elf_backend_section_from_shdr)
797 (bfd *, Elf_Internal_Shdr *, const char *, int);
798
799 /* A function to convert machine dependent ELF section header flags to
800 BFD internal section header flags. */
801 bfd_boolean (*elf_backend_section_flags)
802 (flagword *, const Elf_Internal_Shdr *);
803
804 /* A function that returns a struct containing ELF section flags and
805 type for the given BFD section. */
806 const struct bfd_elf_special_section * (*get_sec_type_attr)
807 (bfd *, asection *);
808
809 /* A function to handle unusual program segment types when creating BFD
810 sections from ELF program segments. */
811 bfd_boolean (*elf_backend_section_from_phdr)
812 (bfd *, Elf_Internal_Phdr *, int, const char *);
813
814 /* A function to set up the ELF section header for a BFD section in
815 preparation for writing it out. This is where the flags and type
816 fields are set for unusual sections. */
817 bfd_boolean (*elf_backend_fake_sections)
818 (bfd *, Elf_Internal_Shdr *, asection *);
819
820 /* A function to get the ELF section index for a BFD section. If
821 this returns TRUE, the section was found. If it is a normal ELF
822 section, *RETVAL should be left unchanged. If it is not a normal
823 ELF section *RETVAL should be set to the SHN_xxxx index. */
824 bfd_boolean (*elf_backend_section_from_bfd_section)
825 (bfd *, asection *, int *retval);
826
827 /* If this field is not NULL, it is called by the add_symbols phase
828 of a link just before adding a symbol to the global linker hash
829 table. It may modify any of the fields as it wishes. If *NAME
830 is set to NULL, the symbol will be skipped rather than being
831 added to the hash table. This function is responsible for
832 handling all processor dependent symbol bindings and section
833 indices, and must set at least *FLAGS and *SEC for each processor
834 dependent case; failure to do so will cause a link error. */
835 bfd_boolean (*elf_add_symbol_hook)
836 (bfd *abfd, struct bfd_link_info *info, Elf_Internal_Sym *,
837 const char **name, flagword *flags, asection **sec, bfd_vma *value);
838
839 /* If this field is not NULL, it is called by the elf_link_output_sym
840 phase of a link for each symbol which will appear in the object file.
841 On error, this function returns 0. 1 is returned when the symbol
842 should be output, 2 is returned when the symbol should be discarded. */
843 int (*elf_backend_link_output_symbol_hook)
844 (struct bfd_link_info *info, const char *, Elf_Internal_Sym *,
845 asection *, struct elf_link_hash_entry *);
846
847 /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend
848 linker the first time it encounters a dynamic object in the link.
849 This function must create any sections required for dynamic
850 linking. The ABFD argument is a dynamic object. The .interp,
851 .dynamic, .dynsym, .dynstr, and .hash functions have already been
852 created, and this function may modify the section flags if
853 desired. This function will normally create the .got and .plt
854 sections, but different backends have different requirements. */
855 bfd_boolean (*elf_backend_create_dynamic_sections)
856 (bfd *abfd, struct bfd_link_info *info);
857
858 /* When creating a shared library, determine whether to omit the
859 dynamic symbol for the section. */
860 bfd_boolean (*elf_backend_omit_section_dynsym)
861 (bfd *output_bfd, struct bfd_link_info *info, asection *osec);
862
863 /* Return TRUE if relocations of targets are compatible to the extent
864 that CHECK_RELOCS will properly process them. PR 4424. */
865 bfd_boolean (*relocs_compatible) (const bfd_target *, const bfd_target *);
866
867 /* The CHECK_RELOCS function is called by the add_symbols phase of
868 the ELF backend linker. It is called once for each section with
869 relocs of an object file, just after the symbols for the object
870 file have been added to the global linker hash table. The
871 function must look through the relocs and do any special handling
872 required. This generally means allocating space in the global
873 offset table, and perhaps allocating space for a reloc. The
874 relocs are always passed as Rela structures; if the section
875 actually uses Rel structures, the r_addend field will always be
876 zero. */
877 bfd_boolean (*check_relocs)
878 (bfd *abfd, struct bfd_link_info *info, asection *o,
879 const Elf_Internal_Rela *relocs);
880
881 /* The CHECK_DIRECTIVES function is called once per input file by
882 the add_symbols phase of the ELF backend linker. The function
883 must inspect the bfd and create any additional symbols according
884 to any custom directives in the bfd. */
885 bfd_boolean (*check_directives)
886 (bfd *abfd, struct bfd_link_info *info);
887
888 /* The NOTICE_AS_NEEDED function is called as the linker is about to
889 handle an as-needed lib (ACT = notice_as_needed), and after the
890 linker has decided to keep the lib (ACT = notice_needed) or when
891 the lib is not needed (ACT = notice_not_needed). */
892 bfd_boolean (*notice_as_needed)
893 (bfd *abfd, struct bfd_link_info *info, enum notice_asneeded_action act);
894
895 /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend
896 linker for every symbol which is defined by a dynamic object and
897 referenced by a regular object. This is called after all the
898 input files have been seen, but before the SIZE_DYNAMIC_SECTIONS
899 function has been called. The hash table entry should be
900 bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be
901 defined in a section from a dynamic object. Dynamic object
902 sections are not included in the final link, and this function is
903 responsible for changing the value to something which the rest of
904 the link can deal with. This will normally involve adding an
905 entry to the .plt or .got or some such section, and setting the
906 symbol to point to that. */
907 bfd_boolean (*elf_backend_adjust_dynamic_symbol)
908 (struct bfd_link_info *info, struct elf_link_hash_entry *h);
909
910 /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker
911 after all the linker input files have been seen but before the
912 section sizes have been set. This is called after
913 ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS. */
914 bfd_boolean (*elf_backend_always_size_sections)
915 (bfd *output_bfd, struct bfd_link_info *info);
916
917 /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend
918 linker after all the linker input files have been seen but before
919 the sections sizes have been set. This is called after
920 ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols.
921 It is only called when linking against a dynamic object. It must
922 set the sizes of the dynamic sections, and may fill in their
923 contents as well. The generic ELF linker can handle the .dynsym,
924 .dynstr and .hash sections. This function must handle the
925 .interp section and any sections created by the
926 CREATE_DYNAMIC_SECTIONS entry point. */
927 bfd_boolean (*elf_backend_size_dynamic_sections)
928 (bfd *output_bfd, struct bfd_link_info *info);
929
930 /* Set TEXT_INDEX_SECTION and DATA_INDEX_SECTION, the output sections
931 we keep to use as a base for relocs and symbols. */
932 void (*elf_backend_init_index_section)
933 (bfd *output_bfd, struct bfd_link_info *info);
934
935 /* The RELOCATE_SECTION function is called by the ELF backend linker
936 to handle the relocations for a section.
937
938 The relocs are always passed as Rela structures; if the section
939 actually uses Rel structures, the r_addend field will always be
940 zero.
941
942 This function is responsible for adjust the section contents as
943 necessary, and (if using Rela relocs and generating a
944 relocatable output file) adjusting the reloc addend as
945 necessary.
946
947 This function does not have to worry about setting the reloc
948 address or the reloc symbol index.
949
950 LOCAL_SYMS is a pointer to the swapped in local symbols.
951
952 LOCAL_SECTIONS is an array giving the section in the input file
953 corresponding to the st_shndx field of each local symbol.
954
955 The global hash table entry for the global symbols can be found
956 via elf_sym_hashes (input_bfd).
957
958 When generating relocatable output, this function must handle
959 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
960 going to be the section symbol corresponding to the output
961 section, which means that the addend must be adjusted
962 accordingly.
963
964 Returns FALSE on error, TRUE on success, 2 if successful and
965 relocations should be written for this section. */
966 int (*elf_backend_relocate_section)
967 (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
968 asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs,
969 Elf_Internal_Sym *local_syms, asection **local_sections);
970
971 /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend
972 linker just before it writes a symbol out to the .dynsym section.
973 The processor backend may make any required adjustment to the
974 symbol. It may also take the opportunity to set contents of the
975 dynamic sections. Note that FINISH_DYNAMIC_SYMBOL is called on
976 all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called
977 on those symbols which are defined by a dynamic object. */
978 bfd_boolean (*elf_backend_finish_dynamic_symbol)
979 (bfd *output_bfd, struct bfd_link_info *info,
980 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym);
981
982 /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend
983 linker just before it writes all the dynamic sections out to the
984 output file. The FINISH_DYNAMIC_SYMBOL will have been called on
985 all dynamic symbols. */
986 bfd_boolean (*elf_backend_finish_dynamic_sections)
987 (bfd *output_bfd, struct bfd_link_info *info);
988
989 /* A function to do any beginning processing needed for the ELF file
990 before building the ELF headers and computing file positions. */
991 void (*elf_backend_begin_write_processing)
992 (bfd *, struct bfd_link_info *);
993
994 /* A function to do any final processing needed for the ELF file
995 before writing it out. The LINKER argument is TRUE if this BFD
996 was created by the ELF backend linker. */
997 void (*elf_backend_final_write_processing)
998 (bfd *, bfd_boolean linker);
999
1000 /* This function is called by get_program_header_size. It should
1001 return the number of additional program segments which this BFD
1002 will need. It should return -1 on error. */
1003 int (*elf_backend_additional_program_headers)
1004 (bfd *, struct bfd_link_info *);
1005
1006 /* This function is called to modify an existing segment map in a
1007 backend specific fashion. */
1008 bfd_boolean (*elf_backend_modify_segment_map)
1009 (bfd *, struct bfd_link_info *);
1010
1011 /* This function is called to modify program headers just before
1012 they are written. */
1013 bfd_boolean (*elf_backend_modify_program_headers)
1014 (bfd *, struct bfd_link_info *);
1015
1016 /* This function is called before section garbage collection to
1017 mark entry symbol sections. */
1018 void (*gc_keep)
1019 (struct bfd_link_info *);
1020
1021 /* This function is called during section garbage collection to
1022 mark sections that define global symbols. */
1023 bfd_boolean (*gc_mark_dynamic_ref)
1024 (struct elf_link_hash_entry *, void *);
1025
1026 /* This function is called during section gc to discover the section a
1027 particular relocation refers to. */
1028 elf_gc_mark_hook_fn gc_mark_hook;
1029
1030 /* This function, if defined, is called after the first gc marking pass
1031 to allow the backend to mark additional sections. */
1032 bfd_boolean (*gc_mark_extra_sections)
1033 (struct bfd_link_info *, elf_gc_mark_hook_fn);
1034
1035 /* This function, if defined, is called during the sweep phase of gc
1036 in order that a backend might update any data structures it might
1037 be maintaining. */
1038 bfd_boolean (*gc_sweep_hook)
1039 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
1040
1041 /* This function, if defined, is called after the ELF headers have
1042 been created. This allows for things like the OS and ABI versions
1043 to be changed. */
1044 void (*elf_backend_post_process_headers)
1045 (bfd *, struct bfd_link_info *);
1046
1047 /* This function, if defined, prints a symbol to file and returns the
1048 name of the symbol to be printed. It should return NULL to fall
1049 back to default symbol printing. */
1050 const char *(*elf_backend_print_symbol_all)
1051 (bfd *, void *, asymbol *);
1052
1053 /* This function, if defined, is called after all local symbols and
1054 global symbols converted to locals are emitted into the symtab
1055 section. It allows the backend to emit special local symbols
1056 not handled in the hash table. */
1057 bfd_boolean (*elf_backend_output_arch_local_syms)
1058 (bfd *, struct bfd_link_info *, void *,
1059 bfd_boolean (*) (void *, const char *, Elf_Internal_Sym *, asection *,
1060 struct elf_link_hash_entry *));
1061
1062 /* This function, if defined, is called after all symbols are emitted
1063 into the symtab section. It allows the backend to emit special
1064 global symbols not handled in the hash table. */
1065 bfd_boolean (*elf_backend_output_arch_syms)
1066 (bfd *, struct bfd_link_info *, void *,
1067 bfd_boolean (*) (void *, const char *, Elf_Internal_Sym *, asection *,
1068 struct elf_link_hash_entry *));
1069
1070 /* Copy any information related to dynamic linking from a pre-existing
1071 symbol to a newly created symbol. Also called to copy flags and
1072 other back-end info to a weakdef, in which case the symbol is not
1073 newly created and plt/got refcounts and dynamic indices should not
1074 be copied. */
1075 void (*elf_backend_copy_indirect_symbol)
1076 (struct bfd_link_info *, struct elf_link_hash_entry *,
1077 struct elf_link_hash_entry *);
1078
1079 /* Modify any information related to dynamic linking such that the
1080 symbol is not exported. */
1081 void (*elf_backend_hide_symbol)
1082 (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
1083
1084 /* A function to do additional symbol fixup, called by
1085 _bfd_elf_fix_symbol_flags. */
1086 bfd_boolean (*elf_backend_fixup_symbol)
1087 (struct bfd_link_info *, struct elf_link_hash_entry *);
1088
1089 /* Merge the backend specific symbol attribute. */
1090 void (*elf_backend_merge_symbol_attribute)
1091 (struct elf_link_hash_entry *, const Elf_Internal_Sym *, bfd_boolean,
1092 bfd_boolean);
1093
1094 /* This function, if defined, will return a string containing the
1095 name of a target-specific dynamic tag. */
1096 char *(*elf_backend_get_target_dtag)
1097 (bfd_vma);
1098
1099 /* Decide whether an undefined symbol is special and can be ignored.
1100 This is the case for OPTIONAL symbols on IRIX. */
1101 bfd_boolean (*elf_backend_ignore_undef_symbol)
1102 (struct elf_link_hash_entry *);
1103
1104 /* Emit relocations. Overrides default routine for emitting relocs,
1105 except during a relocatable link, or if all relocs are being emitted. */
1106 bfd_boolean (*elf_backend_emit_relocs)
1107 (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *,
1108 struct elf_link_hash_entry **);
1109
1110 /* Count relocations. Not called for relocatable links
1111 or if all relocs are being preserved in the output. */
1112 unsigned int (*elf_backend_count_relocs)
1113 (struct bfd_link_info *, asection *);
1114
1115 /* Say whether to sort relocs output by ld -r and ld --emit-relocs,
1116 by r_offset. If NULL, default to true. */
1117 bfd_boolean (*sort_relocs_p)
1118 (asection *);
1119
1120 /* This function, if defined, is called when an NT_PRSTATUS note is found
1121 in a core file. */
1122 bfd_boolean (*elf_backend_grok_prstatus)
1123 (bfd *, Elf_Internal_Note *);
1124
1125 /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO
1126 note is found in a core file. */
1127 bfd_boolean (*elf_backend_grok_psinfo)
1128 (bfd *, Elf_Internal_Note *);
1129
1130 /* This function, if defined, is called to write a note to a corefile. */
1131 char *(*elf_backend_write_core_note)
1132 (bfd *abfd, char *buf, int *bufsiz, int note_type, ...);
1133
1134 /* This function, if defined, is called to convert target-specific
1135 section flag names into hex values. */
1136 flagword (*elf_backend_lookup_section_flags_hook)
1137 (char *);
1138
1139 /* This function returns class of a reloc type. */
1140 enum elf_reloc_type_class (*elf_backend_reloc_type_class)
1141 (const struct bfd_link_info *, const asection *, const Elf_Internal_Rela *);
1142
1143 /* This function, if defined, removes information about discarded functions
1144 from other sections which mention them. */
1145 bfd_boolean (*elf_backend_discard_info)
1146 (bfd *, struct elf_reloc_cookie *, struct bfd_link_info *);
1147
1148 /* This function, if defined, signals that the function above has removed
1149 the discarded relocations for this section. */
1150 bfd_boolean (*elf_backend_ignore_discarded_relocs)
1151 (asection *);
1152
1153 /* What to do when ld finds relocations against symbols defined in
1154 discarded sections. */
1155 unsigned int (*action_discarded)
1156 (asection *);
1157
1158 /* This function returns the width of FDE pointers in bytes, or 0 if
1159 that can't be determined for some reason. The default definition
1160 goes by the bfd's EI_CLASS. */
1161 unsigned int (*elf_backend_eh_frame_address_size)
1162 (bfd *, asection *);
1163
1164 /* These functions tell elf-eh-frame whether to attempt to turn
1165 absolute or lsda encodings into pc-relative ones. The default
1166 definition enables these transformations. */
1167 bfd_boolean (*elf_backend_can_make_relative_eh_frame)
1168 (bfd *, struct bfd_link_info *, asection *);
1169 bfd_boolean (*elf_backend_can_make_lsda_relative_eh_frame)
1170 (bfd *, struct bfd_link_info *, asection *);
1171
1172 /* This function returns an encoding after computing the encoded
1173 value (and storing it in ENCODED) for the given OFFSET into OSEC,
1174 to be stored in at LOC_OFFSET into the LOC_SEC input section.
1175 The default definition chooses a 32-bit PC-relative encoding. */
1176 bfd_byte (*elf_backend_encode_eh_address)
1177 (bfd *abfd, struct bfd_link_info *info,
1178 asection *osec, bfd_vma offset,
1179 asection *loc_sec, bfd_vma loc_offset,
1180 bfd_vma *encoded);
1181
1182 /* This function, if defined, may write out the given section.
1183 Returns TRUE if it did so and FALSE if the caller should. */
1184 bfd_boolean (*elf_backend_write_section)
1185 (bfd *, struct bfd_link_info *, asection *, bfd_byte *);
1186
1187 /* The level of IRIX compatibility we're striving for.
1188 MIPS ELF specific function. */
1189 irix_compat_t (*elf_backend_mips_irix_compat)
1190 (bfd *);
1191
1192 reloc_howto_type *(*elf_backend_mips_rtype_to_howto)
1193 (unsigned int, bfd_boolean);
1194
1195 /* The swapping table to use when dealing with ECOFF information.
1196 Used for the MIPS ELF .mdebug section. */
1197 const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap;
1198
1199 /* This function implements `bfd_elf_bfd_from_remote_memory';
1200 see elf.c, elfcode.h. */
1201 bfd *(*elf_backend_bfd_from_remote_memory)
1202 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep,
1203 int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr,
1204 bfd_size_type len));
1205
1206 /* This function is used by `_bfd_elf_get_synthetic_symtab';
1207 see elf.c. */
1208 bfd_vma (*plt_sym_val) (bfd_vma, const asection *, const arelent *);
1209
1210 /* Is symbol defined in common section? */
1211 bfd_boolean (*common_definition) (Elf_Internal_Sym *);
1212
1213 /* Return a common section index for section. */
1214 unsigned int (*common_section_index) (asection *);
1215
1216 /* Return a common section for section. */
1217 asection *(*common_section) (asection *);
1218
1219 /* Return TRUE if we can merge 2 definitions. */
1220 bfd_boolean (*merge_symbol) (struct elf_link_hash_entry *,
1221 const Elf_Internal_Sym *, asection **,
1222 bfd_boolean, bfd_boolean,
1223 bfd *, const asection *);
1224
1225 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
1226 bfd_boolean (*elf_hash_symbol) (struct elf_link_hash_entry *);
1227
1228 /* Return TRUE if type is a function symbol type. */
1229 bfd_boolean (*is_function_type) (unsigned int type);
1230
1231 /* If the ELF symbol SYM might be a function in SEC, return the
1232 function size and set *CODE_OFF to the function's entry point,
1233 otherwise return zero. */
1234 bfd_size_type (*maybe_function_sym) (const asymbol *sym, asection *sec,
1235 bfd_vma *code_off);
1236
1237 /* Used to handle bad SHF_LINK_ORDER input. */
1238 bfd_error_handler_type link_order_error_handler;
1239
1240 /* Name of the PLT relocation section. */
1241 const char *relplt_name;
1242
1243 /* Alternate EM_xxxx machine codes for this backend. */
1244 int elf_machine_alt1;
1245 int elf_machine_alt2;
1246
1247 const struct elf_size_info *s;
1248
1249 /* An array of target specific special sections. */
1250 const struct bfd_elf_special_section *special_sections;
1251
1252 /* The size in bytes of the header for the GOT. This includes the
1253 so-called reserved entries on some systems. */
1254 bfd_vma got_header_size;
1255
1256 /* The size of the GOT entry for the symbol pointed to by H if non-NULL,
1257 otherwise by the local symbol with index SYMNDX in IBFD. */
1258 bfd_vma (*got_elt_size) (bfd *, struct bfd_link_info *,
1259 struct elf_link_hash_entry *h,
1260 bfd *ibfd, unsigned long symndx);
1261
1262 /* The vendor name to use for a processor-standard attributes section. */
1263 const char *obj_attrs_vendor;
1264
1265 /* The section name to use for a processor-standard attributes section. */
1266 const char *obj_attrs_section;
1267
1268 /* Return 1, 2 or 3 to indicate what type of arguments a
1269 processor-specific tag takes. */
1270 int (*obj_attrs_arg_type) (int);
1271
1272 /* The section type to use for an attributes section. */
1273 unsigned int obj_attrs_section_type;
1274
1275 /* This function determines the order in which any attributes are
1276 written. It must be defined for input in the range
1277 LEAST_KNOWN_OBJ_ATTRIBUTE..NUM_KNOWN_OBJ_ATTRIBUTES-1 (this range
1278 is used in order to make unity easy). The returned value is the
1279 actual tag number to place in the input position. */
1280 int (*obj_attrs_order) (int);
1281
1282 /* Handle merging unknown attributes; either warn and return TRUE,
1283 or give an error and return FALSE. */
1284 bfd_boolean (*obj_attrs_handle_unknown) (bfd *, int);
1285
1286 /* This is non-zero if static TLS segments require a special alignment. */
1287 unsigned static_tls_alignment;
1288
1289 /* Alignment for the PT_GNU_STACK segment. */
1290 unsigned stack_align;
1291
1292 /* This is TRUE if the linker should act like collect and gather
1293 global constructors and destructors by name. This is TRUE for
1294 MIPS ELF because the Irix 5 tools can not handle the .init
1295 section. */
1296 unsigned collect : 1;
1297
1298 /* This is TRUE if the linker should ignore changes to the type of a
1299 symbol. This is TRUE for MIPS ELF because some Irix 5 objects
1300 record undefined functions as STT_OBJECT although the definitions
1301 are STT_FUNC. */
1302 unsigned type_change_ok : 1;
1303
1304 /* Whether the backend may use REL relocations. (Some backends use
1305 both REL and RELA relocations, and this flag is set for those
1306 backends.) */
1307 unsigned may_use_rel_p : 1;
1308
1309 /* Whether the backend may use RELA relocations. (Some backends use
1310 both REL and RELA relocations, and this flag is set for those
1311 backends.) */
1312 unsigned may_use_rela_p : 1;
1313
1314 /* Whether the default relocation type is RELA. If a backend with
1315 this flag set wants REL relocations for a particular section,
1316 it must note that explicitly. Similarly, if this flag is clear,
1317 and the backend wants RELA relocations for a particular
1318 section. */
1319 unsigned default_use_rela_p : 1;
1320
1321 /* True if PLT and copy relocations should be RELA by default. */
1322 unsigned rela_plts_and_copies_p : 1;
1323
1324 /* Set if RELA relocations for a relocatable link can be handled by
1325 generic code. Backends that set this flag need do nothing in the
1326 backend relocate_section routine for relocatable linking. */
1327 unsigned rela_normal : 1;
1328
1329 /* TRUE if addresses "naturally" sign extend. This is used when
1330 swapping in from Elf32 when BFD64. */
1331 unsigned sign_extend_vma : 1;
1332
1333 unsigned want_got_plt : 1;
1334 unsigned plt_readonly : 1;
1335 unsigned want_plt_sym : 1;
1336 unsigned plt_not_loaded : 1;
1337 unsigned plt_alignment : 4;
1338 unsigned can_gc_sections : 1;
1339 unsigned can_refcount : 1;
1340 unsigned want_got_sym : 1;
1341 unsigned want_dynbss : 1;
1342
1343 /* Targets which do not support physical addressing often require
1344 that the p_paddr field in the section header to be set to zero.
1345 This field indicates whether this behavior is required. */
1346 unsigned want_p_paddr_set_to_zero : 1;
1347
1348 /* True if an object file lacking a .note.GNU-stack section
1349 should be assumed to be requesting exec stack. At least one
1350 other file in the link needs to have a .note.GNU-stack section
1351 for a PT_GNU_STACK segment to be created. */
1352 unsigned default_execstack : 1;
1353
1354 /* True if elf_section_data(sec)->this_hdr.contents is sec->rawsize
1355 in length rather than sec->size in length, if sec->rawsize is
1356 non-zero and smaller than sec->size. */
1357 unsigned caches_rawsize : 1;
1358 };
1359
1360 /* Information about reloc sections associated with a bfd_elf_section_data
1361 structure. */
1362 struct bfd_elf_section_reloc_data
1363 {
1364 /* The ELF header for the reloc section associated with this
1365 section, if any. */
1366 Elf_Internal_Shdr *hdr;
1367 /* The number of relocations currently assigned to HDR. */
1368 unsigned int count;
1369 /* The ELF section number of the reloc section. Only used for an
1370 output file. */
1371 int idx;
1372 /* Used by the backend linker to store the symbol hash table entries
1373 associated with relocs against global symbols. */
1374 struct elf_link_hash_entry **hashes;
1375 };
1376
1377 /* Information stored for each BFD section in an ELF file. This
1378 structure is allocated by elf_new_section_hook. */
1379
1380 struct bfd_elf_section_data
1381 {
1382 /* The ELF header for this section. */
1383 Elf_Internal_Shdr this_hdr;
1384
1385 /* INPUT_SECTION_FLAGS if specified in the linker script. */
1386 struct flag_info *section_flag_info;
1387
1388 /* Information about the REL and RELA reloc sections associated
1389 with this section, if any. */
1390 struct bfd_elf_section_reloc_data rel, rela;
1391
1392 /* The ELF section number of this section. */
1393 int this_idx;
1394
1395 /* Used by the backend linker when generating a shared library to
1396 record the dynamic symbol index for a section symbol
1397 corresponding to this section. A value of 0 means that there is
1398 no dynamic symbol for this section. */
1399 int dynindx;
1400
1401 /* A pointer to the linked-to section for SHF_LINK_ORDER. */
1402 asection *linked_to;
1403
1404 /* A pointer to the swapped relocs. If the section uses REL relocs,
1405 rather than RELA, all the r_addend fields will be zero. This
1406 pointer may be NULL. It is used by the backend linker. */
1407 Elf_Internal_Rela *relocs;
1408
1409 /* A pointer to a linked list tracking dynamic relocs copied for
1410 local symbols. */
1411 void *local_dynrel;
1412
1413 /* A pointer to the bfd section used for dynamic relocs. */
1414 asection *sreloc;
1415
1416 union {
1417 /* Group name, if this section is a member of a group. */
1418 const char *name;
1419
1420 /* Group signature sym, if this is the SHT_GROUP section. */
1421 struct bfd_symbol *id;
1422 } group;
1423
1424 /* For a member of a group, points to the SHT_GROUP section.
1425 NULL for the SHT_GROUP section itself and non-group sections. */
1426 asection *sec_group;
1427
1428 /* A linked list of member sections in the group. Circular when used by
1429 the linker. For the SHT_GROUP section, points at first member. */
1430 asection *next_in_group;
1431
1432 /* The FDEs associated with this section. The u.fde.next_in_section
1433 field acts as a chain pointer. */
1434 struct eh_cie_fde *fde_list;
1435
1436 /* A pointer used for various section optimizations. */
1437 void *sec_info;
1438 };
1439
1440 #define elf_section_data(sec) ((struct bfd_elf_section_data*)(sec)->used_by_bfd)
1441 #define elf_linked_to_section(sec) (elf_section_data(sec)->linked_to)
1442 #define elf_section_type(sec) (elf_section_data(sec)->this_hdr.sh_type)
1443 #define elf_section_flags(sec) (elf_section_data(sec)->this_hdr.sh_flags)
1444 #define elf_group_name(sec) (elf_section_data(sec)->group.name)
1445 #define elf_group_id(sec) (elf_section_data(sec)->group.id)
1446 #define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group)
1447 #define elf_fde_list(sec) (elf_section_data(sec)->fde_list)
1448 #define elf_sec_group(sec) (elf_section_data(sec)->sec_group)
1449
1450 #define xvec_get_elf_backend_data(xvec) \
1451 ((const struct elf_backend_data *) (xvec)->backend_data)
1452
1453 #define get_elf_backend_data(abfd) \
1454 xvec_get_elf_backend_data ((abfd)->xvec)
1455
1456 /* The least object attributes (within an attributes subsection) known
1457 for any target. Some code assumes that the value 0 is not used and
1458 the field for that attribute can instead be used as a marker to
1459 indicate that attributes have been initialized. */
1460 #define LEAST_KNOWN_OBJ_ATTRIBUTE 2
1461
1462 /* The maximum number of known object attributes for any target. */
1463 #define NUM_KNOWN_OBJ_ATTRIBUTES 71
1464
1465 /* The value of an object attribute. The type indicates whether the attribute
1466 holds and integer, a string, or both. It can also indicate that there can
1467 be no default (i.e. all values must be written to file, even zero). */
1468
1469 typedef struct obj_attribute
1470 {
1471 #define ATTR_TYPE_FLAG_INT_VAL (1 << 0)
1472 #define ATTR_TYPE_FLAG_STR_VAL (1 << 1)
1473 #define ATTR_TYPE_FLAG_NO_DEFAULT (1 << 2)
1474
1475 #define ATTR_TYPE_HAS_INT_VAL(TYPE) ((TYPE) & ATTR_TYPE_FLAG_INT_VAL)
1476 #define ATTR_TYPE_HAS_STR_VAL(TYPE) ((TYPE) & ATTR_TYPE_FLAG_STR_VAL)
1477 #define ATTR_TYPE_HAS_NO_DEFAULT(TYPE) ((TYPE) & ATTR_TYPE_FLAG_NO_DEFAULT)
1478
1479 int type;
1480 unsigned int i;
1481 char *s;
1482 } obj_attribute;
1483
1484 typedef struct obj_attribute_list
1485 {
1486 struct obj_attribute_list *next;
1487 int tag;
1488 obj_attribute attr;
1489 } obj_attribute_list;
1490
1491 /* Object attributes may either be defined by the processor ABI, index
1492 OBJ_ATTR_PROC in the *_obj_attributes arrays, or be GNU-specific
1493 (and possibly also processor-specific), index OBJ_ATTR_GNU. */
1494 #define OBJ_ATTR_PROC 0
1495 #define OBJ_ATTR_GNU 1
1496 #define OBJ_ATTR_FIRST OBJ_ATTR_PROC
1497 #define OBJ_ATTR_LAST OBJ_ATTR_GNU
1498
1499 /* The following object attribute tags are taken as generic, for all
1500 targets and for "gnu" where there is no target standard. */
1501 enum
1502 {
1503 Tag_NULL = 0,
1504 Tag_File = 1,
1505 Tag_Section = 2,
1506 Tag_Symbol = 3,
1507 Tag_compatibility = 32
1508 };
1509
1510 /* The following struct stores information about every SystemTap section
1511 found in the object file. */
1512 struct sdt_note
1513 {
1514 struct sdt_note *next;
1515 bfd_size_type size;
1516 bfd_byte data[1];
1517 };
1518
1519 /* NT_GNU_BUILD_ID note type info for input BFDs. */
1520 struct elf_build_id
1521 {
1522 size_t size;
1523 bfd_byte data[1];
1524 };
1525
1526 /* tdata information grabbed from an elf core file. */
1527 struct core_elf_obj_tdata
1528 {
1529 int signal;
1530 int pid;
1531 int lwpid;
1532 char* program;
1533 char* command;
1534 };
1535
1536 /* Extra tdata information held for output ELF BFDs. */
1537 struct output_elf_obj_tdata
1538 {
1539 struct elf_segment_map *seg_map;
1540 struct elf_strtab_hash *strtab_ptr;
1541
1542 /* STT_SECTION symbols for each section */
1543 asymbol **section_syms;
1544
1545 /* Used to determine if PT_GNU_EH_FRAME segment header should be
1546 created. */
1547 asection *eh_frame_hdr;
1548
1549 /* NT_GNU_BUILD_ID note type info. */
1550 struct
1551 {
1552 bfd_boolean (*after_write_object_contents) (bfd *);
1553 const char *style;
1554 asection *sec;
1555 } build_id;
1556
1557 /* Records the result of `get_program_header_size'. */
1558 bfd_size_type program_header_size;
1559
1560 /* Used when laying out sections. */
1561 file_ptr next_file_pos;
1562
1563 int num_section_syms;
1564 unsigned int shstrtab_section, strtab_section;
1565
1566 /* Segment flags for the PT_GNU_STACK segment. */
1567 unsigned int stack_flags;
1568
1569 /* This is set to TRUE if the object was created by the backend
1570 linker. */
1571 bfd_boolean linker;
1572
1573 /* Used to determine if the e_flags field has been initialized */
1574 bfd_boolean flags_init;
1575 };
1576
1577 /* Some private data is stashed away for future use using the tdata pointer
1578 in the bfd structure. */
1579
1580 struct elf_obj_tdata
1581 {
1582 Elf_Internal_Ehdr elf_header[1]; /* Actual data, but ref like ptr */
1583 Elf_Internal_Shdr **elf_sect_ptr;
1584 Elf_Internal_Phdr *phdr;
1585 Elf_Internal_Shdr symtab_hdr;
1586 Elf_Internal_Shdr shstrtab_hdr;
1587 Elf_Internal_Shdr strtab_hdr;
1588 Elf_Internal_Shdr dynsymtab_hdr;
1589 Elf_Internal_Shdr dynstrtab_hdr;
1590 Elf_Internal_Shdr dynversym_hdr;
1591 Elf_Internal_Shdr dynverref_hdr;
1592 Elf_Internal_Shdr dynverdef_hdr;
1593 Elf_Internal_Shdr symtab_shndx_hdr;
1594 bfd_vma gp; /* The gp value */
1595 unsigned int gp_size; /* The gp size */
1596 unsigned int num_elf_sections; /* elf_sect_ptr size */
1597
1598 /* A mapping from external symbols to entries in the linker hash
1599 table, used when linking. This is indexed by the symbol index
1600 minus the sh_info field of the symbol table header. */
1601 struct elf_link_hash_entry **sym_hashes;
1602
1603 /* Track usage and final offsets of GOT entries for local symbols.
1604 This array is indexed by symbol index. Elements are used
1605 identically to "got" in struct elf_link_hash_entry. */
1606 union
1607 {
1608 bfd_signed_vma *refcounts;
1609 bfd_vma *offsets;
1610 struct got_entry **ents;
1611 } local_got;
1612
1613 /* The linker ELF emulation code needs to let the backend ELF linker
1614 know what filename should be used for a dynamic object if the
1615 dynamic object is found using a search. The emulation code then
1616 sometimes needs to know what name was actually used. Until the
1617 file has been added to the linker symbol table, this field holds
1618 the name the linker wants. After it has been added, it holds the
1619 name actually used, which will be the DT_SONAME entry if there is
1620 one. */
1621 const char *dt_name;
1622
1623 /* The linker emulation needs to know what audit libs
1624 are used by a dynamic object. */
1625 const char *dt_audit;
1626
1627 /* Used by find_nearest_line entry point. */
1628 void *line_info;
1629
1630 /* A place to stash dwarf1 info for this bfd. */
1631 struct dwarf1_debug *dwarf1_find_line_info;
1632
1633 /* A place to stash dwarf2 info for this bfd. */
1634 void *dwarf2_find_line_info;
1635
1636 /* Stash away info for yet another find line/function variant. */
1637 void *elf_find_function_cache;
1638
1639 /* Number of symbol version definitions we are about to emit. */
1640 unsigned int cverdefs;
1641
1642 /* Number of symbol version references we are about to emit. */
1643 unsigned int cverrefs;
1644
1645 /* Symbol version definitions in external objects. */
1646 Elf_Internal_Verdef *verdef;
1647
1648 /* Symbol version references to external objects. */
1649 Elf_Internal_Verneed *verref;
1650
1651 /* A pointer to the .eh_frame section. */
1652 asection *eh_frame_section;
1653
1654 /* Symbol buffer. */
1655 void *symbuf;
1656
1657 obj_attribute known_obj_attributes[2][NUM_KNOWN_OBJ_ATTRIBUTES];
1658 obj_attribute_list *other_obj_attributes[2];
1659
1660 /* NT_GNU_BUILD_ID note type. */
1661 struct elf_build_id *build_id;
1662
1663 /* Linked-list containing information about every Systemtap section
1664 found in the object file. Each section corresponds to one entry
1665 in the list. */
1666 struct sdt_note *sdt_note_head;
1667
1668 Elf_Internal_Shdr **group_sect_ptr;
1669 int num_group;
1670
1671 unsigned int symtab_section, symtab_shndx_section, dynsymtab_section;
1672 unsigned int dynversym_section, dynverdef_section, dynverref_section;
1673
1674 /* An identifier used to distinguish different target
1675 specific extensions to this structure. */
1676 enum elf_target_id object_id;
1677
1678 /* Whether a dyanmic object was specified normally on the linker
1679 command line, or was specified when --as-needed was in effect,
1680 or was found via a DT_NEEDED entry. */
1681 enum dynamic_lib_link_class dyn_lib_class;
1682
1683 /* Irix 5 often screws up the symbol table, sorting local symbols
1684 after global symbols. This flag is set if the symbol table in
1685 this BFD appears to be screwed up. If it is, we ignore the
1686 sh_info field in the symbol table header, and always read all the
1687 symbols. */
1688 bfd_boolean bad_symtab;
1689
1690 /* True if the bfd contains symbols that have the STT_GNU_IFUNC
1691 symbol type or STB_GNU_UNIQUE binding. Used to set the osabi
1692 field in the ELF header structure. */
1693 bfd_boolean has_gnu_symbols;
1694
1695 /* Information grabbed from an elf core file. */
1696 struct core_elf_obj_tdata *core;
1697
1698 /* More information held for output ELF BFDs. */
1699 struct output_elf_obj_tdata *o;
1700 };
1701
1702 #define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data)
1703
1704 #define elf_object_id(bfd) (elf_tdata(bfd) -> object_id)
1705 #define elf_program_header_size(bfd) (elf_tdata(bfd) -> o->program_header_size)
1706 #define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header)
1707 #define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr)
1708 #define elf_numsections(bfd) (elf_tdata(bfd) -> num_elf_sections)
1709 #define elf_seg_map(bfd) (elf_tdata(bfd) -> o->seg_map)
1710 #define elf_next_file_pos(bfd) (elf_tdata(bfd) -> o->next_file_pos)
1711 #define elf_eh_frame_hdr(bfd) (elf_tdata(bfd) -> o->eh_frame_hdr)
1712 #define elf_linker(bfd) (elf_tdata(bfd) -> o->linker)
1713 #define elf_stack_flags(bfd) (elf_tdata(bfd) -> o->stack_flags)
1714 #define elf_shstrtab(bfd) (elf_tdata(bfd) -> o->strtab_ptr)
1715 #define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section)
1716 #define elf_symtab_shndx(bfd) (elf_tdata(bfd) -> symtab_shndx_section)
1717 #define elf_strtab_sec(bfd) (elf_tdata(bfd) -> o->strtab_section)
1718 #define elf_shstrtab_sec(bfd) (elf_tdata(bfd) -> o->shstrtab_section)
1719 #define elf_symtab_hdr(bfd) (elf_tdata(bfd) -> symtab_hdr)
1720 #define elf_dynsymtab(bfd) (elf_tdata(bfd) -> dynsymtab_section)
1721 #define elf_dynversym(bfd) (elf_tdata(bfd) -> dynversym_section)
1722 #define elf_dynverdef(bfd) (elf_tdata(bfd) -> dynverdef_section)
1723 #define elf_dynverref(bfd) (elf_tdata(bfd) -> dynverref_section)
1724 #define elf_eh_frame_section(bfd) \
1725 (elf_tdata(bfd) -> eh_frame_section)
1726 #define elf_section_syms(bfd) (elf_tdata(bfd) -> o->section_syms)
1727 #define elf_num_section_syms(bfd) (elf_tdata(bfd) -> o->num_section_syms)
1728 #define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo)
1729 #define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus)
1730 #define elf_gp(bfd) (elf_tdata(bfd) -> gp)
1731 #define elf_gp_size(bfd) (elf_tdata(bfd) -> gp_size)
1732 #define elf_sym_hashes(bfd) (elf_tdata(bfd) -> sym_hashes)
1733 #define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts)
1734 #define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets)
1735 #define elf_local_got_ents(bfd) (elf_tdata(bfd) -> local_got.ents)
1736 #define elf_dt_name(bfd) (elf_tdata(bfd) -> dt_name)
1737 #define elf_dt_audit(bfd) (elf_tdata(bfd) -> dt_audit)
1738 #define elf_dyn_lib_class(bfd) (elf_tdata(bfd) -> dyn_lib_class)
1739 #define elf_bad_symtab(bfd) (elf_tdata(bfd) -> bad_symtab)
1740 #define elf_flags_init(bfd) (elf_tdata(bfd) -> o->flags_init)
1741 #define elf_known_obj_attributes(bfd) (elf_tdata (bfd) -> known_obj_attributes)
1742 #define elf_other_obj_attributes(bfd) (elf_tdata (bfd) -> other_obj_attributes)
1743 #define elf_known_obj_attributes_proc(bfd) \
1744 (elf_known_obj_attributes (bfd) [OBJ_ATTR_PROC])
1745 #define elf_other_obj_attributes_proc(bfd) \
1746 (elf_other_obj_attributes (bfd) [OBJ_ATTR_PROC])
1747 \f
1748 extern void _bfd_elf_swap_verdef_in
1749 (bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *);
1750 extern void _bfd_elf_swap_verdef_out
1751 (bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *);
1752 extern void _bfd_elf_swap_verdaux_in
1753 (bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *);
1754 extern void _bfd_elf_swap_verdaux_out
1755 (bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *);
1756 extern void _bfd_elf_swap_verneed_in
1757 (bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *);
1758 extern void _bfd_elf_swap_verneed_out
1759 (bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *);
1760 extern void _bfd_elf_swap_vernaux_in
1761 (bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *);
1762 extern void _bfd_elf_swap_vernaux_out
1763 (bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *);
1764 extern void _bfd_elf_swap_versym_in
1765 (bfd *, const Elf_External_Versym *, Elf_Internal_Versym *);
1766 extern void _bfd_elf_swap_versym_out
1767 (bfd *, const Elf_Internal_Versym *, Elf_External_Versym *);
1768
1769 extern unsigned int _bfd_elf_section_from_bfd_section
1770 (bfd *, asection *);
1771 extern char *bfd_elf_string_from_elf_section
1772 (bfd *, unsigned, unsigned);
1773 extern Elf_Internal_Sym *bfd_elf_get_elf_syms
1774 (bfd *, Elf_Internal_Shdr *, size_t, size_t, Elf_Internal_Sym *, void *,
1775 Elf_External_Sym_Shndx *);
1776 extern const char *bfd_elf_sym_name
1777 (bfd *, Elf_Internal_Shdr *, Elf_Internal_Sym *, asection *);
1778
1779 extern bfd_boolean _bfd_elf_copy_private_bfd_data
1780 (bfd *, bfd *);
1781 extern bfd_boolean _bfd_elf_print_private_bfd_data
1782 (bfd *, void *);
1783 const char * _bfd_elf_get_symbol_version_string
1784 (bfd *, asymbol *, bfd_boolean *);
1785 extern void bfd_elf_print_symbol
1786 (bfd *, void *, asymbol *, bfd_print_symbol_type);
1787
1788 extern unsigned int _bfd_elf_eh_frame_address_size
1789 (bfd *, asection *);
1790 extern bfd_byte _bfd_elf_encode_eh_address
1791 (bfd *abfd, struct bfd_link_info *info, asection *osec, bfd_vma offset,
1792 asection *loc_sec, bfd_vma loc_offset, bfd_vma *encoded);
1793 extern bfd_boolean _bfd_elf_can_make_relative
1794 (bfd *input_bfd, struct bfd_link_info *info, asection *eh_frame_section);
1795
1796 extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
1797 (const struct bfd_link_info *, const asection *,
1798 const Elf_Internal_Rela *);
1799 extern bfd_vma _bfd_elf_rela_local_sym
1800 (bfd *, Elf_Internal_Sym *, asection **, Elf_Internal_Rela *);
1801 extern bfd_vma _bfd_elf_rel_local_sym
1802 (bfd *, Elf_Internal_Sym *, asection **, bfd_vma);
1803 extern bfd_vma _bfd_elf_section_offset
1804 (bfd *, struct bfd_link_info *, asection *, bfd_vma);
1805
1806 extern unsigned long bfd_elf_hash
1807 (const char *);
1808 extern unsigned long bfd_elf_gnu_hash
1809 (const char *);
1810
1811 extern bfd_reloc_status_type bfd_elf_generic_reloc
1812 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
1813 extern bfd_boolean bfd_elf_allocate_object
1814 (bfd *, size_t, enum elf_target_id);
1815 extern bfd_boolean bfd_elf_make_object
1816 (bfd *);
1817 extern bfd_boolean bfd_elf_mkcorefile
1818 (bfd *);
1819 extern bfd_boolean _bfd_elf_make_section_from_shdr
1820 (bfd *, Elf_Internal_Shdr *, const char *, int);
1821 extern bfd_boolean _bfd_elf_make_section_from_phdr
1822 (bfd *, Elf_Internal_Phdr *, int, const char *);
1823 extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc
1824 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
1825 extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create
1826 (bfd *);
1827 extern void _bfd_elf_link_hash_table_free
1828 (bfd *);
1829 extern void _bfd_elf_link_hash_copy_indirect
1830 (struct bfd_link_info *, struct elf_link_hash_entry *,
1831 struct elf_link_hash_entry *);
1832 extern void _bfd_elf_link_hash_hide_symbol
1833 (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
1834 extern bfd_boolean _bfd_elf_link_hash_fixup_symbol
1835 (struct bfd_link_info *, struct elf_link_hash_entry *);
1836 extern bfd_boolean _bfd_elf_link_hash_table_init
1837 (struct elf_link_hash_table *, bfd *,
1838 struct bfd_hash_entry *(*)
1839 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *),
1840 unsigned int, enum elf_target_id);
1841 extern bfd_boolean _bfd_elf_slurp_version_tables
1842 (bfd *, bfd_boolean);
1843 extern bfd_boolean _bfd_elf_merge_sections
1844 (bfd *, struct bfd_link_info *);
1845 extern bfd_boolean _bfd_elf_match_sections_by_type
1846 (bfd *, const asection *, bfd *, const asection *);
1847 extern bfd_boolean bfd_elf_is_group_section
1848 (bfd *, const struct bfd_section *);
1849 extern bfd_boolean _bfd_elf_section_already_linked
1850 (bfd *, asection *, struct bfd_link_info *);
1851 extern void bfd_elf_set_group_contents
1852 (bfd *, asection *, void *);
1853 extern asection *_bfd_elf_check_kept_section
1854 (asection *, struct bfd_link_info *);
1855 #define _bfd_elf_link_just_syms _bfd_generic_link_just_syms
1856 extern void _bfd_elf_copy_link_hash_symbol_type
1857 (bfd *, struct bfd_link_hash_entry *, struct bfd_link_hash_entry *);
1858 extern bfd_boolean _bfd_elf_size_group_sections
1859 (struct bfd_link_info *);
1860 extern bfd_boolean _bfd_elf_fixup_group_sections
1861 (bfd *, asection *);
1862 extern bfd_boolean _bfd_elf_copy_private_header_data
1863 (bfd *, bfd *);
1864 extern bfd_boolean _bfd_elf_copy_private_symbol_data
1865 (bfd *, asymbol *, bfd *, asymbol *);
1866 #define _bfd_generic_init_private_section_data \
1867 _bfd_elf_init_private_section_data
1868 extern bfd_boolean _bfd_elf_init_private_section_data
1869 (bfd *, asection *, bfd *, asection *, struct bfd_link_info *);
1870 extern bfd_boolean _bfd_elf_copy_private_section_data
1871 (bfd *, asection *, bfd *, asection *);
1872 extern bfd_boolean _bfd_elf_write_object_contents
1873 (bfd *);
1874 extern bfd_boolean _bfd_elf_write_corefile_contents
1875 (bfd *);
1876 extern bfd_boolean _bfd_elf_set_section_contents
1877 (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type);
1878 extern long _bfd_elf_get_symtab_upper_bound
1879 (bfd *);
1880 extern long _bfd_elf_canonicalize_symtab
1881 (bfd *, asymbol **);
1882 extern long _bfd_elf_get_dynamic_symtab_upper_bound
1883 (bfd *);
1884 extern long _bfd_elf_canonicalize_dynamic_symtab
1885 (bfd *, asymbol **);
1886 extern long _bfd_elf_get_synthetic_symtab
1887 (bfd *, long, asymbol **, long, asymbol **, asymbol **);
1888 extern long _bfd_elf_get_reloc_upper_bound
1889 (bfd *, sec_ptr);
1890 extern long _bfd_elf_canonicalize_reloc
1891 (bfd *, sec_ptr, arelent **, asymbol **);
1892 extern asection * _bfd_elf_get_dynamic_reloc_section
1893 (bfd *, asection *, bfd_boolean);
1894 extern asection * _bfd_elf_make_dynamic_reloc_section
1895 (asection *, bfd *, unsigned int, bfd *, bfd_boolean);
1896 extern long _bfd_elf_get_dynamic_reloc_upper_bound
1897 (bfd *);
1898 extern long _bfd_elf_canonicalize_dynamic_reloc
1899 (bfd *, arelent **, asymbol **);
1900 extern asymbol *_bfd_elf_make_empty_symbol
1901 (bfd *);
1902 extern void _bfd_elf_get_symbol_info
1903 (bfd *, asymbol *, symbol_info *);
1904 extern bfd_boolean _bfd_elf_is_local_label_name
1905 (bfd *, const char *);
1906 extern alent *_bfd_elf_get_lineno
1907 (bfd *, asymbol *);
1908 extern bfd_boolean _bfd_elf_set_arch_mach
1909 (bfd *, enum bfd_architecture, unsigned long);
1910 extern bfd_boolean _bfd_elf_find_nearest_line
1911 (bfd *, asymbol **, asection *, bfd_vma,
1912 const char **, const char **, unsigned int *, unsigned int *);
1913 extern bfd_boolean _bfd_elf_find_line
1914 (bfd *, asymbol **, asymbol *, const char **, unsigned int *);
1915 extern bfd_boolean _bfd_elf_find_inliner_info
1916 (bfd *, const char **, const char **, unsigned int *);
1917 extern bfd_boolean _bfd_elf_find_function
1918 (bfd *, asymbol **, asection *, bfd_vma, const char **, const char **);
1919 #define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols
1920 #define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1921 extern int _bfd_elf_sizeof_headers
1922 (bfd *, struct bfd_link_info *);
1923 extern bfd_boolean _bfd_elf_new_section_hook
1924 (bfd *, asection *);
1925 extern const struct bfd_elf_special_section *_bfd_elf_get_special_section
1926 (const char *, const struct bfd_elf_special_section *, unsigned int);
1927 extern const struct bfd_elf_special_section *_bfd_elf_get_sec_type_attr
1928 (bfd *, asection *);
1929
1930 /* If the target doesn't have reloc handling written yet: */
1931 extern void _bfd_elf_no_info_to_howto
1932 (bfd *, arelent *, Elf_Internal_Rela *);
1933
1934 extern bfd_boolean bfd_section_from_shdr
1935 (bfd *, unsigned int shindex);
1936 extern bfd_boolean bfd_section_from_phdr
1937 (bfd *, Elf_Internal_Phdr *, int);
1938
1939 extern int _bfd_elf_symbol_from_bfd_symbol
1940 (bfd *, asymbol **);
1941
1942 extern Elf_Internal_Sym *bfd_sym_from_r_symndx
1943 (struct sym_cache *, bfd *, unsigned long);
1944 extern asection *bfd_section_from_elf_index
1945 (bfd *, unsigned int);
1946 extern struct bfd_strtab_hash *_bfd_elf_stringtab_init
1947 (void);
1948
1949 extern struct elf_strtab_hash * _bfd_elf_strtab_init
1950 (void);
1951 extern void _bfd_elf_strtab_free
1952 (struct elf_strtab_hash *);
1953 extern bfd_size_type _bfd_elf_strtab_add
1954 (struct elf_strtab_hash *, const char *, bfd_boolean);
1955 extern void _bfd_elf_strtab_addref
1956 (struct elf_strtab_hash *, bfd_size_type);
1957 extern void _bfd_elf_strtab_delref
1958 (struct elf_strtab_hash *, bfd_size_type);
1959 extern unsigned int _bfd_elf_strtab_refcount
1960 (struct elf_strtab_hash *, bfd_size_type);
1961 extern void _bfd_elf_strtab_clear_all_refs
1962 (struct elf_strtab_hash *tab);
1963 extern void _bfd_elf_strtab_restore_size
1964 (struct elf_strtab_hash *, bfd_size_type);
1965 extern bfd_size_type _bfd_elf_strtab_size
1966 (struct elf_strtab_hash *);
1967 extern bfd_size_type _bfd_elf_strtab_offset
1968 (struct elf_strtab_hash *, bfd_size_type);
1969 extern bfd_boolean _bfd_elf_strtab_emit
1970 (bfd *, struct elf_strtab_hash *);
1971 extern void _bfd_elf_strtab_finalize
1972 (struct elf_strtab_hash *);
1973
1974 extern void _bfd_elf_parse_eh_frame
1975 (bfd *, struct bfd_link_info *, asection *, struct elf_reloc_cookie *);
1976 extern bfd_boolean _bfd_elf_discard_section_eh_frame
1977 (bfd *, struct bfd_link_info *, asection *,
1978 bfd_boolean (*) (bfd_vma, void *), struct elf_reloc_cookie *);
1979 extern bfd_boolean _bfd_elf_discard_section_eh_frame_hdr
1980 (bfd *, struct bfd_link_info *);
1981 extern bfd_vma _bfd_elf_eh_frame_section_offset
1982 (bfd *, struct bfd_link_info *, asection *, bfd_vma);
1983 extern bfd_boolean _bfd_elf_write_section_eh_frame
1984 (bfd *, struct bfd_link_info *, asection *, bfd_byte *);
1985 extern bfd_boolean _bfd_elf_write_section_eh_frame_hdr
1986 (bfd *, struct bfd_link_info *);
1987 extern bfd_boolean _bfd_elf_eh_frame_present
1988 (struct bfd_link_info *);
1989 extern bfd_boolean _bfd_elf_maybe_strip_eh_frame_hdr
1990 (struct bfd_link_info *);
1991
1992 extern bfd_boolean _bfd_elf_hash_symbol (struct elf_link_hash_entry *);
1993
1994 extern long _bfd_elf_link_lookup_local_dynindx
1995 (struct bfd_link_info *, bfd *, long);
1996 extern bfd_boolean _bfd_elf_compute_section_file_positions
1997 (bfd *, struct bfd_link_info *);
1998 extern file_ptr _bfd_elf_assign_file_position_for_section
1999 (Elf_Internal_Shdr *, file_ptr, bfd_boolean);
2000
2001 extern bfd_boolean _bfd_elf_validate_reloc
2002 (bfd *, arelent *);
2003
2004 extern bfd_boolean _bfd_elf_link_create_dynamic_sections
2005 (bfd *, struct bfd_link_info *);
2006 extern bfd_boolean _bfd_elf_link_omit_section_dynsym
2007 (bfd *, struct bfd_link_info *, asection *);
2008 extern bfd_boolean _bfd_elf_create_dynamic_sections
2009 (bfd *, struct bfd_link_info *);
2010 extern bfd_boolean _bfd_elf_create_got_section
2011 (bfd *, struct bfd_link_info *);
2012 extern struct elf_link_hash_entry *_bfd_elf_define_linkage_sym
2013 (bfd *, struct bfd_link_info *, asection *, const char *);
2014 extern void _bfd_elf_init_1_index_section
2015 (bfd *, struct bfd_link_info *);
2016 extern void _bfd_elf_init_2_index_sections
2017 (bfd *, struct bfd_link_info *);
2018
2019 extern bfd_boolean _bfd_elfcore_make_pseudosection
2020 (bfd *, char *, size_t, ufile_ptr);
2021 extern char *_bfd_elfcore_strndup
2022 (bfd *, char *, size_t);
2023
2024 extern Elf_Internal_Rela *_bfd_elf_link_read_relocs
2025 (bfd *, asection *, void *, Elf_Internal_Rela *, bfd_boolean);
2026
2027 extern bfd_boolean _bfd_elf_link_output_relocs
2028 (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *,
2029 struct elf_link_hash_entry **);
2030
2031 extern bfd_boolean _bfd_elf_adjust_dynamic_copy
2032 (struct bfd_link_info *, struct elf_link_hash_entry *, asection *);
2033
2034 extern bfd_boolean _bfd_elf_dynamic_symbol_p
2035 (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
2036
2037 extern bfd_boolean _bfd_elf_symbol_refs_local_p
2038 (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
2039
2040 extern bfd_reloc_status_type bfd_elf_perform_complex_relocation
2041 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma);
2042
2043 extern bfd_boolean _bfd_elf_setup_sections
2044 (bfd *);
2045
2046 extern void _bfd_elf_post_process_headers (bfd * , struct bfd_link_info *);
2047
2048 extern const bfd_target *bfd_elf32_object_p
2049 (bfd *);
2050 extern const bfd_target *bfd_elf32_core_file_p
2051 (bfd *);
2052 extern char *bfd_elf32_core_file_failing_command
2053 (bfd *);
2054 extern int bfd_elf32_core_file_failing_signal
2055 (bfd *);
2056 extern bfd_boolean bfd_elf32_core_file_matches_executable_p
2057 (bfd *, bfd *);
2058 extern int bfd_elf32_core_file_pid
2059 (bfd *);
2060
2061 extern bfd_boolean bfd_elf32_swap_symbol_in
2062 (bfd *, const void *, const void *, Elf_Internal_Sym *);
2063 extern void bfd_elf32_swap_symbol_out
2064 (bfd *, const Elf_Internal_Sym *, void *, void *);
2065 extern void bfd_elf32_swap_reloc_in
2066 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2067 extern void bfd_elf32_swap_reloc_out
2068 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2069 extern void bfd_elf32_swap_reloca_in
2070 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2071 extern void bfd_elf32_swap_reloca_out
2072 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2073 extern void bfd_elf32_swap_phdr_in
2074 (bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *);
2075 extern void bfd_elf32_swap_phdr_out
2076 (bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *);
2077 extern void bfd_elf32_swap_dyn_in
2078 (bfd *, const void *, Elf_Internal_Dyn *);
2079 extern void bfd_elf32_swap_dyn_out
2080 (bfd *, const Elf_Internal_Dyn *, void *);
2081 extern long bfd_elf32_slurp_symbol_table
2082 (bfd *, asymbol **, bfd_boolean);
2083 extern bfd_boolean bfd_elf32_write_shdrs_and_ehdr
2084 (bfd *);
2085 extern int bfd_elf32_write_out_phdrs
2086 (bfd *, const Elf_Internal_Phdr *, unsigned int);
2087 extern bfd_boolean bfd_elf32_checksum_contents
2088 (bfd * , void (*) (const void *, size_t, void *), void *);
2089 extern void bfd_elf32_write_relocs
2090 (bfd *, asection *, void *);
2091 extern bfd_boolean bfd_elf32_slurp_reloc_table
2092 (bfd *, asection *, asymbol **, bfd_boolean);
2093
2094 extern const bfd_target *bfd_elf64_object_p
2095 (bfd *);
2096 extern const bfd_target *bfd_elf64_core_file_p
2097 (bfd *);
2098 extern char *bfd_elf64_core_file_failing_command
2099 (bfd *);
2100 extern int bfd_elf64_core_file_failing_signal
2101 (bfd *);
2102 extern bfd_boolean bfd_elf64_core_file_matches_executable_p
2103 (bfd *, bfd *);
2104 extern int bfd_elf64_core_file_pid
2105 (bfd *);
2106
2107 extern bfd_boolean bfd_elf64_swap_symbol_in
2108 (bfd *, const void *, const void *, Elf_Internal_Sym *);
2109 extern void bfd_elf64_swap_symbol_out
2110 (bfd *, const Elf_Internal_Sym *, void *, void *);
2111 extern void bfd_elf64_swap_reloc_in
2112 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2113 extern void bfd_elf64_swap_reloc_out
2114 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2115 extern void bfd_elf64_swap_reloca_in
2116 (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2117 extern void bfd_elf64_swap_reloca_out
2118 (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2119 extern void bfd_elf64_swap_phdr_in
2120 (bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *);
2121 extern void bfd_elf64_swap_phdr_out
2122 (bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *);
2123 extern void bfd_elf64_swap_dyn_in
2124 (bfd *, const void *, Elf_Internal_Dyn *);
2125 extern void bfd_elf64_swap_dyn_out
2126 (bfd *, const Elf_Internal_Dyn *, void *);
2127 extern long bfd_elf64_slurp_symbol_table
2128 (bfd *, asymbol **, bfd_boolean);
2129 extern bfd_boolean bfd_elf64_write_shdrs_and_ehdr
2130 (bfd *);
2131 extern int bfd_elf64_write_out_phdrs
2132 (bfd *, const Elf_Internal_Phdr *, unsigned int);
2133 extern bfd_boolean bfd_elf64_checksum_contents
2134 (bfd * , void (*) (const void *, size_t, void *), void *);
2135 extern void bfd_elf64_write_relocs
2136 (bfd *, asection *, void *);
2137 extern bfd_boolean bfd_elf64_slurp_reloc_table
2138 (bfd *, asection *, asymbol **, bfd_boolean);
2139
2140 extern bfd_boolean _bfd_elf_default_relocs_compatible
2141 (const bfd_target *, const bfd_target *);
2142
2143 extern bfd_boolean _bfd_elf_relocs_compatible
2144 (const bfd_target *, const bfd_target *);
2145 extern bfd_boolean _bfd_elf_notice_as_needed
2146 (bfd *, struct bfd_link_info *, enum notice_asneeded_action);
2147
2148 extern struct elf_link_hash_entry *_bfd_elf_archive_symbol_lookup
2149 (bfd *, struct bfd_link_info *, const char *);
2150 extern bfd_boolean bfd_elf_link_add_symbols
2151 (bfd *, struct bfd_link_info *);
2152 extern bfd_boolean _bfd_elf_add_dynamic_entry
2153 (struct bfd_link_info *, bfd_vma, bfd_vma);
2154
2155 extern bfd_boolean bfd_elf_link_record_dynamic_symbol
2156 (struct bfd_link_info *, struct elf_link_hash_entry *);
2157
2158 extern int bfd_elf_link_record_local_dynamic_symbol
2159 (struct bfd_link_info *, bfd *, long);
2160
2161 extern bfd_boolean _bfd_elf_close_and_cleanup
2162 (bfd *);
2163
2164 extern bfd_boolean _bfd_elf_common_definition
2165 (Elf_Internal_Sym *);
2166
2167 extern unsigned int _bfd_elf_common_section_index
2168 (asection *);
2169
2170 extern asection *_bfd_elf_common_section
2171 (asection *);
2172
2173 extern bfd_vma _bfd_elf_default_got_elt_size
2174 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, bfd *,
2175 unsigned long);
2176
2177 extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn
2178 (bfd *, arelent *, struct bfd_symbol *, void *,
2179 asection *, bfd *, char **);
2180
2181 extern bfd_boolean bfd_elf_final_link
2182 (bfd *, struct bfd_link_info *);
2183
2184 extern void _bfd_elf_gc_keep
2185 (struct bfd_link_info *info);
2186
2187 extern bfd_boolean bfd_elf_gc_mark_dynamic_ref_symbol
2188 (struct elf_link_hash_entry *h, void *inf);
2189
2190 extern bfd_boolean bfd_elf_gc_sections
2191 (bfd *, struct bfd_link_info *);
2192
2193 extern bfd_boolean bfd_elf_gc_record_vtinherit
2194 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
2195
2196 extern bfd_boolean bfd_elf_gc_record_vtentry
2197 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
2198
2199 extern asection *_bfd_elf_gc_mark_hook
2200 (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
2201 struct elf_link_hash_entry *, Elf_Internal_Sym *);
2202
2203 extern asection *_bfd_elf_gc_mark_rsec
2204 (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn,
2205 struct elf_reloc_cookie *);
2206
2207 extern bfd_boolean _bfd_elf_gc_mark_reloc
2208 (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn,
2209 struct elf_reloc_cookie *);
2210
2211 extern bfd_boolean _bfd_elf_gc_mark_fdes
2212 (struct bfd_link_info *, asection *, asection *, elf_gc_mark_hook_fn,
2213 struct elf_reloc_cookie *);
2214
2215 extern bfd_boolean _bfd_elf_gc_mark
2216 (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn);
2217
2218 extern bfd_boolean _bfd_elf_gc_mark_extra_sections
2219 (struct bfd_link_info *, elf_gc_mark_hook_fn);
2220
2221 extern bfd_boolean bfd_elf_gc_common_finalize_got_offsets
2222 (bfd *, struct bfd_link_info *);
2223
2224 extern bfd_boolean bfd_elf_gc_common_final_link
2225 (bfd *, struct bfd_link_info *);
2226
2227 extern bfd_boolean bfd_elf_reloc_symbol_deleted_p
2228 (bfd_vma, void *);
2229
2230 extern struct elf_segment_map * _bfd_elf_make_dynamic_segment
2231 (bfd *, asection *);
2232
2233 extern bfd_boolean _bfd_elf_map_sections_to_segments
2234 (bfd *, struct bfd_link_info *);
2235
2236 extern bfd_boolean _bfd_elf_is_function_type (unsigned int);
2237
2238 extern bfd_size_type _bfd_elf_maybe_function_sym (const asymbol *, asection *,
2239 bfd_vma *);
2240
2241 extern int bfd_elf_get_default_section_type (flagword);
2242
2243 extern bfd_boolean bfd_elf_lookup_section_flags
2244 (struct bfd_link_info *, struct flag_info *, asection *);
2245
2246 extern Elf_Internal_Phdr * _bfd_elf_find_segment_containing_section
2247 (bfd * abfd, asection * section);
2248
2249 /* Exported interface for writing elf corefile notes. */
2250 extern char *elfcore_write_note
2251 (bfd *, char *, int *, const char *, int, const void *, int);
2252 extern char *elfcore_write_prpsinfo
2253 (bfd *, char *, int *, const char *, const char *);
2254 extern char *elfcore_write_prstatus
2255 (bfd *, char *, int *, long, int, const void *);
2256 extern char * elfcore_write_pstatus
2257 (bfd *, char *, int *, long, int, const void *);
2258 extern char *elfcore_write_prfpreg
2259 (bfd *, char *, int *, const void *, int);
2260 extern char *elfcore_write_prxfpreg
2261 (bfd *, char *, int *, const void *, int);
2262 extern char *elfcore_write_xstatereg
2263 (bfd *, char *, int *, const void *, int);
2264 extern char *elfcore_write_ppc_vmx
2265 (bfd *, char *, int *, const void *, int);
2266 extern char *elfcore_write_ppc_vsx
2267 (bfd *, char *, int *, const void *, int);
2268 extern char *elfcore_write_s390_timer
2269 (bfd *, char *, int *, const void *, int);
2270 extern char *elfcore_write_s390_todcmp
2271 (bfd *, char *, int *, const void *, int);
2272 extern char *elfcore_write_s390_todpreg
2273 (bfd *, char *, int *, const void *, int);
2274 extern char *elfcore_write_s390_ctrs
2275 (bfd *, char *, int *, const void *, int);
2276 extern char *elfcore_write_s390_prefix
2277 (bfd *, char *, int *, const void *, int);
2278 extern char *elfcore_write_s390_last_break
2279 (bfd *, char *, int *, const void *, int);
2280 extern char *elfcore_write_s390_system_call
2281 (bfd *, char *, int *, const void *, int);
2282 extern char *elfcore_write_s390_tdb
2283 (bfd *, char *, int *, const void *, int);
2284 extern char *elfcore_write_arm_vfp
2285 (bfd *, char *, int *, const void *, int);
2286 extern char *elfcore_write_aarch_tls
2287 (bfd *, char *, int *, const void *, int);
2288 extern char *elfcore_write_aarch_hw_break
2289 (bfd *, char *, int *, const void *, int);
2290 extern char *elfcore_write_aarch_hw_watch
2291 (bfd *, char *, int *, const void *, int);
2292 extern char *elfcore_write_lwpstatus
2293 (bfd *, char *, int *, long, int, const void *);
2294 extern char *elfcore_write_register_note
2295 (bfd *, char *, int *, const char *, const void *, int);
2296
2297 /* Internal structure which holds information to be included in the
2298 PRPSINFO section of Linux core files.
2299
2300 This is an "internal" structure in the sense that it should be used
2301 to pass information to BFD (via the `elfcore_write_linux_prpsinfo'
2302 function), so things like endianess shouldn't be an issue. This
2303 structure will eventually be converted in one of the
2304 `elf_external_linux_*' structures and written out to an output bfd
2305 by one of the functions declared below. */
2306
2307 struct elf_internal_linux_prpsinfo
2308 {
2309 char pr_state; /* Numeric process state. */
2310 char pr_sname; /* Char for pr_state. */
2311 char pr_zomb; /* Zombie. */
2312 char pr_nice; /* Nice val. */
2313 unsigned long pr_flag; /* Flags. */
2314 unsigned int pr_uid;
2315 unsigned int pr_gid;
2316 int pr_pid, pr_ppid, pr_pgrp, pr_sid;
2317 char pr_fname[16 + 1]; /* Filename of executable. */
2318 char pr_psargs[80 + 1]; /* Initial part of arg list. */
2319 };
2320
2321 /* Linux/most 32-bit archs. */
2322 extern char *elfcore_write_linux_prpsinfo32
2323 (bfd *, char *, int *, const struct elf_internal_linux_prpsinfo *);
2324
2325 /* Linux/most 64-bit archs. */
2326 extern char *elfcore_write_linux_prpsinfo64
2327 (bfd *, char *, int *, const struct elf_internal_linux_prpsinfo *);
2328
2329 /* Linux/PPC32 uses different layout compared to most archs. */
2330 extern char *elfcore_write_ppc_linux_prpsinfo32
2331 (bfd *, char *, int *, const struct elf_internal_linux_prpsinfo *);
2332
2333 extern bfd *_bfd_elf32_bfd_from_remote_memory
2334 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep,
2335 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type));
2336 extern bfd *_bfd_elf64_bfd_from_remote_memory
2337 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep,
2338 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type));
2339
2340 extern bfd_vma bfd_elf_obj_attr_size (bfd *);
2341 extern void bfd_elf_set_obj_attr_contents (bfd *, bfd_byte *, bfd_vma);
2342 extern int bfd_elf_get_obj_attr_int (bfd *, int, int);
2343 extern void bfd_elf_add_obj_attr_int (bfd *, int, int, unsigned int);
2344 #define bfd_elf_add_proc_attr_int(BFD, TAG, VALUE) \
2345 bfd_elf_add_obj_attr_int ((BFD), OBJ_ATTR_PROC, (TAG), (VALUE))
2346 extern void bfd_elf_add_obj_attr_string (bfd *, int, int, const char *);
2347 #define bfd_elf_add_proc_attr_string(BFD, TAG, VALUE) \
2348 bfd_elf_add_obj_attr_string ((BFD), OBJ_ATTR_PROC, (TAG), (VALUE))
2349 extern void bfd_elf_add_obj_attr_int_string (bfd *, int, int, unsigned int,
2350 const char *);
2351 #define bfd_elf_add_proc_attr_int_string(BFD, TAG, INTVAL, STRVAL) \
2352 bfd_elf_add_obj_attr_int_string ((BFD), OBJ_ATTR_PROC, (TAG), \
2353 (INTVAL), (STRVAL))
2354
2355 extern char *_bfd_elf_attr_strdup (bfd *, const char *);
2356 extern void _bfd_elf_copy_obj_attributes (bfd *, bfd *);
2357 extern int _bfd_elf_obj_attrs_arg_type (bfd *, int, int);
2358 extern void _bfd_elf_parse_attributes (bfd *, Elf_Internal_Shdr *);
2359 extern bfd_boolean _bfd_elf_merge_object_attributes (bfd *, bfd *);
2360 extern bfd_boolean _bfd_elf_merge_unknown_attribute_low (bfd *, bfd *, int);
2361 extern bfd_boolean _bfd_elf_merge_unknown_attribute_list (bfd *, bfd *);
2362 extern Elf_Internal_Shdr *_bfd_elf_single_rel_hdr (asection *sec);
2363
2364 /* The linker may need to keep track of the number of relocs that it
2365 decides to copy as dynamic relocs in check_relocs for each symbol.
2366 This is so that it can later discard them if they are found to be
2367 unnecessary. We can store the information in a field extending the
2368 regular ELF linker hash table. */
2369
2370 struct elf_dyn_relocs
2371 {
2372 struct elf_dyn_relocs *next;
2373
2374 /* The input section of the reloc. */
2375 asection *sec;
2376
2377 /* Total number of relocs copied for the input section. */
2378 bfd_size_type count;
2379
2380 /* Number of pc-relative relocs copied for the input section. */
2381 bfd_size_type pc_count;
2382 };
2383
2384 extern bfd_boolean _bfd_elf_create_ifunc_sections
2385 (bfd *, struct bfd_link_info *);
2386 extern bfd_boolean _bfd_elf_allocate_ifunc_dyn_relocs
2387 (struct bfd_link_info *, struct elf_link_hash_entry *,
2388 struct elf_dyn_relocs **, unsigned int, unsigned int, unsigned int);
2389 extern long _bfd_elf_ifunc_get_synthetic_symtab
2390 (bfd *, long, asymbol **, long, asymbol **, asymbol **, asection *,
2391 bfd_vma *(*) (bfd *, asymbol **, asection *, asection *));
2392
2393 extern void elf_append_rela (bfd *, asection *, Elf_Internal_Rela *);
2394 extern void elf_append_rel (bfd *, asection *, Elf_Internal_Rela *);
2395
2396 extern bfd_vma elf64_r_info (bfd_vma, bfd_vma);
2397 extern bfd_vma elf64_r_sym (bfd_vma);
2398 extern bfd_vma elf32_r_info (bfd_vma, bfd_vma);
2399 extern bfd_vma elf32_r_sym (bfd_vma);
2400
2401 /* Large common section. */
2402 extern asection _bfd_elf_large_com_section;
2403
2404 /* Hash for local symbol with the first section id, ID, in the input
2405 file and the local symbol index, SYM. */
2406 #define ELF_LOCAL_SYMBOL_HASH(ID, SYM) \
2407 (((((ID) & 0xff) << 24) | (((ID) & 0xff00) << 8)) \
2408 ^ (SYM) ^ ((ID) >> 16))
2409
2410 /* This is the condition under which finish_dynamic_symbol will be called.
2411 If our finish_dynamic_symbol isn't called, we'll need to do something
2412 about initializing any .plt and .got entries in relocate_section. */
2413 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
2414 ((DYN) \
2415 && ((SHARED) || !(H)->forced_local) \
2416 && ((H)->dynindx != -1 || (H)->forced_local))
2417
2418 /* This macro is to avoid lots of duplicated code in the body
2419 of xxx_relocate_section() in the various elfxx-xxxx.c files. */
2420 #define RELOC_FOR_GLOBAL_SYMBOL(info, input_bfd, input_section, rel, \
2421 r_symndx, symtab_hdr, sym_hashes, \
2422 h, sec, relocation, \
2423 unresolved_reloc, warned, ignored) \
2424 do \
2425 { \
2426 /* It seems this can happen with erroneous or unsupported \
2427 input (mixing a.out and elf in an archive, for example.) */ \
2428 if (sym_hashes == NULL) \
2429 return FALSE; \
2430 \
2431 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; \
2432 \
2433 if (info->wrap_hash != NULL \
2434 && (input_section->flags & SEC_DEBUGGING) != 0) \
2435 h = ((struct elf_link_hash_entry *) \
2436 unwrap_hash_lookup (info, input_bfd, &h->root)); \
2437 \
2438 while (h->root.type == bfd_link_hash_indirect \
2439 || h->root.type == bfd_link_hash_warning) \
2440 h = (struct elf_link_hash_entry *) h->root.u.i.link; \
2441 \
2442 warned = FALSE; \
2443 ignored = FALSE; \
2444 unresolved_reloc = FALSE; \
2445 relocation = 0; \
2446 if (h->root.type == bfd_link_hash_defined \
2447 || h->root.type == bfd_link_hash_defweak) \
2448 { \
2449 sec = h->root.u.def.section; \
2450 if (sec == NULL \
2451 || sec->output_section == NULL) \
2452 /* Set a flag that will be cleared later if we find a \
2453 relocation value for this symbol. output_section \
2454 is typically NULL for symbols satisfied by a shared \
2455 library. */ \
2456 unresolved_reloc = TRUE; \
2457 else \
2458 relocation = (h->root.u.def.value \
2459 + sec->output_section->vma \
2460 + sec->output_offset); \
2461 } \
2462 else if (h->root.type == bfd_link_hash_undefweak) \
2463 ; \
2464 else if (info->unresolved_syms_in_objects == RM_IGNORE \
2465 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) \
2466 ignored = TRUE; \
2467 else if (!info->relocatable) \
2468 { \
2469 bfd_boolean err; \
2470 err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR \
2471 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT); \
2472 if (!info->callbacks->undefined_symbol (info, \
2473 h->root.root.string, \
2474 input_bfd, \
2475 input_section, \
2476 rel->r_offset, err)) \
2477 return FALSE; \
2478 warned = TRUE; \
2479 } \
2480 (void) unresolved_reloc; \
2481 (void) warned; \
2482 (void) ignored; \
2483 } \
2484 while (0)
2485
2486 /* This macro is to avoid lots of duplicated code in the body of the
2487 loop over relocations in xxx_relocate_section() in the various
2488 elfxx-xxxx.c files.
2489
2490 Handle relocations against symbols from removed linkonce sections,
2491 or sections discarded by a linker script. When doing a relocatable
2492 link, we remove such relocations. Otherwise, we just want the
2493 section contents zeroed and avoid any special processing. */
2494 #define RELOC_AGAINST_DISCARDED_SECTION(info, input_bfd, input_section, \
2495 rel, count, relend, \
2496 howto, index, contents) \
2497 { \
2498 int i_; \
2499 _bfd_clear_contents (howto, input_bfd, input_section, \
2500 contents + rel[index].r_offset); \
2501 \
2502 if (info->relocatable \
2503 && (input_section->flags & SEC_DEBUGGING)) \
2504 { \
2505 /* Only remove relocations in debug sections since other \
2506 sections may require relocations. */ \
2507 Elf_Internal_Shdr *rel_hdr; \
2508 \
2509 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); \
2510 \
2511 /* Avoid empty output section. */ \
2512 if (rel_hdr->sh_size > rel_hdr->sh_entsize) \
2513 { \
2514 rel_hdr->sh_size -= rel_hdr->sh_entsize; \
2515 rel_hdr = _bfd_elf_single_rel_hdr (input_section); \
2516 rel_hdr->sh_size -= rel_hdr->sh_entsize; \
2517 \
2518 memmove (rel, rel + count, \
2519 (relend - rel - count) * sizeof (*rel)); \
2520 \
2521 input_section->reloc_count--; \
2522 relend -= count; \
2523 rel--; \
2524 continue; \
2525 } \
2526 } \
2527 \
2528 for (i_ = 0; i_ < count; i_++) \
2529 { \
2530 rel[i_].r_info = 0; \
2531 rel[i_].r_addend = 0; \
2532 } \
2533 rel += count - 1; \
2534 continue; \
2535 }
2536
2537 /* Will a symbol be bound to the definition within the shared
2538 library, if any. A unique symbol can never be bound locally. */
2539 #define SYMBOLIC_BIND(INFO, H) \
2540 (!(H)->unique_global \
2541 && ((INFO)->symbolic || ((INFO)->dynamic && !(H)->dynamic)))
2542
2543 #endif /* _LIBELF_H_ */
This page took 0.137981 seconds and 4 git commands to generate.