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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [include/] [bfdlink.h] - Blame information for rev 98

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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