OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [bfd/] [elf-bfd.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.