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