* elf-bfd.h (struct got_entry, struct plt_entry): Forward declare.
[external/binutils.git] / bfd / elf-bfd.h
1 /* BFD back-end data structures for ELF files.
2    Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3    2002, 2003 Free Software Foundation, Inc.
4    Written by Cygnus Support.
5
6    This file is part of BFD, the Binary File Descriptor library.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
22 #ifndef _LIBELF_H_
23 #define _LIBELF_H_ 1
24
25 #include "elf/common.h"
26 #include "elf/internal.h"
27 #include "elf/external.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 #define NUM_SHDR_ENTRIES(shdr) ((shdr)->sh_size / (shdr)->sh_entsize)
34
35 /* If size isn't specified as 64 or 32, NAME macro should fail.  */
36 /* Do not "beautify" the CONCAT* macro args.  Traditional C will not
37    remove whitespace added here, and thus will fail to concatenate
38    the tokens.  */
39 #ifndef NAME
40 #if ARCH_SIZE==64
41 #define NAME(x,y) CONCAT4 (x,64,_,y)
42 #endif
43 #if ARCH_SIZE==32
44 #define NAME(x,y) CONCAT4 (x,32,_,y)
45 #endif
46 #endif
47
48 #ifndef NAME
49 #define NAME(x,y) CONCAT4 (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       PTR mips_extr;
71       PTR 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 /* ELF linker hash table entries.  */
87
88 struct elf_link_hash_entry
89 {
90   struct bfd_link_hash_entry root;
91
92   /* Symbol index in output file.  This is initialized to -1.  It is
93      set to -2 if the symbol is used by a reloc.  */
94   long indx;
95
96   /* Symbol index as a dynamic symbol.  Initialized to -1, and remains
97      -1 if this is not a dynamic symbol.  */
98   /* ??? Note that this is consistently used as a synonym for tests
99      against whether we can perform various simplifying transformations
100      to the code.  (E.g. changing a pc-relative jump to a PLT entry
101      into a pc-relative jump to the target function.)  That test, which
102      is often relatively complex, and someplaces wrong or incomplete,
103      should really be replaced by a predicate in elflink.c.
104
105      End result: this field -1 does not indicate that the symbol is
106      not in the dynamic symbol table, but rather that the symbol is
107      not visible outside this DSO.  */
108   long dynindx;
109
110   /* String table index in .dynstr if this is a dynamic symbol.  */
111   unsigned long dynstr_index;
112
113   /* Hash value of the name computed using the ELF hash function.  */
114   unsigned long elf_hash_value;
115
116   /* If this is a weak defined symbol from a dynamic object, this
117      field points to a defined symbol with the same value, if there is
118      one.  Otherwise it is NULL.  */
119   struct elf_link_hash_entry *weakdef;
120
121   /* If this symbol is used in the linker created sections, the processor
122      specific backend uses this field to map the field into the offset
123      from the beginning of the section.  */
124   struct elf_linker_section_pointers *linker_section_pointer;
125
126   /* Version information.  */
127   union
128   {
129     /* This field is used for a symbol which is not defined in a
130        regular object.  It points to the version information read in
131        from the dynamic object.  */
132     Elf_Internal_Verdef *verdef;
133     /* This field is used for a symbol which is defined in a regular
134        object.  It is set up in size_dynamic_sections.  It points to
135        the version information we should write out for this symbol.  */
136     struct bfd_elf_version_tree *vertree;
137   } verinfo;
138
139   /* Virtual table entry use information.  This array is nominally of size
140      size/sizeof(target_void_pointer), though we have to be able to assume
141      and track a size while the symbol is still undefined.  It is indexed
142      via offset/sizeof(target_void_pointer).  */
143   size_t vtable_entries_size;
144   bfd_boolean *vtable_entries_used;
145
146   /* Virtual table derivation info.  */
147   struct elf_link_hash_entry *vtable_parent;
148
149   /* If this symbol requires an entry in the global offset table, the
150      processor specific backend uses this field to track usage and
151      final offset.  Two schemes are supported:  The first assumes that
152      a symbol may only have one GOT entry, and uses REFCOUNT until
153      size_dynamic_sections, at which point the contents of the .got is
154      fixed.  Afterward, if OFFSET is -1, then the symbol does not
155      require a global offset table entry.  The second scheme allows
156      multiple GOT entries per symbol, managed via a linked list
157      pointed to by GLIST.  */
158   union gotplt_union
159     {
160       bfd_signed_vma refcount;
161       bfd_vma offset;
162       struct got_entry *glist;
163       struct plt_entry *plist;
164     } got;
165
166   /* Same, but tracks a procedure linkage table entry.  */
167   union gotplt_union plt;
168
169   /* Symbol size.  */
170   bfd_size_type size;
171
172   /* Symbol type (STT_NOTYPE, STT_OBJECT, etc.).  */
173   char type;
174
175   /* Symbol st_other value, symbol visibility.  */
176   unsigned char other;
177
178   /* Some flags; legal values follow.  */
179   unsigned short elf_link_hash_flags;
180   /* Symbol is referenced by a non-shared object.  */
181 #define ELF_LINK_HASH_REF_REGULAR 01
182   /* Symbol is defined by a non-shared object.  */
183 #define ELF_LINK_HASH_DEF_REGULAR 02
184   /* Symbol is referenced by a shared object.  */
185 #define ELF_LINK_HASH_REF_DYNAMIC 04
186   /* Symbol is defined by a shared object.  */
187 #define ELF_LINK_HASH_DEF_DYNAMIC 010
188   /* Symbol has a non-weak reference from a non-shared object.  */
189 #define ELF_LINK_HASH_REF_REGULAR_NONWEAK 020
190   /* Dynamic symbol has been adjustd.  */
191 #define ELF_LINK_HASH_DYNAMIC_ADJUSTED 040
192   /* Symbol needs a copy reloc.  */
193 #define ELF_LINK_HASH_NEEDS_COPY 0100
194   /* Symbol needs a procedure linkage table entry.  */
195 #define ELF_LINK_HASH_NEEDS_PLT 0200
196   /* Symbol appears in a non-ELF input file.  */
197 #define ELF_LINK_NON_ELF 0400
198   /* Symbol should be marked as hidden in the version information.  */
199 #define ELF_LINK_HIDDEN 01000
200   /* Symbol was forced to local scope due to a version script file.  */
201 #define ELF_LINK_FORCED_LOCAL 02000
202   /* Symbol was marked during garbage collection.  */
203 #define ELF_LINK_HASH_MARK 04000
204   /* Symbol is referenced by a non-GOT/non-PLT relocation.  This is
205      not currently set by all the backends.  */
206 #define ELF_LINK_NON_GOT_REF 010000
207 };
208
209 /* Records local symbols to be emitted in the dynamic symbol table.  */
210
211 struct elf_link_local_dynamic_entry
212 {
213   struct elf_link_local_dynamic_entry *next;
214
215   /* The input bfd this symbol came from.  */
216   bfd *input_bfd;
217
218   /* The index of the local symbol being copied.  */
219   long input_indx;
220
221   /* The index in the outgoing dynamic symbol table.  */
222   long dynindx;
223
224   /* A copy of the input symbol.  */
225   Elf_Internal_Sym isym;
226 };
227
228 struct elf_link_loaded_list
229 {
230   struct elf_link_loaded_list *next;
231   bfd *abfd;
232 };
233
234 /* Structures used by the eh_frame optimization code.  */
235 struct cie_header
236 {
237   unsigned int length;
238   unsigned int id;
239 };
240
241 struct cie
242 {
243   struct cie_header hdr;
244   unsigned char version;
245   unsigned char augmentation[20];
246   unsigned int code_align;
247   int data_align;
248   unsigned int ra_column;
249   unsigned int augmentation_size;
250   struct elf_link_hash_entry *personality;
251   unsigned char per_encoding;
252   unsigned char lsda_encoding;
253   unsigned char fde_encoding;
254   unsigned char initial_insn_length;
255   unsigned char make_relative;
256   unsigned char make_lsda_relative;
257   unsigned char initial_instructions[50];
258 };
259
260 struct eh_cie_fde
261 {
262   unsigned int offset;
263   unsigned int size;
264   asection *sec;
265   unsigned int new_offset;
266   unsigned char fde_encoding;
267   unsigned char lsda_encoding;
268   unsigned char lsda_offset;
269   unsigned char cie : 1;
270   unsigned char removed : 1;
271   unsigned char make_relative : 1;
272   unsigned char make_lsda_relative : 1;
273   unsigned char per_encoding_relative : 1;
274 };
275
276 struct eh_frame_sec_info
277 {
278   unsigned int count;
279   unsigned int alloced;
280   struct eh_cie_fde entry[1];
281 };
282
283 struct eh_frame_array_ent
284 {
285   bfd_vma initial_loc;
286   bfd_vma fde;
287 };
288
289 struct eh_frame_hdr_info
290 {
291   struct cie last_cie;
292   asection *last_cie_sec;
293   asection *hdr_sec;
294   unsigned int last_cie_offset;
295   unsigned int fde_count, array_count;
296   struct eh_frame_array_ent *array;
297   /* TRUE if .eh_frame_hdr should contain the sorted search table.
298      We build it if we successfully read all .eh_frame input sections
299      and recognize them.  */
300   bfd_boolean table;
301 };
302
303 /* Cached start, size and alignment of PT_TLS segment.  */
304 struct elf_link_tls_segment
305 {
306   bfd_vma start;
307   bfd_size_type size;
308   unsigned int align;
309 };
310
311 /* ELF linker hash table.  */
312
313 struct elf_link_hash_table
314 {
315   struct bfd_link_hash_table root;
316
317   /* Whether we have created the special dynamic sections required
318      when linking against or generating a shared object.  */
319   bfd_boolean dynamic_sections_created;
320
321   /* The BFD used to hold special sections created by the linker.
322      This will be the first BFD found which requires these sections to
323      be created.  */
324   bfd *dynobj;
325
326   /* The value to use when initialising got.refcount/offset and
327      plt.refcount/offset in an elf_link_hash_entry.  Set to zero when
328      the values are refcounts.  Set to init_offset in
329      size_dynamic_sections when the values may be offsets.  */
330   union gotplt_union init_refcount;
331
332   /* The value to use for got.refcount/offset and plt.refcount/offset
333      when the values may be offsets.  Normally (bfd_vma) -1.  */
334   union gotplt_union init_offset;
335
336   /* The number of symbols found in the link which must be put into
337      the .dynsym section.  */
338   bfd_size_type dynsymcount;
339
340   /* The string table of dynamic symbols, which becomes the .dynstr
341      section.  */
342   struct elf_strtab_hash *dynstr;
343
344   /* The number of buckets in the hash table in the .hash section.
345      This is based on the number of dynamic symbols.  */
346   bfd_size_type bucketcount;
347
348   /* A linked list of DT_NEEDED names found in dynamic objects
349      included in the link.  */
350   struct bfd_link_needed_list *needed;
351
352   /* The _GLOBAL_OFFSET_TABLE_ symbol.  */
353   struct elf_link_hash_entry *hgot;
354
355   /* A pointer to information used to link stabs in sections.  */
356   PTR stab_info;
357
358   /* A pointer to information used to merge SEC_MERGE sections.  */
359   PTR merge_info;
360
361   /* Used by eh_frame code when editing .eh_frame.  */
362   struct eh_frame_hdr_info eh_info;
363
364   /* A linked list of local symbols to be added to .dynsym.  */
365   struct elf_link_local_dynamic_entry *dynlocal;
366
367   /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic
368      objects included in the link.  */
369   struct bfd_link_needed_list *runpath;
370
371   /* Cached start, size and alignment of PT_TLS segment.  */
372   struct elf_link_tls_segment *tls_segment;
373
374   /* A linked list of BFD's loaded in the link.  */
375   struct elf_link_loaded_list *loaded;
376 };
377
378 /* Look up an entry in an ELF linker hash table.  */
379
380 #define elf_link_hash_lookup(table, string, create, copy, follow)       \
381   ((struct elf_link_hash_entry *)                                       \
382    bfd_link_hash_lookup (&(table)->root, (string), (create),            \
383                          (copy), (follow)))
384
385 /* Traverse an ELF linker hash table.  */
386
387 #define elf_link_hash_traverse(table, func, info)                       \
388   (bfd_link_hash_traverse                                               \
389    (&(table)->root,                                                     \
390     (bfd_boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \
391     (info)))
392
393 /* Get the ELF linker hash table from a link_info structure.  */
394
395 #define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))
396
397 /* Returns TRUE if the hash table is a struct elf_link_hash_table.  */
398 #define is_elf_hash_table(p)                                            \
399   ((p)->hash->type == bfd_link_elf_hash_table)
400
401 /* Used by bfd_section_from_r_symndx to cache a small number of local
402    symbol to section mappings.  */
403 #define LOCAL_SYM_CACHE_SIZE 32
404 struct sym_sec_cache
405 {
406   bfd *abfd;
407   unsigned long indx[LOCAL_SYM_CACHE_SIZE];
408   asection *sec[LOCAL_SYM_CACHE_SIZE];
409 };
410 \f
411 /* Constant information held for an ELF backend.  */
412
413 struct elf_size_info {
414   unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr;
415   unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note;
416
417   /* The size of entries in the .hash section.  */
418   unsigned char sizeof_hash_entry;
419
420   /* The number of internal relocations to allocate per external
421      relocation entry.  */
422   unsigned char int_rels_per_ext_rel;
423   /* We use some fixed size arrays.  This should be large enough to
424      handle all back-ends.  */
425 #define MAX_INT_RELS_PER_EXT_REL 3
426
427   unsigned char arch_size, file_align;
428   unsigned char elfclass, ev_current;
429   int (*write_out_phdrs)
430     PARAMS ((bfd *, const Elf_Internal_Phdr *, unsigned int));
431   bfd_boolean (*write_shdrs_and_ehdr)
432     PARAMS ((bfd *));
433   void (*write_relocs)
434     PARAMS ((bfd *, asection *, PTR));
435   void (*swap_symbol_in)
436     PARAMS ((bfd *, const PTR, const PTR, Elf_Internal_Sym *));
437   void (*swap_symbol_out)
438     PARAMS ((bfd *, const Elf_Internal_Sym *, PTR, PTR));
439   bfd_boolean (*slurp_reloc_table)
440     PARAMS ((bfd *, asection *, asymbol **, bfd_boolean));
441   long (*slurp_symbol_table)
442     PARAMS ((bfd *, asymbol **, bfd_boolean));
443   void (*swap_dyn_in)
444     PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
445   void (*swap_dyn_out)
446     PARAMS ((bfd *, const Elf_Internal_Dyn *, PTR));
447
448   /* This function is called to swap in a REL relocation.  If an
449      external relocation corresponds to more than one internal
450      relocation, then all relocations are swapped in at once.  */
451   void (*swap_reloc_in)
452     PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
453
454   /* This function is called to swap out a REL relocation.  */
455   void (*swap_reloc_out)
456     PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
457
458   /* This function is called to swap in a RELA relocation.  If an
459      external relocation corresponds to more than one internal
460      relocation, then all relocations are swapped in at once.  */
461   void (*swap_reloca_in)
462     PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
463
464   /* This function is called to swap out a RELA relocation.  */
465   void (*swap_reloca_out)
466     PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
467 };
468
469 #define elf_symbol_from(ABFD,S) \
470         (((S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \
471           && (S)->the_bfd->tdata.elf_obj_data != 0) \
472          ? (elf_symbol_type *) (S) \
473          : 0)
474
475 enum elf_reloc_type_class {
476   reloc_class_normal,
477   reloc_class_relative,
478   reloc_class_plt,
479   reloc_class_copy
480 };
481
482 struct elf_reloc_cookie
483 {
484   Elf_Internal_Rela *rels, *rel, *relend;
485   Elf_Internal_Sym *locsyms;
486   bfd *abfd;
487   size_t locsymcount;
488   size_t extsymoff;
489   struct elf_link_hash_entry **sym_hashes;
490   bfd_boolean bad_symtab;
491 };
492
493 /* The level of IRIX compatibility we're striving for.  */
494
495 typedef enum {
496   ict_none,
497   ict_irix5,
498   ict_irix6
499 } irix_compat_t;
500
501 struct elf_backend_data
502 {
503   /* The architecture for this backend.  */
504   enum bfd_architecture arch;
505
506   /* The ELF machine code (EM_xxxx) for this backend.  */
507   int elf_machine_code;
508
509   /* The maximum page size for this backend.  */
510   bfd_vma maxpagesize;
511
512   /* A function to translate an ELF RELA relocation to a BFD arelent
513      structure.  */
514   void (*elf_info_to_howto)
515     PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
516
517   /* A function to translate an ELF REL relocation to a BFD arelent
518      structure.  */
519   void (*elf_info_to_howto_rel)
520     PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
521
522   /* A function to determine whether a symbol is global when
523      partitioning the symbol table into local and global symbols.
524      This should be NULL for most targets, in which case the correct
525      thing will be done.  MIPS ELF, at least on the Irix 5, has
526      special requirements.  */
527   bfd_boolean (*elf_backend_sym_is_global)
528     PARAMS ((bfd *, asymbol *));
529
530   /* The remaining functions are hooks which are called only if they
531      are not NULL.  */
532
533   /* A function to permit a backend specific check on whether a
534      particular BFD format is relevant for an object file, and to
535      permit the backend to set any global information it wishes.  When
536      this is called elf_elfheader is set, but anything else should be
537      used with caution.  If this returns FALSE, the check_format
538      routine will return a bfd_error_wrong_format error.  */
539   bfd_boolean (*elf_backend_object_p)
540     PARAMS ((bfd *));
541
542   /* A function to do additional symbol processing when reading the
543      ELF symbol table.  This is where any processor-specific special
544      section indices are handled.  */
545   void (*elf_backend_symbol_processing)
546     PARAMS ((bfd *, asymbol *));
547
548   /* A function to do additional symbol processing after reading the
549      entire ELF symbol table.  */
550   bfd_boolean (*elf_backend_symbol_table_processing)
551     PARAMS ((bfd *, elf_symbol_type *, unsigned int));
552
553    /* A function to set the type of the info field.  Processor-specific
554      types should be handled here.  */
555   int (*elf_backend_get_symbol_type)
556     PARAMS (( Elf_Internal_Sym *, int));
557
558   /* A function to do additional processing on the ELF section header
559      just before writing it out.  This is used to set the flags and
560      type fields for some sections, or to actually write out data for
561      unusual sections.  */
562   bfd_boolean (*elf_backend_section_processing)
563     PARAMS ((bfd *, Elf_Internal_Shdr *));
564
565   /* A function to handle unusual section types when creating BFD
566      sections from ELF sections.  */
567   bfd_boolean (*elf_backend_section_from_shdr)
568     PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
569
570   /* A function to convert machine dependent section header flags to
571      BFD internal section header flags.  */
572   bfd_boolean (*elf_backend_section_flags)
573     PARAMS ((flagword *, Elf_Internal_Shdr *));
574
575   /* A function to handle unusual program segment types when creating BFD
576      sections from ELF program segments.  */
577   bfd_boolean (*elf_backend_section_from_phdr)
578     PARAMS ((bfd *, Elf_Internal_Phdr *, int));
579
580   /* A function to set up the ELF section header for a BFD section in
581      preparation for writing it out.  This is where the flags and type
582      fields are set for unusual sections.  */
583   bfd_boolean (*elf_backend_fake_sections)
584     PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
585
586   /* A function to get the ELF section index for a BFD section.  If
587      this returns TRUE, the section was found.  If it is a normal ELF
588      section, *RETVAL should be left unchanged.  If it is not a normal
589      ELF section *RETVAL should be set to the SHN_xxxx index.  */
590   bfd_boolean (*elf_backend_section_from_bfd_section)
591     PARAMS ((bfd *, asection *, int *retval));
592
593   /* If this field is not NULL, it is called by the add_symbols phase
594      of a link just before adding a symbol to the global linker hash
595      table.  It may modify any of the fields as it wishes.  If *NAME
596      is set to NULL, the symbol will be skipped rather than being
597      added to the hash table.  This function is responsible for
598      handling all processor dependent symbol bindings and section
599      indices, and must set at least *FLAGS and *SEC for each processor
600      dependent case; failure to do so will cause a link error.  */
601   bfd_boolean (*elf_add_symbol_hook)
602     PARAMS ((bfd *abfd, struct bfd_link_info *info,
603              const Elf_Internal_Sym *, const char **name,
604              flagword *flags, asection **sec, bfd_vma *value));
605
606   /* If this field is not NULL, it is called by the elf_link_output_sym
607      phase of a link for each symbol which will appear in the object file.  */
608   bfd_boolean (*elf_backend_link_output_symbol_hook)
609     PARAMS ((bfd *, struct bfd_link_info *info, const char *,
610              Elf_Internal_Sym *, asection *));
611
612   /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend
613      linker the first time it encounters a dynamic object in the link.
614      This function must create any sections required for dynamic
615      linking.  The ABFD argument is a dynamic object.  The .interp,
616      .dynamic, .dynsym, .dynstr, and .hash functions have already been
617      created, and this function may modify the section flags if
618      desired.  This function will normally create the .got and .plt
619      sections, but different backends have different requirements.  */
620   bfd_boolean (*elf_backend_create_dynamic_sections)
621     PARAMS ((bfd *abfd, struct bfd_link_info *info));
622
623   /* The CHECK_RELOCS function is called by the add_symbols phase of
624      the ELF backend linker.  It is called once for each section with
625      relocs of an object file, just after the symbols for the object
626      file have been added to the global linker hash table.  The
627      function must look through the relocs and do any special handling
628      required.  This generally means allocating space in the global
629      offset table, and perhaps allocating space for a reloc.  The
630      relocs are always passed as Rela structures; if the section
631      actually uses Rel structures, the r_addend field will always be
632      zero.  */
633   bfd_boolean (*check_relocs)
634     PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *o,
635              const Elf_Internal_Rela *relocs));
636
637   /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend
638      linker for every symbol which is defined by a dynamic object and
639      referenced by a regular object.  This is called after all the
640      input files have been seen, but before the SIZE_DYNAMIC_SECTIONS
641      function has been called.  The hash table entry should be
642      bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be
643      defined in a section from a dynamic object.  Dynamic object
644      sections are not included in the final link, and this function is
645      responsible for changing the value to something which the rest of
646      the link can deal with.  This will normally involve adding an
647      entry to the .plt or .got or some such section, and setting the
648      symbol to point to that.  */
649   bfd_boolean (*elf_backend_adjust_dynamic_symbol)
650     PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h));
651
652   /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker
653      after all the linker input files have been seen but before the
654      section sizes have been set.  This is called after
655      ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS.  */
656   bfd_boolean (*elf_backend_always_size_sections)
657     PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
658
659   /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend
660      linker after all the linker input files have been seen but before
661      the sections sizes have been set.  This is called after
662      ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols.
663      It is only called when linking against a dynamic object.  It must
664      set the sizes of the dynamic sections, and may fill in their
665      contents as well.  The generic ELF linker can handle the .dynsym,
666      .dynstr and .hash sections.  This function must handle the
667      .interp section and any sections created by the
668      CREATE_DYNAMIC_SECTIONS entry point.  */
669   bfd_boolean (*elf_backend_size_dynamic_sections)
670     PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
671
672   /* The RELOCATE_SECTION function is called by the ELF backend linker
673      to handle the relocations for a section.
674
675      The relocs are always passed as Rela structures; if the section
676      actually uses Rel structures, the r_addend field will always be
677      zero.
678
679      This function is responsible for adjust the section contents as
680      necessary, and (if using Rela relocs and generating a
681      relocateable output file) adjusting the reloc addend as
682      necessary.
683
684      This function does not have to worry about setting the reloc
685      address or the reloc symbol index.
686
687      LOCAL_SYMS is a pointer to the swapped in local symbols.
688
689      LOCAL_SECTIONS is an array giving the section in the input file
690      corresponding to the st_shndx field of each local symbol.
691
692      The global hash table entry for the global symbols can be found
693      via elf_sym_hashes (input_bfd).
694
695      When generating relocateable output, this function must handle
696      STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
697      going to be the section symbol corresponding to the output
698      section, which means that the addend must be adjusted
699      accordingly.  */
700   bfd_boolean (*elf_backend_relocate_section)
701     PARAMS ((bfd *output_bfd, struct bfd_link_info *info,
702              bfd *input_bfd, asection *input_section, bfd_byte *contents,
703              Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
704              asection **local_sections));
705
706   /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend
707      linker just before it writes a symbol out to the .dynsym section.
708      The processor backend may make any required adjustment to the
709      symbol.  It may also take the opportunity to set contents of the
710      dynamic sections.  Note that FINISH_DYNAMIC_SYMBOL is called on
711      all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called
712      on those symbols which are defined by a dynamic object.  */
713   bfd_boolean (*elf_backend_finish_dynamic_symbol)
714     PARAMS ((bfd *output_bfd, struct bfd_link_info *info,
715              struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
716
717   /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend
718      linker just before it writes all the dynamic sections out to the
719      output file.  The FINISH_DYNAMIC_SYMBOL will have been called on
720      all dynamic symbols.  */
721   bfd_boolean (*elf_backend_finish_dynamic_sections)
722     PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
723
724   /* A function to do any beginning processing needed for the ELF file
725      before building the ELF headers and computing file positions.  */
726   void (*elf_backend_begin_write_processing)
727     PARAMS ((bfd *, struct bfd_link_info *));
728
729   /* A function to do any final processing needed for the ELF file
730      before writing it out.  The LINKER argument is TRUE if this BFD
731      was created by the ELF backend linker.  */
732   void (*elf_backend_final_write_processing)
733     PARAMS ((bfd *, bfd_boolean linker));
734
735   /* This function is called by get_program_header_size.  It should
736      return the number of additional program segments which this BFD
737      will need.  It should return -1 on error.  */
738   int (*elf_backend_additional_program_headers)
739     PARAMS ((bfd *));
740
741   /* This function is called to modify an existing segment map in a
742      backend specific fashion.  */
743   bfd_boolean (*elf_backend_modify_segment_map)
744     PARAMS ((bfd *));
745
746   /* This function is called during section gc to discover the section a
747      particular relocation refers to.  */
748   asection * (*gc_mark_hook)
749     PARAMS ((asection *sec, struct bfd_link_info *, Elf_Internal_Rela *,
750              struct elf_link_hash_entry *h, Elf_Internal_Sym *));
751
752   /* This function, if defined, is called during the sweep phase of gc
753      in order that a backend might update any data structures it might
754      be maintaining.  */
755   bfd_boolean (*gc_sweep_hook)
756     PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *o,
757              const Elf_Internal_Rela *relocs));
758
759   /* This function, if defined, is called after the ELF headers have
760      been created.  This allows for things like the OS and ABI versions
761      to be changed.  */
762   void (*elf_backend_post_process_headers)
763     PARAMS ((bfd *, struct bfd_link_info *));
764
765   /* This function, if defined, prints a symbol to file and returns the
766      name of the symbol to be printed.  It should return NULL to fall
767      back to default symbol printing.  */
768   const char *(*elf_backend_print_symbol_all)
769     PARAMS ((bfd *, PTR, asymbol *));
770
771   /* This function, if defined, is called after all local symbols and
772      global symbols converted to locals are emited into the symtab
773      section.  It allows the backend to emit special global symbols
774      not handled in the hash table.  */
775   bfd_boolean (*elf_backend_output_arch_syms)
776     PARAMS ((bfd *, struct bfd_link_info *, PTR,
777             bfd_boolean (*) (PTR, const char *, Elf_Internal_Sym *, asection *)));
778
779   /* Copy any information related to dynamic linking from a pre-existing
780      symbol to a newly created symbol.  Also called to copy flags and
781      other back-end info to a weakdef, in which case the symbol is not
782      newly created and plt/got refcounts and dynamic indices should not
783      be copied.  */
784   void (*elf_backend_copy_indirect_symbol)
785     PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
786              struct elf_link_hash_entry *));
787
788   /* Modify any information related to dynamic linking such that the
789      symbol is not exported.  */
790   void (*elf_backend_hide_symbol)
791     PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
792
793   /* Emit relocations.  Overrides default routine for emitting relocs,
794      except during a relocatable link, or if all relocs are being emitted.  */
795   bfd_boolean (*elf_backend_emit_relocs)
796     PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *));
797
798   /* Count relocations.  Not called for relocatable links
799      or if all relocs are being preserved in the output.  */
800   unsigned int (*elf_backend_count_relocs)
801     PARAMS ((asection *, Elf_Internal_Rela *));
802
803   /* This function, if defined, is called when an NT_PRSTATUS note is found
804      in a core file. */
805   bfd_boolean (*elf_backend_grok_prstatus)
806     PARAMS ((bfd *, Elf_Internal_Note *));
807
808   /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO
809      note is found in a core file. */
810   bfd_boolean (*elf_backend_grok_psinfo)
811     PARAMS ((bfd *, Elf_Internal_Note *));
812
813   /* Functions to print VMAs.  Special code to handle 64 bit ELF files.  */
814   void (* elf_backend_sprintf_vma)
815     PARAMS ((bfd *, char *, bfd_vma));
816   void (* elf_backend_fprintf_vma)
817     PARAMS ((bfd *, PTR, bfd_vma));
818
819   /* This function returns class of a reloc type.  */
820   enum elf_reloc_type_class (*elf_backend_reloc_type_class)
821     PARAMS ((const Elf_Internal_Rela *));
822
823   /* This function, if defined, removes information about discarded functions
824      from other sections which mention them.  */
825   bfd_boolean (*elf_backend_discard_info)
826     PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *));
827
828   /* This function, if defined, signals that the function above has removed
829      the discarded relocations for this section.  */
830   bfd_boolean (*elf_backend_ignore_discarded_relocs)
831     PARAMS ((asection *));
832
833   /* This function, if defined, may write out the given section.
834      Returns TRUE if it did so and FALSE if the caller should.  */
835   bfd_boolean (*elf_backend_write_section)
836     PARAMS ((bfd *, asection *, bfd_byte *));
837
838   /* The level of IRIX compatibility we're striving for.
839      MIPS ELF specific function.  */
840   irix_compat_t (*elf_backend_mips_irix_compat)
841     PARAMS ((bfd *));
842
843   reloc_howto_type *(*elf_backend_mips_rtype_to_howto)
844     PARAMS ((unsigned int, bfd_boolean));
845
846   /* The swapping table to use when dealing with ECOFF information.
847      Used for the MIPS ELF .mdebug section.  */
848   const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap;
849
850   /* Alternate EM_xxxx machine codes for this backend.  */
851   int elf_machine_alt1;
852   int elf_machine_alt2;
853
854   const struct elf_size_info *s;
855
856   /* offset of the _GLOBAL_OFFSET_TABLE_ symbol from the start of the
857      .got section */
858   bfd_vma got_symbol_offset;
859
860   /* The size in bytes of the headers for the GOT and PLT.  This includes
861      the so-called reserved entries on some systems.  */
862   bfd_vma got_header_size;
863   bfd_vma plt_header_size;
864
865   /* This is TRUE if the linker should act like collect and gather
866      global constructors and destructors by name.  This is TRUE for
867      MIPS ELF because the Irix 5 tools can not handle the .init
868      section.  */
869   unsigned collect : 1;
870
871   /* This is TRUE if the linker should ignore changes to the type of a
872      symbol.  This is TRUE for MIPS ELF because some Irix 5 objects
873      record undefined functions as STT_OBJECT although the definitions
874      are STT_FUNC.  */
875   unsigned type_change_ok : 1;
876
877   /* Whether the backend may use REL relocations.  (Some backends use
878      both REL and RELA relocations, and this flag is set for those
879      backends.)  */
880   unsigned may_use_rel_p : 1;
881
882   /* Whether the backend may use RELA relocations.  (Some backends use
883      both REL and RELA relocations, and this flag is set for those
884      backends.)  */
885   unsigned may_use_rela_p : 1;
886
887   /* Whether the default relocation type is RELA.  If a backend with
888      this flag set wants REL relocations for a particular section,
889      it must note that explicitly.  Similarly, if this flag is clear,
890      and the backend wants RELA relocations for a particular
891      section.  */
892   unsigned default_use_rela_p : 1;
893
894   /* Set if RELA relocations for a relocatable link can be handled by
895      generic code.  Backends that set this flag need do nothing in the
896      backend relocate_section routine for relocatable linking.  */
897   unsigned rela_normal : 1;
898
899   /* TRUE if addresses "naturally" sign extend.  This is used when
900      swapping in from Elf32 when BFD64.  */
901   unsigned sign_extend_vma : 1;
902
903   unsigned want_got_plt : 1;
904   unsigned plt_readonly : 1;
905   unsigned want_plt_sym : 1;
906   unsigned plt_not_loaded : 1;
907   unsigned plt_alignment : 4;
908   unsigned can_gc_sections : 1;
909   unsigned can_refcount : 1;
910   unsigned want_got_sym : 1;
911   unsigned want_dynbss : 1;
912     /* Targets which do not support physical addressing often require
913        that the p_paddr field in the section header to be set to zero.
914        This field indicates whether this behavior is required.  */
915   unsigned want_p_paddr_set_to_zero : 1;
916 };
917
918 /* Information stored for each BFD section in an ELF file.  This
919    structure is allocated by elf_new_section_hook.  */
920
921 struct bfd_elf_section_data
922 {
923   /* The ELF header for this section.  */
924   Elf_Internal_Shdr this_hdr;
925
926   /* The ELF header for the reloc section associated with this
927      section, if any.  */
928   Elf_Internal_Shdr rel_hdr;
929
930   /* If there is a second reloc section associated with this section,
931      as can happen on Irix 6, this field points to the header.  */
932   Elf_Internal_Shdr *rel_hdr2;
933
934   /* The number of relocations currently assigned to REL_HDR.  */
935   unsigned int rel_count;
936
937   /* The number of relocations currently assigned to REL_HDR2.  */
938   unsigned int rel_count2;
939
940   /* The ELF section number of this section.  Only used for an output
941      file.  */
942   int this_idx;
943
944   /* The ELF section number of the reloc section indicated by
945      REL_HDR if any.  Only used for an output file.  */
946   int rel_idx;
947
948   /* The ELF section number of the reloc section indicated by
949      REL_HDR2 if any.  Only used for an output file.  */
950   int rel_idx2;
951
952   /* Used by the backend linker when generating a shared library to
953      record the dynamic symbol index for a section symbol
954      corresponding to this section.  A value of 0 means that there is
955      no dynamic symbol for this section.  */
956   int dynindx;
957
958   /* Used by the backend linker to store the symbol hash table entries
959      associated with relocs against global symbols.  */
960   struct elf_link_hash_entry **rel_hashes;
961
962   /* A pointer to the swapped relocs.  If the section uses REL relocs,
963      rather than RELA, all the r_addend fields will be zero.  This
964      pointer may be NULL.  It is used by the backend linker.  */
965   Elf_Internal_Rela *relocs;
966
967   /* A pointer to a linked list tracking dynamic relocs copied for
968      local symbols.  */
969   PTR local_dynrel;
970
971   /* A pointer to the bfd section used for dynamic relocs.  */
972   asection *sreloc;
973
974   union {
975     /* Group name, if this section is a member of a group.  */
976     const char *name;
977
978     /* Group signature sym, if this is the SHT_GROUP section.  */
979     struct symbol_cache_entry *id;
980   } group;
981
982   /* A linked list of sections in the group.  Circular when used by
983      the linker.  */
984   asection *next_in_group;
985
986   /* A pointer used for various section optimizations.  */
987   PTR sec_info;
988 };
989
990 #define elf_section_data(sec)  ((struct bfd_elf_section_data*)sec->used_by_bfd)
991 #define elf_group_name(sec)    (elf_section_data(sec)->group.name)
992 #define elf_group_id(sec)      (elf_section_data(sec)->group.id)
993 #define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group)
994
995 /* Return TRUE if section has been discarded.  */
996 #define elf_discarded_section(sec)                              \
997   (!bfd_is_abs_section (sec)                                    \
998    && bfd_is_abs_section ((sec)->output_section)                \
999    && sec->sec_info_type != ELF_INFO_TYPE_MERGE                 \
1000    && sec->sec_info_type != ELF_INFO_TYPE_JUST_SYMS)
1001
1002 #define get_elf_backend_data(abfd) \
1003   ((struct elf_backend_data *) (abfd)->xvec->backend_data)
1004
1005 /* Enumeration to specify the special section.  */
1006 typedef enum elf_linker_section_enum
1007 {
1008   LINKER_SECTION_UNKNOWN,               /* not used */
1009   LINKER_SECTION_GOT,                   /* .got section for global offset pointers */
1010   LINKER_SECTION_PLT,                   /* .plt section for generated procedure stubs */
1011   LINKER_SECTION_SDATA,                 /* .sdata/.sbss section for PowerPC */
1012   LINKER_SECTION_SDATA2,                /* .sdata2/.sbss2 section for PowerPC */
1013   LINKER_SECTION_MAX                    /* # of linker sections */
1014 } elf_linker_section_enum_t;
1015
1016 /* Sections created by the linker.  */
1017
1018 typedef struct elf_linker_section
1019 {
1020   char *name;                           /* name of the section */
1021   char *rel_name;                       /* name of the associated .rel{,a}. section */
1022   char *bss_name;                       /* name of a related .bss section */
1023   char *sym_name;                       /* name of symbol to reference this section */
1024   asection *section;                    /* pointer to the section */
1025   asection *bss_section;                /* pointer to the bss section associated with this */
1026   asection *rel_section;                /* pointer to the relocations needed for this section */
1027   struct elf_link_hash_entry *sym_hash; /* pointer to the created symbol hash value */
1028   bfd_vma initial_size;                 /* initial size before any linker generated allocations */
1029   bfd_vma sym_offset;                   /* offset of symbol from beginning of section */
1030   bfd_vma hole_size;                    /* size of reserved address hole in allocation */
1031   bfd_vma hole_offset;                  /* current offset for the hole */
1032   bfd_vma max_hole_offset;              /* maximum offset for the hole */
1033   elf_linker_section_enum_t which;      /* which section this is */
1034   bfd_boolean hole_written_p;           /* whether the hole has been initialized */
1035   unsigned int alignment;               /* alignment for the section */
1036   flagword flags;                       /* flags to use to create the section */
1037 } elf_linker_section_t;
1038
1039 /* Linked list of allocated pointer entries.  This hangs off of the symbol lists, and
1040    provides allows us to return different pointers, based on different addend's.  */
1041
1042 typedef struct elf_linker_section_pointers
1043 {
1044   struct elf_linker_section_pointers *next;     /* next allocated pointer for this symbol */
1045   bfd_vma offset;                               /* offset of pointer from beginning of section */
1046   bfd_vma addend;                               /* addend used */
1047   elf_linker_section_enum_t which;              /* which linker section this is */
1048   bfd_boolean written_address_p;                /* whether address was written yet */
1049 } elf_linker_section_pointers_t;
1050
1051 /* Some private data is stashed away for future use using the tdata pointer
1052    in the bfd structure.  */
1053
1054 struct elf_obj_tdata
1055 {
1056   Elf_Internal_Ehdr elf_header[1];      /* Actual data, but ref like ptr */
1057   Elf_Internal_Shdr **elf_sect_ptr;
1058   Elf_Internal_Phdr *phdr;
1059   struct elf_segment_map *segment_map;
1060   struct elf_strtab_hash *strtab_ptr;
1061   int num_locals;
1062   int num_globals;
1063   unsigned int num_elf_sections;        /* elf_sect_ptr size */
1064   int num_section_syms;
1065   asymbol **section_syms;               /* STT_SECTION symbols for each section */
1066   Elf_Internal_Shdr symtab_hdr;
1067   Elf_Internal_Shdr shstrtab_hdr;
1068   Elf_Internal_Shdr strtab_hdr;
1069   Elf_Internal_Shdr dynsymtab_hdr;
1070   Elf_Internal_Shdr dynstrtab_hdr;
1071   Elf_Internal_Shdr dynversym_hdr;
1072   Elf_Internal_Shdr dynverref_hdr;
1073   Elf_Internal_Shdr dynverdef_hdr;
1074   Elf_Internal_Shdr symtab_shndx_hdr;
1075   unsigned int symtab_section, shstrtab_section;
1076   unsigned int strtab_section, dynsymtab_section;
1077   unsigned int symtab_shndx_section;
1078   unsigned int dynversym_section, dynverdef_section, dynverref_section;
1079   file_ptr next_file_pos;
1080 #if 0
1081   /* we don't need these inside bfd anymore, and I think
1082      these weren't used outside bfd.  */
1083   void *prstatus;                       /* The raw /proc prstatus structure */
1084   void *prpsinfo;                       /* The raw /proc prpsinfo structure */
1085 #endif
1086   bfd_vma gp;                           /* The gp value */
1087   unsigned int gp_size;                 /* The gp size */
1088
1089   Elf_Internal_Shdr **group_sect_ptr;
1090   int num_group;
1091
1092   /* Information grabbed from an elf core file.  */
1093   int core_signal;
1094   int core_pid;
1095   int core_lwpid;
1096   char* core_program;
1097   char* core_command;
1098
1099   /* This is set to TRUE if the object was created by the backend
1100      linker.  */
1101   bfd_boolean linker;
1102
1103   /* A mapping from external symbols to entries in the linker hash
1104      table, used when linking.  This is indexed by the symbol index
1105      minus the sh_info field of the symbol table header.  */
1106   struct elf_link_hash_entry **sym_hashes;
1107
1108   /* Track usage and final offsets of GOT entries for local symbols.
1109      This array is indexed by symbol index.  Elements are used
1110      identically to "got" in struct elf_link_hash_entry.  */
1111   union
1112     {
1113       bfd_signed_vma *refcounts;
1114       bfd_vma *offsets;
1115       struct got_entry **ents;
1116     } local_got;
1117
1118   /* A mapping from local symbols to offsets into the various linker
1119      sections added.  This is index by the symbol index.  */
1120   elf_linker_section_pointers_t **linker_section_pointers;
1121
1122   /* The linker ELF emulation code needs to let the backend ELF linker
1123      know what filename should be used for a dynamic object if the
1124      dynamic object is found using a search.  The emulation code then
1125      sometimes needs to know what name was actually used.  Until the
1126      file has been added to the linker symbol table, this field holds
1127      the name the linker wants.  After it has been added, it holds the
1128      name actually used, which will be the DT_SONAME entry if there is
1129      one.  */
1130   const char *dt_name;
1131
1132   /* When a reference in a regular object is resolved by a shared
1133      object is loaded into via the DT_NEEDED entries by the linker
1134      ELF emulation code, we need to add the shared object to the
1135      DT_NEEDED list of the resulting binary to indicate the dependency
1136      as if the -l option is passed to the linker. This field holds the
1137      name of the loaded shared object.  */
1138   const char *dt_soname;
1139
1140   /* Irix 5 often screws up the symbol table, sorting local symbols
1141      after global symbols.  This flag is set if the symbol table in
1142      this BFD appears to be screwed up.  If it is, we ignore the
1143      sh_info field in the symbol table header, and always read all the
1144      symbols.  */
1145   bfd_boolean bad_symtab;
1146
1147   /* Records the result of `get_program_header_size'.  */
1148   bfd_size_type program_header_size;
1149
1150   /* Used by find_nearest_line entry point.  */
1151   PTR line_info;
1152
1153   /* Used by MIPS ELF find_nearest_line entry point.  The structure
1154      could be included directly in this one, but there's no point to
1155      wasting the memory just for the infrequently called
1156      find_nearest_line.  */
1157   struct mips_elf_find_line *find_line_info;
1158
1159   /* A place to stash dwarf1 info for this bfd.  */
1160   struct dwarf1_debug *dwarf1_find_line_info;
1161
1162   /* A place to stash dwarf2 info for this bfd.  */
1163   PTR dwarf2_find_line_info;
1164
1165   /* An array of stub sections indexed by symbol number, used by the
1166      MIPS ELF linker.  FIXME: We should figure out some way to only
1167      include this field for a MIPS ELF target.  */
1168   asection **local_stubs;
1169
1170   /* Used to determine if PT_GNU_EH_FRAME segment header should be
1171      created.  */
1172   asection *eh_frame_hdr;
1173
1174   /* Used to determine if the e_flags field has been initialized */
1175   bfd_boolean flags_init;
1176
1177   /* Number of symbol version definitions we are about to emit.  */
1178   unsigned int cverdefs;
1179
1180   /* Number of symbol version references we are about to emit.  */
1181   unsigned int cverrefs;
1182
1183   /* Symbol version definitions in external objects.  */
1184   Elf_Internal_Verdef *verdef;
1185
1186   /* Symbol version references to external objects.  */
1187   Elf_Internal_Verneed *verref;
1188
1189   /* Linker sections that we are interested in.  */
1190   struct elf_linker_section *linker_section[ (int)LINKER_SECTION_MAX ];
1191
1192   /* The Irix 5 support uses two virtual sections, which represent
1193      text/data symbols defined in dynamic objects.  */
1194   asymbol *elf_data_symbol;
1195   asymbol *elf_text_symbol;
1196   asection *elf_data_section;
1197   asection *elf_text_section;
1198 };
1199
1200 #define elf_tdata(bfd)          ((bfd) -> tdata.elf_obj_data)
1201 #define elf_elfheader(bfd)      (elf_tdata(bfd) -> elf_header)
1202 #define elf_elfsections(bfd)    (elf_tdata(bfd) -> elf_sect_ptr)
1203 #define elf_numsections(bfd)    (elf_tdata(bfd) -> num_elf_sections)
1204 #define elf_shstrtab(bfd)       (elf_tdata(bfd) -> strtab_ptr)
1205 #define elf_onesymtab(bfd)      (elf_tdata(bfd) -> symtab_section)
1206 #define elf_symtab_shndx(bfd)   (elf_tdata(bfd) -> symtab_shndx_section)
1207 #define elf_dynsymtab(bfd)      (elf_tdata(bfd) -> dynsymtab_section)
1208 #define elf_dynversym(bfd)      (elf_tdata(bfd) -> dynversym_section)
1209 #define elf_dynverdef(bfd)      (elf_tdata(bfd) -> dynverdef_section)
1210 #define elf_dynverref(bfd)      (elf_tdata(bfd) -> dynverref_section)
1211 #define elf_num_locals(bfd)     (elf_tdata(bfd) -> num_locals)
1212 #define elf_num_globals(bfd)    (elf_tdata(bfd) -> num_globals)
1213 #define elf_section_syms(bfd)   (elf_tdata(bfd) -> section_syms)
1214 #define elf_num_section_syms(bfd) (elf_tdata(bfd) -> num_section_syms)
1215 #define core_prpsinfo(bfd)      (elf_tdata(bfd) -> prpsinfo)
1216 #define core_prstatus(bfd)      (elf_tdata(bfd) -> prstatus)
1217 #define elf_gp(bfd)             (elf_tdata(bfd) -> gp)
1218 #define elf_gp_size(bfd)        (elf_tdata(bfd) -> gp_size)
1219 #define elf_sym_hashes(bfd)     (elf_tdata(bfd) -> sym_hashes)
1220 #define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts)
1221 #define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets)
1222 #define elf_local_got_ents(bfd) (elf_tdata(bfd) -> local_got.ents)
1223 #define elf_local_ptr_offsets(bfd) (elf_tdata(bfd) -> linker_section_pointers)
1224 #define elf_dt_name(bfd)        (elf_tdata(bfd) -> dt_name)
1225 #define elf_dt_soname(bfd)      (elf_tdata(bfd) -> dt_soname)
1226 #define elf_bad_symtab(bfd)     (elf_tdata(bfd) -> bad_symtab)
1227 #define elf_flags_init(bfd)     (elf_tdata(bfd) -> flags_init)
1228 #define elf_linker_section(bfd,n) (elf_tdata(bfd) -> linker_section[(int)n])
1229 \f
1230 extern void _bfd_elf_swap_verdef_in
1231   PARAMS ((bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *));
1232 extern void _bfd_elf_swap_verdef_out
1233   PARAMS ((bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *));
1234 extern void _bfd_elf_swap_verdaux_in
1235   PARAMS ((bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *));
1236 extern void _bfd_elf_swap_verdaux_out
1237   PARAMS ((bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *));
1238 extern void _bfd_elf_swap_verneed_in
1239   PARAMS ((bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *));
1240 extern void _bfd_elf_swap_verneed_out
1241   PARAMS ((bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *));
1242 extern void _bfd_elf_swap_vernaux_in
1243   PARAMS ((bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *));
1244 extern void _bfd_elf_swap_vernaux_out
1245   PARAMS ((bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *));
1246 extern void _bfd_elf_swap_versym_in
1247   PARAMS ((bfd *, const Elf_External_Versym *, Elf_Internal_Versym *));
1248 extern void _bfd_elf_swap_versym_out
1249   PARAMS ((bfd *, const Elf_Internal_Versym *, Elf_External_Versym *));
1250
1251 extern int _bfd_elf_section_from_bfd_section
1252   PARAMS ((bfd *, asection *));
1253 extern char *bfd_elf_string_from_elf_section
1254   PARAMS ((bfd *, unsigned, unsigned));
1255 extern char *bfd_elf_get_str_section
1256   PARAMS ((bfd *, unsigned));
1257 extern Elf_Internal_Sym *bfd_elf_get_elf_syms
1258   PARAMS ((bfd *, Elf_Internal_Shdr *, size_t, size_t,
1259            Elf_Internal_Sym *, PTR, Elf_External_Sym_Shndx *));
1260 extern const char *bfd_elf_local_sym_name
1261   PARAMS ((bfd *, Elf_Internal_Sym *));
1262
1263 extern bfd_boolean _bfd_elf_copy_private_bfd_data
1264   PARAMS ((bfd *, bfd *));
1265 extern bfd_boolean _bfd_elf_print_private_bfd_data
1266   PARAMS ((bfd *, PTR));
1267 extern void bfd_elf_print_symbol
1268   PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
1269
1270 #define elf_string_from_elf_strtab(abfd, strindex) \
1271   bfd_elf_string_from_elf_section(abfd, elf_elfheader(abfd)->e_shstrndx, \
1272                                   strindex)
1273
1274 #define bfd_elf32_print_symbol  bfd_elf_print_symbol
1275 #define bfd_elf64_print_symbol  bfd_elf_print_symbol
1276
1277 extern void _bfd_elf_sprintf_vma
1278   PARAMS ((bfd *, char *, bfd_vma));
1279 extern void _bfd_elf_fprintf_vma
1280   PARAMS ((bfd *, PTR, bfd_vma));
1281
1282 extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
1283   PARAMS ((const Elf_Internal_Rela *));
1284 extern bfd_vma _bfd_elf_rela_local_sym
1285   PARAMS ((bfd *, Elf_Internal_Sym *, asection *, Elf_Internal_Rela *));
1286 extern bfd_vma _bfd_elf_rel_local_sym
1287   PARAMS ((bfd *, Elf_Internal_Sym *, asection **, bfd_vma));
1288 extern bfd_vma _bfd_elf_section_offset
1289   PARAMS ((bfd *, struct bfd_link_info *, asection *, bfd_vma));
1290
1291 extern unsigned long bfd_elf_hash
1292   PARAMS ((const char *));
1293
1294 extern bfd_reloc_status_type bfd_elf_generic_reloc
1295   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
1296 extern bfd_boolean bfd_elf_mkobject
1297   PARAMS ((bfd *));
1298 extern bfd_boolean bfd_elf_mkcorefile
1299   PARAMS ((bfd *));
1300 extern Elf_Internal_Shdr *bfd_elf_find_section
1301   PARAMS ((bfd *, char *));
1302 extern bfd_boolean _bfd_elf_make_section_from_shdr
1303   PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
1304 extern bfd_boolean _bfd_elf_make_section_from_phdr
1305   PARAMS ((bfd *, Elf_Internal_Phdr *, int, const char *));
1306 extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc
1307   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
1308 extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create
1309   PARAMS ((bfd *));
1310 extern void _bfd_elf_link_hash_copy_indirect
1311   PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
1312            struct elf_link_hash_entry *));
1313 extern void _bfd_elf_link_hash_hide_symbol
1314   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
1315 extern bfd_boolean _bfd_elf_link_hash_table_init
1316   PARAMS ((struct elf_link_hash_table *, bfd *,
1317            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
1318                                        struct bfd_hash_table *,
1319                                        const char *)));
1320 extern bfd_boolean _bfd_elf_slurp_version_tables
1321   PARAMS ((bfd *));
1322 extern bfd_boolean _bfd_elf_merge_sections
1323   PARAMS ((bfd *, struct bfd_link_info *));
1324 extern bfd_boolean bfd_elf_discard_group
1325   PARAMS ((bfd *, struct sec *));
1326 extern void bfd_elf_set_group_contents
1327   PARAMS ((bfd *, asection *, PTR));
1328 extern void _bfd_elf_link_just_syms
1329   PARAMS ((asection *, struct bfd_link_info *));
1330 extern bfd_boolean _bfd_elf_copy_private_symbol_data
1331   PARAMS ((bfd *, asymbol *, bfd *, asymbol *));
1332 extern bfd_boolean _bfd_elf_copy_private_section_data
1333   PARAMS ((bfd *, asection *, bfd *, asection *));
1334 extern bfd_boolean _bfd_elf_write_object_contents
1335   PARAMS ((bfd *));
1336 extern bfd_boolean _bfd_elf_write_corefile_contents
1337   PARAMS ((bfd *));
1338 extern bfd_boolean _bfd_elf_set_section_contents
1339   PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
1340 extern long _bfd_elf_get_symtab_upper_bound
1341   PARAMS ((bfd *));
1342 extern long _bfd_elf_get_symtab
1343   PARAMS ((bfd *, asymbol **));
1344 extern long _bfd_elf_get_dynamic_symtab_upper_bound
1345   PARAMS ((bfd *));
1346 extern long _bfd_elf_canonicalize_dynamic_symtab
1347   PARAMS ((bfd *, asymbol **));
1348 extern long _bfd_elf_get_reloc_upper_bound
1349   PARAMS ((bfd *, sec_ptr));
1350 extern long _bfd_elf_canonicalize_reloc
1351   PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
1352 extern long _bfd_elf_get_dynamic_reloc_upper_bound
1353   PARAMS ((bfd *));
1354 extern long _bfd_elf_canonicalize_dynamic_reloc
1355   PARAMS ((bfd *, arelent **, asymbol **));
1356 extern asymbol *_bfd_elf_make_empty_symbol
1357   PARAMS ((bfd *));
1358 extern void _bfd_elf_get_symbol_info
1359   PARAMS ((bfd *, asymbol *, symbol_info *));
1360 extern bfd_boolean _bfd_elf_is_local_label_name
1361   PARAMS ((bfd *, const char *));
1362 extern alent *_bfd_elf_get_lineno
1363   PARAMS ((bfd *, asymbol *));
1364 extern bfd_boolean _bfd_elf_set_arch_mach
1365   PARAMS ((bfd *, enum bfd_architecture, unsigned long));
1366 extern bfd_boolean _bfd_elf_find_nearest_line
1367   PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
1368            const char **, unsigned int *));
1369 #define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols
1370 #define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1371 extern int _bfd_elf_sizeof_headers
1372   PARAMS ((bfd *, bfd_boolean));
1373 extern bfd_boolean _bfd_elf_new_section_hook
1374   PARAMS ((bfd *, asection *));
1375 extern bfd_boolean _bfd_elf_init_reloc_shdr
1376   PARAMS ((bfd *, Elf_Internal_Shdr *, asection *, bfd_boolean));
1377
1378 /* If the target doesn't have reloc handling written yet:  */
1379 extern void _bfd_elf_no_info_to_howto
1380   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
1381
1382 extern bfd_boolean bfd_section_from_shdr
1383   PARAMS ((bfd *, unsigned int shindex));
1384 extern bfd_boolean bfd_section_from_phdr
1385   PARAMS ((bfd *, Elf_Internal_Phdr *, int));
1386
1387 extern int _bfd_elf_symbol_from_bfd_symbol
1388   PARAMS ((bfd *, asymbol **));
1389
1390 extern asection *bfd_section_from_r_symndx
1391   PARAMS ((bfd *, struct sym_sec_cache *, asection *, unsigned long));
1392 extern asection *bfd_section_from_elf_index
1393   PARAMS ((bfd *, unsigned int));
1394 extern bfd_boolean _bfd_elf_create_dynamic_sections
1395   PARAMS ((bfd *, struct bfd_link_info *));
1396 extern struct bfd_strtab_hash *_bfd_elf_stringtab_init
1397   PARAMS ((void));
1398
1399 extern struct elf_strtab_hash * _bfd_elf_strtab_init
1400   PARAMS ((void));
1401 extern void _bfd_elf_strtab_free
1402   PARAMS ((struct elf_strtab_hash *));
1403 extern bfd_size_type _bfd_elf_strtab_add
1404   PARAMS ((struct elf_strtab_hash *, const char *, bfd_boolean));
1405 extern void _bfd_elf_strtab_addref
1406   PARAMS ((struct elf_strtab_hash *, bfd_size_type));
1407 extern void _bfd_elf_strtab_delref
1408   PARAMS ((struct elf_strtab_hash *, bfd_size_type));
1409 extern void _bfd_elf_strtab_clear_all_refs
1410   PARAMS ((struct elf_strtab_hash *));
1411 extern bfd_size_type _bfd_elf_strtab_size
1412   PARAMS ((struct elf_strtab_hash *));
1413 extern bfd_size_type _bfd_elf_strtab_offset
1414   PARAMS ((struct elf_strtab_hash *, bfd_size_type));
1415 extern bfd_boolean _bfd_elf_strtab_emit
1416   PARAMS ((bfd *, struct elf_strtab_hash *));
1417 extern void _bfd_elf_strtab_finalize
1418   PARAMS ((struct elf_strtab_hash *));
1419
1420 extern bfd_boolean _bfd_elf_discard_section_eh_frame
1421   PARAMS ((bfd *, struct bfd_link_info *, asection *,
1422            bfd_boolean (*) (bfd_vma, PTR), struct elf_reloc_cookie *));
1423 extern bfd_boolean _bfd_elf_discard_section_eh_frame_hdr
1424   PARAMS ((bfd *, struct bfd_link_info *));
1425 extern bfd_vma _bfd_elf_eh_frame_section_offset
1426   PARAMS ((bfd *, asection *, bfd_vma));
1427 extern bfd_boolean _bfd_elf_write_section_eh_frame
1428   PARAMS ((bfd *, struct bfd_link_info *, asection *, bfd_byte *));
1429 extern bfd_boolean _bfd_elf_write_section_eh_frame_hdr
1430   PARAMS ((bfd *, struct bfd_link_info *));
1431 extern bfd_boolean _bfd_elf_maybe_strip_eh_frame_hdr
1432   PARAMS ((struct bfd_link_info *));
1433
1434 extern bfd_boolean _bfd_elf_link_record_dynamic_symbol
1435   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
1436 extern long _bfd_elf_link_lookup_local_dynindx
1437   PARAMS ((struct bfd_link_info *, bfd *, long));
1438 extern bfd_boolean _bfd_elf_compute_section_file_positions
1439   PARAMS ((bfd *, struct bfd_link_info *));
1440 extern void _bfd_elf_assign_file_positions_for_relocs
1441   PARAMS ((bfd *));
1442 extern file_ptr _bfd_elf_assign_file_position_for_section
1443   PARAMS ((Elf_Internal_Shdr *, file_ptr, bfd_boolean));
1444
1445 extern bfd_boolean _bfd_elf_validate_reloc
1446   PARAMS ((bfd *, arelent *));
1447
1448 extern bfd_boolean _bfd_elf_create_dynamic_sections
1449   PARAMS ((bfd *, struct bfd_link_info *));
1450 extern bfd_boolean _bfd_elf_create_got_section
1451   PARAMS ((bfd *, struct bfd_link_info *));
1452 extern unsigned long _bfd_elf_link_renumber_dynsyms
1453   PARAMS ((bfd *, struct bfd_link_info *));
1454
1455 extern bfd_boolean _bfd_elfcore_make_pseudosection
1456   PARAMS ((bfd *, char *, size_t, ufile_ptr));
1457 extern char *_bfd_elfcore_strndup
1458   PARAMS ((bfd *, char *, size_t));
1459
1460 extern elf_linker_section_t *_bfd_elf_create_linker_section
1461   PARAMS ((bfd *, struct bfd_link_info *, enum elf_linker_section_enum,
1462            elf_linker_section_t *));
1463
1464 extern elf_linker_section_pointers_t *_bfd_elf_find_pointer_linker_section
1465   PARAMS ((elf_linker_section_pointers_t *, bfd_vma,
1466            elf_linker_section_enum_t));
1467
1468 extern bfd_boolean bfd_elf32_create_pointer_linker_section
1469   PARAMS ((bfd *, struct bfd_link_info *, elf_linker_section_t *,
1470            struct elf_link_hash_entry *, const Elf_Internal_Rela *));
1471
1472 extern bfd_vma bfd_elf32_finish_pointer_linker_section
1473   PARAMS ((bfd *, bfd *, struct bfd_link_info *, elf_linker_section_t *,
1474            struct elf_link_hash_entry *, bfd_vma,
1475            const Elf_Internal_Rela *, int));
1476
1477 extern bfd_boolean bfd_elf64_create_pointer_linker_section
1478   PARAMS ((bfd *, struct bfd_link_info *, elf_linker_section_t *,
1479            struct elf_link_hash_entry *, const Elf_Internal_Rela *));
1480
1481 extern bfd_vma bfd_elf64_finish_pointer_linker_section
1482   PARAMS ((bfd *, bfd *, struct bfd_link_info *, elf_linker_section_t *,
1483            struct elf_link_hash_entry *, bfd_vma,
1484            const Elf_Internal_Rela *, int));
1485
1486 extern bfd_boolean _bfd_elf_make_linker_section_rela
1487   PARAMS ((bfd *, elf_linker_section_t *, int));
1488
1489 extern const bfd_target *bfd_elf32_object_p
1490   PARAMS ((bfd *));
1491 extern const bfd_target *bfd_elf32_core_file_p
1492   PARAMS ((bfd *));
1493 extern char *bfd_elf32_core_file_failing_command
1494   PARAMS ((bfd *));
1495 extern int bfd_elf32_core_file_failing_signal
1496   PARAMS ((bfd *));
1497 extern bfd_boolean bfd_elf32_core_file_matches_executable_p
1498   PARAMS ((bfd *, bfd *));
1499
1500 extern bfd_boolean bfd_elf32_bfd_link_add_symbols
1501   PARAMS ((bfd *, struct bfd_link_info *));
1502 extern bfd_boolean bfd_elf32_bfd_final_link
1503   PARAMS ((bfd *, struct bfd_link_info *));
1504
1505 extern void bfd_elf32_swap_symbol_in
1506   PARAMS ((bfd *, const PTR, const PTR, Elf_Internal_Sym *));
1507 extern void bfd_elf32_swap_symbol_out
1508   PARAMS ((bfd *, const Elf_Internal_Sym *, PTR, PTR));
1509 extern void bfd_elf32_swap_reloc_in
1510   PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
1511 extern void bfd_elf32_swap_reloc_out
1512   PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
1513 extern void bfd_elf32_swap_reloca_in
1514   PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
1515 extern void bfd_elf32_swap_reloca_out
1516   PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
1517 extern void bfd_elf32_swap_phdr_in
1518   PARAMS ((bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *));
1519 extern void bfd_elf32_swap_phdr_out
1520   PARAMS ((bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *));
1521 extern void bfd_elf32_swap_dyn_in
1522   PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1523 extern void bfd_elf32_swap_dyn_out
1524   PARAMS ((bfd *, const Elf_Internal_Dyn *, PTR));
1525 extern long bfd_elf32_slurp_symbol_table
1526   PARAMS ((bfd *, asymbol **, bfd_boolean));
1527 extern bfd_boolean bfd_elf32_write_shdrs_and_ehdr
1528   PARAMS ((bfd *));
1529 extern int bfd_elf32_write_out_phdrs
1530   PARAMS ((bfd *, const Elf_Internal_Phdr *, unsigned int));
1531 extern void bfd_elf32_write_relocs
1532   PARAMS ((bfd *, asection *, PTR));
1533 extern bfd_boolean bfd_elf32_slurp_reloc_table
1534   PARAMS ((bfd *, asection *, asymbol **, bfd_boolean));
1535 extern bfd_boolean bfd_elf32_add_dynamic_entry
1536   PARAMS ((struct bfd_link_info *, bfd_vma, bfd_vma));
1537 extern bfd_boolean bfd_elf32_link_create_dynamic_sections
1538   PARAMS ((bfd *, struct bfd_link_info *));
1539 extern Elf_Internal_Rela *_bfd_elf32_link_read_relocs
1540   PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, bfd_boolean));
1541
1542 extern const bfd_target *bfd_elf64_object_p
1543   PARAMS ((bfd *));
1544 extern const bfd_target *bfd_elf64_core_file_p
1545   PARAMS ((bfd *));
1546 extern char *bfd_elf64_core_file_failing_command
1547   PARAMS ((bfd *));
1548 extern int bfd_elf64_core_file_failing_signal
1549   PARAMS ((bfd *));
1550 extern bfd_boolean bfd_elf64_core_file_matches_executable_p
1551   PARAMS ((bfd *, bfd *));
1552 extern bfd_boolean bfd_elf64_bfd_link_add_symbols
1553   PARAMS ((bfd *, struct bfd_link_info *));
1554 extern bfd_boolean bfd_elf64_bfd_final_link
1555   PARAMS ((bfd *, struct bfd_link_info *));
1556
1557 extern void bfd_elf64_swap_symbol_in
1558   PARAMS ((bfd *, const PTR, const PTR, Elf_Internal_Sym *));
1559 extern void bfd_elf64_swap_symbol_out
1560   PARAMS ((bfd *, const Elf_Internal_Sym *, PTR, PTR));
1561 extern void bfd_elf64_swap_reloc_in
1562   PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
1563 extern void bfd_elf64_swap_reloc_out
1564   PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
1565 extern void bfd_elf64_swap_reloca_in
1566   PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
1567 extern void bfd_elf64_swap_reloca_out
1568   PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
1569 extern void bfd_elf64_swap_phdr_in
1570   PARAMS ((bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *));
1571 extern void bfd_elf64_swap_phdr_out
1572   PARAMS ((bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *));
1573 extern void bfd_elf64_swap_dyn_in
1574   PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1575 extern void bfd_elf64_swap_dyn_out
1576   PARAMS ((bfd *, const Elf_Internal_Dyn *, PTR));
1577 extern long bfd_elf64_slurp_symbol_table
1578   PARAMS ((bfd *, asymbol **, bfd_boolean));
1579 extern bfd_boolean bfd_elf64_write_shdrs_and_ehdr
1580   PARAMS ((bfd *));
1581 extern int bfd_elf64_write_out_phdrs
1582   PARAMS ((bfd *, const Elf_Internal_Phdr *, unsigned int));
1583 extern void bfd_elf64_write_relocs
1584   PARAMS ((bfd *, asection *, PTR));
1585 extern bfd_boolean bfd_elf64_slurp_reloc_table
1586   PARAMS ((bfd *, asection *, asymbol **, bfd_boolean));
1587 extern bfd_boolean bfd_elf64_add_dynamic_entry
1588   PARAMS ((struct bfd_link_info *, bfd_vma, bfd_vma));
1589 extern bfd_boolean bfd_elf64_link_create_dynamic_sections
1590   PARAMS ((bfd *, struct bfd_link_info *));
1591 extern Elf_Internal_Rela *_bfd_elf64_link_read_relocs
1592   PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, bfd_boolean));
1593
1594 #define bfd_elf32_link_record_dynamic_symbol \
1595   _bfd_elf_link_record_dynamic_symbol
1596 #define bfd_elf64_link_record_dynamic_symbol \
1597   _bfd_elf_link_record_dynamic_symbol
1598
1599 extern int elf_link_record_local_dynamic_symbol
1600   PARAMS ((struct bfd_link_info *, bfd *, long));
1601 #define _bfd_elf32_link_record_local_dynamic_symbol \
1602   elf_link_record_local_dynamic_symbol
1603 #define _bfd_elf64_link_record_local_dynamic_symbol \
1604   elf_link_record_local_dynamic_symbol
1605
1606 extern bfd_boolean _bfd_elf_close_and_cleanup
1607   PARAMS ((bfd *));
1608 extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn
1609   PARAMS ((bfd *, arelent *, struct symbol_cache_entry *, PTR,
1610            asection *, bfd *, char **));
1611
1612 extern bfd_boolean _bfd_elf32_gc_sections
1613   PARAMS ((bfd *, struct bfd_link_info *));
1614 extern bfd_boolean _bfd_elf32_gc_common_finalize_got_offsets
1615   PARAMS ((bfd *, struct bfd_link_info *));
1616 extern bfd_boolean _bfd_elf32_gc_common_final_link
1617   PARAMS ((bfd *, struct bfd_link_info *));
1618 extern bfd_boolean _bfd_elf32_gc_record_vtinherit
1619   PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma));
1620 extern bfd_boolean _bfd_elf32_gc_record_vtentry
1621   PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma));
1622
1623 extern bfd_boolean _bfd_elf64_gc_sections
1624   PARAMS ((bfd *, struct bfd_link_info *));
1625 extern bfd_boolean _bfd_elf64_gc_common_finalize_got_offsets
1626   PARAMS ((bfd *, struct bfd_link_info *));
1627 extern bfd_boolean _bfd_elf64_gc_common_final_link
1628   PARAMS ((bfd *, struct bfd_link_info *));
1629 extern bfd_boolean _bfd_elf64_gc_record_vtinherit
1630   PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma));
1631 extern bfd_boolean _bfd_elf64_gc_record_vtentry
1632   PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma));
1633
1634 extern bfd_boolean _bfd_elf32_reloc_symbol_deleted_p
1635   PARAMS ((bfd_vma, PTR));
1636 extern bfd_boolean _bfd_elf64_reloc_symbol_deleted_p
1637   PARAMS ((bfd_vma, PTR));
1638
1639 /* Exported interface for writing elf corefile notes. */
1640 extern char *elfcore_write_note
1641   PARAMS ((bfd *, char *, int *, const char *, int, const PTR, int));
1642 extern char *elfcore_write_prpsinfo
1643   PARAMS ((bfd *, char *, int *, const char *, const char *));
1644 extern char *elfcore_write_prstatus
1645   PARAMS ((bfd *, char *, int *, long, int, const PTR));
1646 extern char * elfcore_write_pstatus
1647   PARAMS ((bfd *, char *, int *, long, int, const PTR));
1648 extern char *elfcore_write_prfpreg
1649   PARAMS ((bfd *, char *, int *, const PTR, int));
1650 extern char *elfcore_write_prxfpreg
1651   PARAMS ((bfd *, char *, int *, const PTR, int));
1652 extern char *elfcore_write_lwpstatus
1653   PARAMS ((bfd *, char *, int *, long, int, const PTR));
1654
1655 /* SH ELF specific routine.  */
1656
1657 extern bfd_boolean _sh_elf_set_mach_from_flags
1658   PARAMS ((bfd *));
1659
1660 #endif /* _LIBELF_H_ */