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