source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/hardware/tools/avr/x86_64-pc-linux-gnu/avr/include/bfdlink.h @ 4837

Last change on this file since 4837 was 4837, checked in by daduve, 2 years ago

Adding new version

File size: 31.9 KB
Line 
1/* bfdlink.h -- header file for BFD link routines
2   Copyright (C) 1993-2015 Free Software Foundation, Inc.
3   Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support.
4
5   This file is part of BFD, the Binary File Descriptor library.
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 3 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program; if not, write to the Free Software
19   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20   MA 02110-1301, USA.  */
21
22#ifndef BFDLINK_H
23#define BFDLINK_H
24
25/* Which symbols to strip during a link.  */
26enum bfd_link_strip
27{
28  strip_none,           /* Don't strip any symbols.  */
29  strip_debugger,       /* Strip debugging symbols.  */
30  strip_some,           /* keep_hash is the list of symbols to keep.  */
31  strip_all             /* Strip all symbols.  */
32};
33
34/* Which local symbols to discard during a link.  This is irrelevant
35   if strip_all is used.  */
36enum bfd_link_discard
37{
38  discard_sec_merge,    /* Discard local temporary symbols in SEC_MERGE
39                           sections.  */
40  discard_none,         /* Don't discard any locals.  */
41  discard_l,            /* Discard local temporary symbols.  */
42  discard_all           /* Discard all locals.  */
43};
44
45/* Describes the type of hash table entry structure being used.
46   Different hash table structure have different fields and so
47   support different linking features.  */
48enum bfd_link_hash_table_type
49  {
50    bfd_link_generic_hash_table,
51    bfd_link_elf_hash_table
52  };
53
54/* These are the possible types of an entry in the BFD link hash
55   table.  */
56
57enum bfd_link_hash_type
58{
59  bfd_link_hash_new,            /* Symbol is new.  */
60  bfd_link_hash_undefined,      /* Symbol seen before, but undefined.  */
61  bfd_link_hash_undefweak,      /* Symbol is weak and undefined.  */
62  bfd_link_hash_defined,        /* Symbol is defined.  */
63  bfd_link_hash_defweak,        /* Symbol is weak and defined.  */
64  bfd_link_hash_common,         /* Symbol is common.  */
65  bfd_link_hash_indirect,       /* Symbol is an indirect link.  */
66  bfd_link_hash_warning         /* Like indirect, but warn if referenced.  */
67};
68
69enum bfd_link_common_skip_ar_symbols
70{
71  bfd_link_common_skip_none,
72  bfd_link_common_skip_text,
73  bfd_link_common_skip_data,
74  bfd_link_common_skip_all
75};
76
77struct bfd_link_hash_common_entry
78  {
79    unsigned int alignment_power;       /* Alignment.  */
80    asection *section;          /* Symbol section.  */
81  };
82
83/* The linking routines use a hash table which uses this structure for
84   its elements.  */
85
86struct bfd_link_hash_entry
87{
88  /* Base hash table entry structure.  */
89  struct bfd_hash_entry root;
90
91  /* Type of this entry.  */
92  ENUM_BITFIELD (bfd_link_hash_type) type : 8;
93
94  /* Symbol is referenced in a normal object file, as distict from a LTO
95     IR object file.  */
96  unsigned int non_ir_ref : 1;
97
98  /* Symbol is a built-in define.  These will be overridden by PROVIDE
99     in a linker script.  */
100  unsigned int linker_def : 1;
101
102  /* A union of information depending upon the type.  */
103  union
104    {
105      /* Nothing is kept for bfd_hash_new.  */
106      /* bfd_link_hash_undefined, bfd_link_hash_undefweak.  */
107      struct
108        {
109          /* Undefined and common symbols are kept in a linked list through
110             this field.  This field is present in all of the union element
111             so that we don't need to remove entries from the list when we
112             change their type.  Removing entries would either require the
113             list to be doubly linked, which would waste more memory, or
114             require a traversal.  When an undefined or common symbol is
115             created, it should be added to this list, the head of which is in
116             the link hash table itself.  As symbols are defined, they need
117             not be removed from the list; anything which reads the list must
118             doublecheck the symbol type.
119
120             Weak symbols are not kept on this list.
121
122             Defined and defweak symbols use this field as a reference marker.
123             If the field is not NULL, or this structure is the tail of the
124             undefined symbol list, the symbol has been referenced.  If the
125             symbol is undefined and becomes defined, this field will
126             automatically be non-NULL since the symbol will have been on the
127             undefined symbol list.  */
128          struct bfd_link_hash_entry *next;
129          bfd *abfd;            /* BFD symbol was found in.  */
130        } undef;
131      /* bfd_link_hash_defined, bfd_link_hash_defweak.  */
132      struct
133        {
134          struct bfd_link_hash_entry *next;
135          asection *section;    /* Symbol section.  */
136          bfd_vma value;        /* Symbol value.  */
137        } def;
138      /* bfd_link_hash_indirect, bfd_link_hash_warning.  */
139      struct
140        {
141          struct bfd_link_hash_entry *next;
142          struct bfd_link_hash_entry *link;     /* Real symbol.  */
143          const char *warning;  /* Warning (bfd_link_hash_warning only).  */
144        } i;
145      /* bfd_link_hash_common.  */
146      struct
147        {
148          struct bfd_link_hash_entry *next;
149          /* The linker needs to know three things about common
150             symbols: the size, the alignment, and the section in
151             which the symbol should be placed.  We store the size
152             here, and we allocate a small structure to hold the
153             section and the alignment.  The alignment is stored as a
154             power of two.  We don't store all the information
155             directly because we don't want to increase the size of
156             the union; this structure is a major space user in the
157             linker.  */
158          struct bfd_link_hash_common_entry *p;
159          bfd_size_type size;   /* Common symbol size.  */
160        } c;
161    } u;
162};
163
164/* This is the link hash table.  It is a derived class of
165   bfd_hash_table.  */
166
167struct bfd_link_hash_table
168{
169  /* The hash table itself.  */
170  struct bfd_hash_table table;
171  /* A linked list of undefined and common symbols, linked through the
172     next field in the bfd_link_hash_entry structure.  */
173  struct bfd_link_hash_entry *undefs;
174  /* Entries are added to the tail of the undefs list.  */
175  struct bfd_link_hash_entry *undefs_tail;
176  /* Function to free the hash table on closing BFD.  */
177  void (*hash_table_free) (bfd *);
178  /* The type of the link hash table.  */
179  enum bfd_link_hash_table_type type;
180};
181
182/* Look up an entry in a link hash table.  If FOLLOW is TRUE, this
183   follows bfd_link_hash_indirect and bfd_link_hash_warning links to
184   the real symbol.  */
185extern struct bfd_link_hash_entry *bfd_link_hash_lookup
186  (struct bfd_link_hash_table *, const char *, bfd_boolean create,
187   bfd_boolean copy, bfd_boolean follow);
188
189/* Look up an entry in the main linker hash table if the symbol might
190   be wrapped.  This should only be used for references to an
191   undefined symbol, not for definitions of a symbol.  */
192
193extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup
194  (bfd *, struct bfd_link_info *, const char *, bfd_boolean,
195   bfd_boolean, bfd_boolean);
196
197/* If H is a wrapped symbol, ie. the symbol name starts with "__wrap_"
198   and the remainder is found in wrap_hash, return the real symbol.  */
199
200extern struct bfd_link_hash_entry *unwrap_hash_lookup
201  (struct bfd_link_info *, bfd *, struct bfd_link_hash_entry *);
202
203/* Traverse a link hash table.  */
204extern void bfd_link_hash_traverse
205  (struct bfd_link_hash_table *,
206    bfd_boolean (*) (struct bfd_link_hash_entry *, void *),
207    void *);
208
209/* Add an entry to the undefs list.  */
210extern void bfd_link_add_undef
211  (struct bfd_link_hash_table *, struct bfd_link_hash_entry *);
212
213/* Remove symbols from the undefs list that don't belong there.  */
214extern void bfd_link_repair_undef_list
215  (struct bfd_link_hash_table *table);
216
217/* Read symbols and cache symbol pointer array in outsymbols.  */
218extern bfd_boolean bfd_generic_link_read_symbols (bfd *);
219
220struct bfd_sym_chain
221{
222  struct bfd_sym_chain *next;
223  const char *name;
224};
225
226/* How to handle unresolved symbols.
227   There are four possibilities which are enumerated below:  */
228enum report_method
229{
230  /* This is the initial value when then link_info structure is created.
231     It allows the various stages of the linker to determine whether they
232     allowed to set the value.  */
233  RM_NOT_YET_SET = 0,
234  RM_IGNORE,
235  RM_GENERATE_WARNING,
236  RM_GENERATE_ERROR
237};
238
239typedef enum {with_flags, without_flags} flag_type;
240
241/* A section flag list.  */
242struct flag_info_list
243{
244  flag_type with;
245  const char *name;
246  bfd_boolean valid;
247  struct flag_info_list *next;
248};
249
250/* Section flag info.  */
251struct flag_info
252{
253  flagword only_with_flags;
254  flagword not_with_flags;
255  struct flag_info_list *flag_list;
256  bfd_boolean flags_initialized;
257};
258
259struct bfd_elf_dynamic_list;
260struct bfd_elf_version_tree;
261
262/* Types of output.  */
263
264enum output_type
265{
266  type_pde,
267  type_pie,
268  type_relocatable,
269  type_dll,
270};
271
272#define bfd_link_pde(info)         ((info)->type == type_pde)
273#define bfd_link_dll(info)         ((info)->type == type_dll)
274#define bfd_link_relocatable(info) ((info)->type == type_relocatable)
275#define bfd_link_pie(info)         ((info)->type == type_pie)
276#define bfd_link_executable(info)  (bfd_link_pde (info) || bfd_link_pie (info))
277#define bfd_link_pic(info)         (bfd_link_dll (info) || bfd_link_pie (info))
278
279/* This structure holds all the information needed to communicate
280   between BFD and the linker when doing a link.  */
281
282struct bfd_link_info
283{
284  /* Output type.  */
285  ENUM_BITFIELD (output_type) type : 2;
286
287  /* TRUE if BFD should pre-bind symbols in a shared object.  */
288  unsigned int symbolic: 1;
289
290  /* TRUE if executable should not contain copy relocs.
291     Setting this true may result in a non-sharable text segment.  */
292  unsigned int nocopyreloc: 1;
293
294  /* TRUE if BFD should export all symbols in the dynamic symbol table
295     of an executable, rather than only those used.  */
296  unsigned int export_dynamic: 1;
297
298  /* TRUE if a default symbol version should be created and used for
299     exported symbols.  */
300  unsigned int create_default_symver: 1;
301
302  /* TRUE if unreferenced sections should be removed.  */
303  unsigned int gc_sections: 1;
304
305  /* TRUE if every symbol should be reported back via the notice
306     callback.  */
307  unsigned int notice_all: 1;
308
309  /* TRUE if the LTO plugin is active.  */
310  unsigned int lto_plugin_active: 1;
311
312  /* TRUE if global symbols in discarded sections should be stripped.  */
313  unsigned int strip_discarded: 1;
314
315  /* TRUE if all data symbols should be dynamic.  */
316  unsigned int dynamic_data: 1;
317
318  /* Which symbols to strip.  */
319  ENUM_BITFIELD (bfd_link_strip) strip : 2;
320
321  /* Which local symbols to discard.  */
322  ENUM_BITFIELD (bfd_link_discard) discard : 2;
323
324  /* Criteria for skipping symbols when determining
325     whether to include an object from an archive. */
326  ENUM_BITFIELD (bfd_link_common_skip_ar_symbols) common_skip_ar_symbols : 2;
327
328  /* What to do with unresolved symbols in an object file.
329     When producing executables the default is GENERATE_ERROR.
330     When producing shared libraries the default is IGNORE.  The
331     assumption with shared libraries is that the reference will be
332     resolved at load/execution time.  */
333  ENUM_BITFIELD (report_method) unresolved_syms_in_objects : 2;
334
335  /* What to do with unresolved symbols in a shared library.
336     The same defaults apply.  */
337  ENUM_BITFIELD (report_method) unresolved_syms_in_shared_libs : 2;
338
339  /* TRUE if shared objects should be linked directly, not shared.  */
340  unsigned int static_link: 1;
341
342  /* TRUE if symbols should be retained in memory, FALSE if they
343     should be freed and reread.  */
344  unsigned int keep_memory: 1;
345
346  /* TRUE if BFD should generate relocation information in the final
347     executable.  */
348  unsigned int emitrelocations: 1;
349
350  /* TRUE if PT_GNU_RELRO segment should be created.  */
351  unsigned int relro: 1;
352
353  /* Nonzero if .eh_frame_hdr section and PT_GNU_EH_FRAME ELF segment
354     should be created.  1 for DWARF2 tables, 2 for compact tables.  */
355  unsigned int eh_frame_hdr_type: 2;
356
357  /* TRUE if we should warn when adding a DT_TEXTREL to a shared object.  */
358  unsigned int warn_shared_textrel: 1;
359
360  /* TRUE if we should error when adding a DT_TEXTREL.  */
361  unsigned int error_textrel: 1;
362
363  /* TRUE if .hash section should be created.  */
364  unsigned int emit_hash: 1;
365
366  /* TRUE if .gnu.hash section should be created.  */
367  unsigned int emit_gnu_hash: 1;
368
369  /* If TRUE reduce memory overheads, at the expense of speed. This will
370     cause map file generation to use an O(N^2) algorithm and disable
371     caching ELF symbol buffer.  */
372  unsigned int reduce_memory_overheads: 1;
373
374  /* TRUE if the output file should be in a traditional format.  This
375     is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag
376     on the output file, but may be checked when reading the input
377     files.  */
378  unsigned int traditional_format: 1;
379
380  /* TRUE if non-PLT relocs should be merged into one reloc section
381     and sorted so that relocs against the same symbol come together.  */
382  unsigned int combreloc: 1;
383
384  /* TRUE if a default symbol version should be created and used for
385     imported symbols.  */
386  unsigned int default_imported_symver: 1;
387
388  /* TRUE if the new ELF dynamic tags are enabled. */
389  unsigned int new_dtags: 1;
390
391  /* FALSE if .eh_frame unwind info should be generated for PLT and other
392     linker created sections, TRUE if it should be omitted.  */
393  unsigned int no_ld_generated_unwind_info: 1;
394
395  /* TRUE if BFD should generate a "task linked" object file,
396     similar to relocatable but also with globals converted to
397     statics.  */
398  unsigned int task_link: 1;
399
400  /* TRUE if ok to have multiple definition.  */
401  unsigned int allow_multiple_definition: 1;
402
403  /* TRUE if ok to have version with no definition.  */
404  unsigned int allow_undefined_version: 1;
405
406  /* TRUE if some symbols have to be dynamic, controlled by
407     --dynamic-list command line options.  */
408  unsigned int dynamic: 1;
409
410  /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W|PF_X
411     flags.  */
412  unsigned int execstack: 1;
413
414  /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W
415     flags.  */
416  unsigned int noexecstack: 1;
417
418  /* TRUE if we want to produced optimized output files.  This might
419     need much more time and therefore must be explicitly selected.  */
420  unsigned int optimize: 1;
421
422  /* TRUE if user should be informed of removed unreferenced sections.  */
423  unsigned int print_gc_sections: 1;
424
425  /* TRUE if we should warn alternate ELF machine code.  */
426  unsigned int warn_alternate_em: 1;
427
428  /* TRUE if the linker script contained an explicit PHDRS command.  */
429  unsigned int user_phdrs: 1;
430
431  /* TRUE if BND prefix in PLT entries is always generated.  */
432  unsigned int bndplt: 1;
433
434  /* TRUE if generation of .interp/PT_INTERP should be suppressed.  */
435  unsigned int nointerp: 1;
436
437  /* TRUE if generate a 1-byte NOP as suffix for x86 call instruction.  */
438  unsigned int call_nop_as_suffix : 1;
439
440  /* The 1-byte NOP for x86 call instruction.  */
441  char call_nop_byte;
442
443  /* Char that may appear as the first char of a symbol, but should be
444     skipped (like symbol_leading_char) when looking up symbols in
445     wrap_hash.  Used by PowerPC Linux for 'dot' symbols.  */
446  char wrap_char;
447
448  /* Separator between archive and filename in linker script filespecs.  */
449  char path_separator;
450
451  /* Compress DWARF debug sections.  */
452  enum compressed_debug_section_type compress_debug;
453
454  /* Default stack size.  Zero means default (often zero itself), -1
455     means explicitly zero-sized.  */
456  bfd_signed_vma stacksize;
457
458  /* Enable or disable target specific optimizations.
459
460     Not all targets have optimizations to enable.
461
462     Normally these optimizations are disabled by default but some targets
463     prefer to enable them by default.  So this field is a tri-state variable.
464     The values are:
465     
466     zero: Enable the optimizations (either from --relax being specified on
467       the command line or the backend's before_allocation emulation function.
468       
469     positive: The user has requested that these optimizations be disabled.
470       (Via the --no-relax command line option).
471
472     negative: The optimizations are disabled.  (Set when initializing the
473       args_type structure in ldmain.c:main.  */
474  signed int disable_target_specific_optimizations;
475
476  /* Function callbacks.  */
477  const struct bfd_link_callbacks *callbacks;
478
479  /* Hash table handled by BFD.  */
480  struct bfd_link_hash_table *hash;
481
482  /* Hash table of symbols to keep.  This is NULL unless strip is
483     strip_some.  */
484  struct bfd_hash_table *keep_hash;
485
486  /* Hash table of symbols to report back via the notice callback.  If
487     this is NULL, and notice_all is FALSE, then no symbols are
488     reported back.  */
489  struct bfd_hash_table *notice_hash;
490
491  /* Hash table of symbols which are being wrapped (the --wrap linker
492     option).  If this is NULL, no symbols are being wrapped.  */
493  struct bfd_hash_table *wrap_hash;
494
495  /* Hash table of symbols which may be left unresolved during
496     a link.  If this is NULL, no symbols can be left unresolved.  */
497  struct bfd_hash_table *ignore_hash;
498
499  /* The output BFD.  */
500  bfd *output_bfd;
501
502  /* The list of input BFD's involved in the link.  These are chained
503     together via the link.next field.  */
504  bfd *input_bfds;
505  bfd **input_bfds_tail;
506
507  /* If a symbol should be created for each input BFD, this is section
508     where those symbols should be placed.  It must be a section in
509     the output BFD.  It may be NULL, in which case no such symbols
510     will be created.  This is to support CREATE_OBJECT_SYMBOLS in the
511     linker command language.  */
512  asection *create_object_symbols_section;
513
514  /* List of global symbol names that are starting points for marking
515     sections against garbage collection.  */
516  struct bfd_sym_chain *gc_sym_list;
517
518  /* If a base output file is wanted, then this points to it */
519  void *base_file;
520
521  /* The function to call when the executable or shared object is
522     loaded.  */
523  const char *init_function;
524
525  /* The function to call when the executable or shared object is
526     unloaded.  */
527  const char *fini_function;
528
529  /* Number of relaxation passes.  Usually only one relaxation pass
530     is needed.  But a backend can have as many relaxation passes as
531     necessary.  During bfd_relax_section call, it is set to the
532     current pass, starting from 0.  */
533  int relax_pass;
534
535  /* Number of relaxation trips.  This number is incremented every
536     time the relaxation pass is restarted due to a previous
537     relaxation returning true in *AGAIN.  */
538  int relax_trip;
539
540  /* > 0 to treat protected data defined in the shared library as
541     reference external.  0 to treat it as internal.  -1 to let
542     backend to decide.  */
543  int extern_protected_data;
544
545  /* Non-zero if auto-import thunks for DATA items in pei386 DLLs
546     should be generated/linked against.  Set to 1 if this feature
547     is explicitly requested by the user, -1 if enabled by default.  */
548  int pei386_auto_import;
549
550  /* Non-zero if runtime relocs for DATA items with non-zero addends
551     in pei386 DLLs should be generated.  Set to 1 if this feature
552     is explicitly requested by the user, -1 if enabled by default.  */
553  int pei386_runtime_pseudo_reloc;
554
555  /* How many spare .dynamic DT_NULL entries should be added?  */
556  unsigned int spare_dynamic_tags;
557
558  /* May be used to set DT_FLAGS for ELF. */
559  bfd_vma flags;
560
561  /* May be used to set DT_FLAGS_1 for ELF. */
562  bfd_vma flags_1;
563
564  /* Start and end of RELRO region.  */
565  bfd_vma relro_start, relro_end;
566
567  /* List of symbols should be dynamic.  */
568  struct bfd_elf_dynamic_list *dynamic_list;
569
570  /* The version information.  */
571  struct bfd_elf_version_tree *version_info;
572};
573
574/* This structures holds a set of callback functions.  These are called
575   by the BFD linker routines.  Except for the info functions, the first
576   argument to each callback function is the bfd_link_info structure
577   being used and each function returns a boolean value.  If the
578   function returns FALSE, then the BFD function which called it should
579   return with a failure indication.  */
580
581struct bfd_link_callbacks
582{
583  /* A function which is called when an object is added from an
584     archive.  ABFD is the archive element being added.  NAME is the
585     name of the symbol which caused the archive element to be pulled
586     in.  This function may set *SUBSBFD to point to an alternative
587     BFD from which symbols should in fact be added in place of the
588     original BFD's symbols.  */
589  bfd_boolean (*add_archive_element)
590    (struct bfd_link_info *, bfd *abfd, const char *name, bfd **subsbfd);
591  /* A function which is called when a symbol is found with multiple
592     definitions.  H is the symbol which is defined multiple times.
593     NBFD is the new BFD, NSEC is the new section, and NVAL is the new
594     value.  NSEC may be bfd_com_section or bfd_ind_section.  */
595  bfd_boolean (*multiple_definition)
596    (struct bfd_link_info *, struct bfd_link_hash_entry *h,
597     bfd *nbfd, asection *nsec, bfd_vma nval);
598  /* A function which is called when a common symbol is defined
599     multiple times.  H is the symbol appearing multiple times.
600     NBFD is the BFD of the new symbol.  NTYPE is the type of the new
601     symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or
602     bfd_link_hash_indirect.  If NTYPE is bfd_link_hash_common, NSIZE
603     is the size of the new symbol.  */
604  bfd_boolean (*multiple_common)
605    (struct bfd_link_info *, struct bfd_link_hash_entry *h,
606     bfd *nbfd, enum bfd_link_hash_type ntype, bfd_vma nsize);
607  /* A function which is called to add a symbol to a set.  ENTRY is
608     the link hash table entry for the set itself (e.g.,
609     __CTOR_LIST__).  RELOC is the relocation to use for an entry in
610     the set when generating a relocatable file, and is also used to
611     get the size of the entry when generating an executable file.
612     ABFD, SEC and VALUE identify the value to add to the set.  */
613  bfd_boolean (*add_to_set)
614    (struct bfd_link_info *, struct bfd_link_hash_entry *entry,
615     bfd_reloc_code_real_type reloc, bfd *abfd, asection *sec, bfd_vma value);
616  /* A function which is called when the name of a g++ constructor or
617     destructor is found.  This is only called by some object file
618     formats.  CONSTRUCTOR is TRUE for a constructor, FALSE for a
619     destructor.  This will use BFD_RELOC_CTOR when generating a
620     relocatable file.  NAME is the name of the symbol found.  ABFD,
621     SECTION and VALUE are the value of the symbol.  */
622  bfd_boolean (*constructor)
623    (struct bfd_link_info *, bfd_boolean constructor, const char *name,
624     bfd *abfd, asection *sec, bfd_vma value);
625  /* A function which is called to issue a linker warning.  For
626     example, this is called when there is a reference to a warning
627     symbol.  WARNING is the warning to be issued.  SYMBOL is the name
628     of the symbol which triggered the warning; it may be NULL if
629     there is none.  ABFD, SECTION and ADDRESS identify the location
630     which trigerred the warning; either ABFD or SECTION or both may
631     be NULL if the location is not known.  */
632  bfd_boolean (*warning)
633    (struct bfd_link_info *, const char *warning, const char *symbol,
634     bfd *abfd, asection *section, bfd_vma address);
635  /* A function which is called when a relocation is attempted against
636     an undefined symbol.  NAME is the symbol which is undefined.
637     ABFD, SECTION and ADDRESS identify the location from which the
638     reference is made. IS_FATAL indicates whether an undefined symbol is
639     a fatal error or not. In some cases SECTION may be NULL.  */
640  bfd_boolean (*undefined_symbol)
641    (struct bfd_link_info *, const char *name, bfd *abfd,
642     asection *section, bfd_vma address, bfd_boolean is_fatal);
643  /* A function which is called when a reloc overflow occurs. ENTRY is
644     the link hash table entry for the symbol the reloc is against.
645     NAME is the name of the local symbol or section the reloc is
646     against, RELOC_NAME is the name of the relocation, and ADDEND is
647     any addend that is used.  ABFD, SECTION and ADDRESS identify the
648     location at which the overflow occurs; if this is the result of a
649     bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
650     ABFD will be NULL.  */
651  bfd_boolean (*reloc_overflow)
652    (struct bfd_link_info *, struct bfd_link_hash_entry *entry,
653     const char *name, const char *reloc_name, bfd_vma addend,
654     bfd *abfd, asection *section, bfd_vma address);
655  /* A function which is called when a dangerous reloc is performed.
656     MESSAGE is an appropriate message.
657     ABFD, SECTION and ADDRESS identify the location at which the
658     problem occurred; if this is the result of a
659     bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
660     ABFD will be NULL.  */
661  bfd_boolean (*reloc_dangerous)
662    (struct bfd_link_info *, const char *message,
663     bfd *abfd, asection *section, bfd_vma address);
664  /* A function which is called when a reloc is found to be attached
665     to a symbol which is not being written out.  NAME is the name of
666     the symbol.  ABFD, SECTION and ADDRESS identify the location of
667     the reloc; if this is the result of a
668     bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
669     ABFD will be NULL.  */
670  bfd_boolean (*unattached_reloc)
671    (struct bfd_link_info *, const char *name,
672     bfd *abfd, asection *section, bfd_vma address);
673  /* A function which is called when a symbol in notice_hash is
674     defined or referenced.  H is the symbol, INH the indirect symbol
675     if applicable.  ABFD, SECTION and ADDRESS are the (new) value of
676     the symbol.  If SECTION is bfd_und_section, this is a reference.
677     FLAGS are the symbol BSF_* flags.  */
678  bfd_boolean (*notice)
679    (struct bfd_link_info *, struct bfd_link_hash_entry *h,
680     struct bfd_link_hash_entry *inh,
681     bfd *abfd, asection *section, bfd_vma address, flagword flags);
682  /* Error or warning link info message.  */
683  void (*einfo)
684    (const char *fmt, ...);
685  /* General link info message.  */
686  void (*info)
687    (const char *fmt, ...);
688  /* Message to be printed in linker map file.  */
689  void (*minfo)
690    (const char *fmt, ...);
691  /* This callback provides a chance for users of the BFD library to
692     override its decision about whether to place two adjacent sections
693     into the same segment.  */
694  bfd_boolean (*override_segment_assignment)
695    (struct bfd_link_info *, bfd * abfd,
696     asection * current_section, asection * previous_section,
697     bfd_boolean new_segment);
698};
699
700/* The linker builds link_order structures which tell the code how to
701   include input data in the output file.  */
702
703/* These are the types of link_order structures.  */
704
705enum bfd_link_order_type
706{
707  bfd_undefined_link_order,     /* Undefined.  */
708  bfd_indirect_link_order,      /* Built from a section.  */
709  bfd_data_link_order,          /* Set to explicit data.  */
710  bfd_section_reloc_link_order, /* Relocate against a section.  */
711  bfd_symbol_reloc_link_order   /* Relocate against a symbol.  */
712};
713
714/* This is the link_order structure itself.  These form a chain
715   attached to the output section whose contents they are describing.  */
716
717struct bfd_link_order
718{
719  /* Next link_order in chain.  */
720  struct bfd_link_order *next;
721  /* Type of link_order.  */
722  enum bfd_link_order_type type;
723  /* Offset within output section.  */
724  bfd_vma offset;
725  /* Size within output section.  */
726  bfd_size_type size;
727  /* Type specific information.  */
728  union
729    {
730      struct
731        {
732          /* Section to include.  If this is used, then
733             section->output_section must be the section the
734             link_order is attached to, section->output_offset must
735             equal the link_order offset field, and section->size
736             must equal the link_order size field.  Maybe these
737             restrictions should be relaxed someday.  */
738          asection *section;
739        } indirect;
740      struct
741        {
742          /* Size of contents, or zero when contents should be filled by
743             the architecture-dependent fill function.
744             A non-zero value allows filling of the output section
745             with an arbitrary repeated pattern.  */
746          unsigned int size;
747          /* Data to put into file.  */
748          bfd_byte *contents;
749        } data;
750      struct
751        {
752          /* Description of reloc to generate.  Used for
753             bfd_section_reloc_link_order and
754             bfd_symbol_reloc_link_order.  */
755          struct bfd_link_order_reloc *p;
756        } reloc;
757    } u;
758};
759
760/* A linker order of type bfd_section_reloc_link_order or
761   bfd_symbol_reloc_link_order means to create a reloc against a
762   section or symbol, respectively.  This is used to implement -Ur to
763   generate relocs for the constructor tables.  The
764   bfd_link_order_reloc structure describes the reloc that BFD should
765   create.  It is similar to a arelent, but I didn't use arelent
766   because the linker does not know anything about most symbols, and
767   any asymbol structure it creates will be partially meaningless.
768   This information could logically be in the bfd_link_order struct,
769   but I didn't want to waste the space since these types of relocs
770   are relatively rare.  */
771
772struct bfd_link_order_reloc
773{
774  /* Reloc type.  */
775  bfd_reloc_code_real_type reloc;
776
777  union
778    {
779      /* For type bfd_section_reloc_link_order, this is the section
780         the reloc should be against.  This must be a section in the
781         output BFD, not any of the input BFDs.  */
782      asection *section;
783      /* For type bfd_symbol_reloc_link_order, this is the name of the
784         symbol the reloc should be against.  */
785      const char *name;
786    } u;
787
788  /* Addend to use.  The object file should contain zero.  The BFD
789     backend is responsible for filling in the contents of the object
790     file correctly.  For some object file formats (e.g., COFF) the
791     addend must be stored into in the object file, and for some
792     (e.g., SPARC a.out) it is kept in the reloc.  */
793  bfd_vma addend;
794};
795
796/* Allocate a new link_order for a section.  */
797extern struct bfd_link_order *bfd_new_link_order (bfd *, asection *);
798
799/* These structures are used to describe version information for the
800   ELF linker.  These structures could be manipulated entirely inside
801   BFD, but it would be a pain.  Instead, the regular linker sets up
802   these structures, and then passes them into BFD.  */
803
804/* Glob pattern for a version.  */
805
806struct bfd_elf_version_expr
807{
808  /* Next glob pattern for this version.  */
809  struct bfd_elf_version_expr *next;
810  /* Glob pattern.  */
811  const char *pattern;
812  /* Set if pattern is not a glob.  */
813  unsigned int literal : 1;
814  /* Defined by ".symver".  */
815  unsigned int symver : 1;
816  /* Defined by version script.  */
817  unsigned int script : 1;
818  /* Pattern type.  */
819#define BFD_ELF_VERSION_C_TYPE          1
820#define BFD_ELF_VERSION_CXX_TYPE        2
821#define BFD_ELF_VERSION_JAVA_TYPE       4
822  unsigned int mask : 3;
823};
824
825struct bfd_elf_version_expr_head
826{
827  /* List of all patterns, both wildcards and non-wildcards.  */
828  struct bfd_elf_version_expr *list;
829  /* Hash table for non-wildcards.  */
830  void *htab;
831  /* Remaining patterns.  */
832  struct bfd_elf_version_expr *remaining;
833  /* What kind of pattern types are present in list (bitmask).  */
834  unsigned int mask;
835};
836
837/* Version dependencies.  */
838
839struct bfd_elf_version_deps
840{
841  /* Next dependency for this version.  */
842  struct bfd_elf_version_deps *next;
843  /* The version which this version depends upon.  */
844  struct bfd_elf_version_tree *version_needed;
845};
846
847/* A node in the version tree.  */
848
849struct bfd_elf_version_tree
850{
851  /* Next version.  */
852  struct bfd_elf_version_tree *next;
853  /* Name of this version.  */
854  const char *name;
855  /* Version number.  */
856  unsigned int vernum;
857  /* Regular expressions for global symbols in this version.  */
858  struct bfd_elf_version_expr_head globals;
859  /* Regular expressions for local symbols in this version.  */
860  struct bfd_elf_version_expr_head locals;
861  /* List of versions which this version depends upon.  */
862  struct bfd_elf_version_deps *deps;
863  /* Index of the version name.  This is used within BFD.  */
864  unsigned int name_indx;
865  /* Whether this version tree was used.  This is used within BFD.  */
866  int used;
867  /* Matching hook.  */
868  struct bfd_elf_version_expr *(*match)
869    (struct bfd_elf_version_expr_head *head,
870     struct bfd_elf_version_expr *prev, const char *sym);
871};
872
873struct bfd_elf_dynamic_list
874{
875  struct bfd_elf_version_expr_head head;
876  struct bfd_elf_version_expr *(*match)
877    (struct bfd_elf_version_expr_head *head,
878     struct bfd_elf_version_expr *prev, const char *sym);
879};
880
881#endif
Note: See TracBrowser for help on using the repository browser.