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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [include/] [bfdlink.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/* bfdlink.h -- header file for BFD link routines
2
   Copyright 1993, 94, 95, 96, 97, 1999 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
 
21
#ifndef BFDLINK_H
22
#define BFDLINK_H
23
 
24
/* Which symbols to strip during a link.  */
25
enum bfd_link_strip
26
{
27
  strip_none,           /* Don't strip any symbols.  */
28
  strip_debugger,       /* Strip debugging symbols.  */
29
  strip_some,           /* keep_hash is the list of symbols to keep.  */
30
  strip_all             /* Strip all symbols.  */
31
};
32
 
33
/* Which local symbols to discard during a link.  This is irrelevant
34
   if strip_all is used.  */
35
enum bfd_link_discard
36
{
37
  discard_none,         /* Don't discard any locals.  */
38
  discard_l,            /* Discard local temporary symbols.  */
39
  discard_all           /* Discard all locals.  */
40
};
41
 
42
/* These are the possible types of an entry in the BFD link hash
43
   table.  */
44
 
45
enum bfd_link_hash_type
46
{
47
  bfd_link_hash_new,            /* Symbol is new.  */
48
  bfd_link_hash_undefined,      /* Symbol seen before, but undefined.  */
49
  bfd_link_hash_undefweak,      /* Symbol is weak and undefined.  */
50
  bfd_link_hash_defined,        /* Symbol is defined.  */
51
  bfd_link_hash_defweak,        /* Symbol is weak and defined.  */
52
  bfd_link_hash_common,         /* Symbol is common.  */
53
  bfd_link_hash_indirect,       /* Symbol is an indirect link.  */
54
  bfd_link_hash_warning         /* Like indirect, but warn if referenced.  */
55
};
56
 
57
/* The linking routines use a hash table which uses this structure for
58
   its elements.  */
59
 
60
struct bfd_link_hash_entry
61
{
62
  /* Base hash table entry structure.  */
63
  struct bfd_hash_entry root;
64
  /* Type of this entry.  */
65
  enum bfd_link_hash_type type;
66
 
67
  /* Undefined and common symbols are kept in a linked list through
68
     this field.  This field is not in the union because that would
69
     force us to remove entries from the list when we changed their
70
     type, which would force the list to be doubly linked, which would
71
     waste more memory.  When an undefined or common symbol is
72
     created, it should be added to this list, the head of which is in
73
     the link hash table itself.  As symbols are defined, they need
74
     not be removed from the list; anything which reads the list must
75
     doublecheck the symbol type.
76
 
77
     Weak symbols are not kept on this list.
78
 
79
     Defined and defweak symbols use this field as a reference marker.
80
     If the field is not NULL, or this structure is the tail of the
81
     undefined symbol list, the symbol has been referenced.  If the
82
     symbol is undefined and becomes defined, this field will
83
     automatically be non-NULL since the symbol will have been on the
84
     undefined symbol list.  */
85
  struct bfd_link_hash_entry *next;
86
  /* A union of information depending upon the type.  */
87
  union
88
    {
89
      /* Nothing is kept for bfd_hash_new.  */
90
      /* bfd_link_hash_undefined, bfd_link_hash_undefweak.  */
91
      struct
92
        {
93
          bfd *abfd;            /* BFD symbol was found in.  */
94
        } undef;
95
      /* bfd_link_hash_defined, bfd_link_hash_defweak.  */
96
      struct
97
        {
98
          bfd_vma value;        /* Symbol value.  */
99
          asection *section;    /* Symbol section.  */
100
        } def;
101
      /* bfd_link_hash_indirect, bfd_link_hash_warning.  */
102
      struct
103
        {
104
          struct bfd_link_hash_entry *link;     /* Real symbol.  */
105
          const char *warning;  /* Warning (bfd_link_hash_warning only).  */
106
        } i;
107
      /* bfd_link_hash_common.  */
108
      struct
109
        {
110
          /* The linker needs to know three things about common
111
             symbols: the size, the alignment, and the section in
112
             which the symbol should be placed.  We store the size
113
             here, and we allocate a small structure to hold the
114
             section and the alignment.  The alignment is stored as a
115
             power of two.  We don't store all the information
116
             directly because we don't want to increase the size of
117
             the union; this structure is a major space user in the
118
             linker.  */
119
          bfd_size_type size;   /* Common symbol size.  */
120
          struct bfd_link_hash_common_entry
121
            {
122
              unsigned int alignment_power;     /* Alignment.  */
123
              asection *section;                /* Symbol section.  */
124
            } *p;
125
        } c;
126
    } u;
127
};
128
 
129
/* This is the link hash table.  It is a derived class of
130
   bfd_hash_table.  */
131
 
132
struct bfd_link_hash_table
133
{
134
  /* The hash table itself.  */
135
  struct bfd_hash_table table;
136
  /* The back end which created this hash table.  This indicates the
137
     type of the entries in the hash table, which is sometimes
138
     important information when linking object files of different
139
     types together.  */
140
  const bfd_target *creator;
141
  /* A linked list of undefined and common symbols, linked through the
142
     next field in the bfd_link_hash_entry structure.  */
143
  struct bfd_link_hash_entry *undefs;
144
  /* Entries are added to the tail of the undefs list.  */
145
  struct bfd_link_hash_entry *undefs_tail;
146
};
147
 
148
/* Look up an entry in a link hash table.  If FOLLOW is true, this
149
   follows bfd_link_hash_indirect and bfd_link_hash_warning links to
150
   the real symbol.  */
151
extern struct bfd_link_hash_entry *bfd_link_hash_lookup
152
  PARAMS ((struct bfd_link_hash_table *, const char *, boolean create,
153
           boolean copy, boolean follow));
154
 
155
/* Look up an entry in the main linker hash table if the symbol might
156
   be wrapped.  This should only be used for references to an
157
   undefined symbol, not for definitions of a symbol.  */
158
 
159
extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup
160
  PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean, boolean,
161
           boolean));
162
 
163
/* Traverse a link hash table.  */
164
extern void bfd_link_hash_traverse
165
  PARAMS ((struct bfd_link_hash_table *,
166
           boolean (*) (struct bfd_link_hash_entry *, PTR),
167
           PTR));
168
 
169
/* Add an entry to the undefs list.  */
170
extern void bfd_link_add_undef
171
  PARAMS ((struct bfd_link_hash_table *, struct bfd_link_hash_entry *));
172
 
173
/* This structure holds all the information needed to communicate
174
   between BFD and the linker when doing a link.  */
175
 
176
struct bfd_link_info
177
{
178
  /* Function callbacks.  */
179
  const struct bfd_link_callbacks *callbacks;
180
  /* true if BFD should generate a relocateable object file.  */
181
  boolean relocateable;
182
  /* true if BFD should generate a "task linked" object file,
183
     similar to relocatable but also with globals converted to statics. */
184
  boolean task_link;
185
  /* true if BFD should generate a shared object.  */
186
  boolean shared;
187
  /* true if BFD should pre-bind symbols in a shared object.  */
188
  boolean symbolic;
189
  /* true if shared objects should be linked directly, not shared.  */
190
  boolean static_link;
191
  /* true if the output file should be in a traditional format.  This
192
     is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag
193
     on the output file, but may be checked when reading the input
194
     files.  */
195
  boolean traditional_format;
196
  /* true if we want to produced optimized output files.  This might
197
     need much more time and therefore must be explicitly selected.  */
198
  boolean optimize;
199
  /* true if BFD should generate errors for undefined symbols
200
     even if generating a shared object.  */
201
  boolean no_undefined;
202
  /* Which symbols to strip.  */
203
  enum bfd_link_strip strip;
204
  /* Which local symbols to discard.  */
205
  enum bfd_link_discard discard;
206
  /* true if symbols should be retained in memory, false if they
207
     should be freed and reread.  */
208
  boolean keep_memory;
209
  /* The list of input BFD's involved in the link.  These are chained
210
     together via the link_next field.  */
211
  bfd *input_bfds;
212
  /* If a symbol should be created for each input BFD, this is section
213
     where those symbols should be placed.  It must be a section in
214
     the output BFD.  It may be NULL, in which case no such symbols
215
     will be created.  This is to support CREATE_OBJECT_SYMBOLS in the
216
     linker command language.  */
217
  asection *create_object_symbols_section;
218
  /* Hash table handled by BFD.  */
219
  struct bfd_link_hash_table *hash;
220
  /* Hash table of symbols to keep.  This is NULL unless strip is
221
     strip_some.  */
222
  struct bfd_hash_table *keep_hash;
223
  /* true if every symbol should be reported back via the notice
224
     callback.  */
225
  boolean notice_all;
226
  /* Hash table of symbols to report back via the notice callback.  If
227
     this is NULL, and notice_all is false, then no symbols are
228
     reported back.  */
229
  struct bfd_hash_table *notice_hash;
230
  /* Hash table of symbols which are being wrapped (the --wrap linker
231
     option).  If this is NULL, no symbols are being wrapped.  */
232
  struct bfd_hash_table *wrap_hash;
233
  /* If a base output file is wanted, then this points to it */
234
  PTR base_file;
235
 
236
  /* If non-zero, specifies that branches which are problematic for the
237
  MPC860 C0 (or earlier) should be checked for and modified.  It gives the
238
  number of bytes that should be checked at the end of each text page. */
239
  int mpc860c0;
240
 
241
  /* The function to call when the executable or shared object is
242
     loaded.  */
243
  const char *init_function;
244
  /* The function to call when the executable or shared object is
245
     unloaded.  */
246
  const char *fini_function;
247
};
248
 
249
/* This structures holds a set of callback functions.  These are
250
   called by the BFD linker routines.  The first argument to each
251
   callback function is the bfd_link_info structure being used.  Each
252
   function returns a boolean value.  If the function returns false,
253
   then the BFD function which called it will return with a failure
254
   indication.  */
255
 
256
struct bfd_link_callbacks
257
{
258
  /* A function which is called when an object is added from an
259
     archive.  ABFD is the archive element being added.  NAME is the
260
     name of the symbol which caused the archive element to be pulled
261
     in.  */
262
  boolean (*add_archive_element) PARAMS ((struct bfd_link_info *,
263
                                          bfd *abfd,
264
                                          const char *name));
265
  /* A function which is called when a symbol is found with multiple
266
     definitions.  NAME is the symbol which is defined multiple times.
267
     OBFD is the old BFD, OSEC is the old section, OVAL is the old
268
     value, NBFD is the new BFD, NSEC is the new section, and NVAL is
269
     the new value.  OBFD may be NULL.  OSEC and NSEC may be
270
     bfd_com_section or bfd_ind_section.  */
271
  boolean (*multiple_definition) PARAMS ((struct bfd_link_info *,
272
                                          const char *name,
273
                                          bfd *obfd,
274
                                          asection *osec,
275
                                          bfd_vma oval,
276
                                          bfd *nbfd,
277
                                          asection *nsec,
278
                                          bfd_vma nval));
279
  /* A function which is called when a common symbol is defined
280
     multiple times.  NAME is the symbol appearing multiple times.
281
     OBFD is the BFD of the existing symbol; it may be NULL if this is
282
     not known.  OTYPE is the type of the existing symbol, which may
283
     be bfd_link_hash_defined, bfd_link_hash_defweak,
284
     bfd_link_hash_common, or bfd_link_hash_indirect.  If OTYPE is
285
     bfd_link_hash_common, OSIZE is the size of the existing symbol.
286
     NBFD is the BFD of the new symbol.  NTYPE is the type of the new
287
     symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or
288
     bfd_link_hash_indirect.  If NTYPE is bfd_link_hash_common, NSIZE
289
     is the size of the new symbol.  */
290
  boolean (*multiple_common) PARAMS ((struct bfd_link_info *,
291
                                      const char *name,
292
                                      bfd *obfd,
293
                                      enum bfd_link_hash_type otype,
294
                                      bfd_vma osize,
295
                                      bfd *nbfd,
296
                                      enum bfd_link_hash_type ntype,
297
                                      bfd_vma nsize));
298
  /* A function which is called to add a symbol to a set.  ENTRY is
299
     the link hash table entry for the set itself (e.g.,
300
     __CTOR_LIST__).  RELOC is the relocation to use for an entry in
301
     the set when generating a relocateable file, and is also used to
302
     get the size of the entry when generating an executable file.
303
     ABFD, SEC and VALUE identify the value to add to the set.  */
304
  boolean (*add_to_set) PARAMS ((struct bfd_link_info *,
305
                                 struct bfd_link_hash_entry *entry,
306
                                 bfd_reloc_code_real_type reloc,
307
                                 bfd *abfd, asection *sec, bfd_vma value));
308
  /* A function which is called when the name of a g++ constructor or
309
     destructor is found.  This is only called by some object file
310
     formats.  CONSTRUCTOR is true for a constructor, false for a
311
     destructor.  This will use BFD_RELOC_CTOR when generating a
312
     relocateable file.  NAME is the name of the symbol found.  ABFD,
313
     SECTION and VALUE are the value of the symbol.  */
314
  boolean (*constructor) PARAMS ((struct bfd_link_info *,
315
                                  boolean constructor,
316
                                  const char *name, bfd *abfd, asection *sec,
317
                                  bfd_vma value));
318
  /* A function which is called to issue a linker warning.  For
319
     example, this is called when there is a reference to a warning
320
     symbol.  WARNING is the warning to be issued.  SYMBOL is the name
321
     of the symbol which triggered the warning; it may be NULL if
322
     there is none.  ABFD, SECTION and ADDRESS identify the location
323
     which trigerred the warning; either ABFD or SECTION or both may
324
     be NULL if the location is not known.  */
325
  boolean (*warning) PARAMS ((struct bfd_link_info *,
326
                              const char *warning, const char *symbol,
327
                              bfd *abfd, asection *section,
328
                              bfd_vma address));
329
  /* A function which is called when a relocation is attempted against
330
     an undefined symbol.  NAME is the symbol which is undefined.
331
     ABFD, SECTION and ADDRESS identify the location from which the
332
     reference is made. FATAL indicates whether an undefined symbol is
333
     a fatal error or not. In some cases SECTION may be NULL.  */
334
  boolean (*undefined_symbol) PARAMS ((struct bfd_link_info *,
335
                                       const char *name, bfd *abfd,
336
                                       asection *section,
337
                                       bfd_vma address,
338
                                       boolean fatal));
339
  /* A function which is called when a reloc overflow occurs.  NAME is
340
     the name of the symbol or section the reloc is against,
341
     RELOC_NAME is the name of the relocation, and ADDEND is any
342
     addend that is used.  ABFD, SECTION and ADDRESS identify the
343
     location at which the overflow occurs; if this is the result of a
344
     bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
345
     ABFD will be NULL.  */
346
  boolean (*reloc_overflow) PARAMS ((struct bfd_link_info *,
347
                                     const char *name,
348
                                     const char *reloc_name, bfd_vma addend,
349
                                     bfd *abfd, asection *section,
350
                                     bfd_vma address));
351
  /* A function which is called when a dangerous reloc is performed.
352
     The canonical example is an a29k IHCONST reloc which does not
353
     follow an IHIHALF reloc.  MESSAGE is an appropriate message.
354
     ABFD, SECTION and ADDRESS identify the location at which the
355
     problem occurred; if this is the result of a
356
     bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
357
     ABFD will be NULL.  */
358
  boolean (*reloc_dangerous) PARAMS ((struct bfd_link_info *,
359
                                      const char *message,
360
                                      bfd *abfd, asection *section,
361
                                      bfd_vma address));
362
  /* A function which is called when a reloc is found to be attached
363
     to a symbol which is not being written out.  NAME is the name of
364
     the symbol.  ABFD, SECTION and ADDRESS identify the location of
365
     the reloc; if this is the result of a
366
     bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
367
     ABFD will be NULL.  */
368
  boolean (*unattached_reloc) PARAMS ((struct bfd_link_info *,
369
                                       const char *name,
370
                                       bfd *abfd, asection *section,
371
                                       bfd_vma address));
372
  /* A function which is called when a symbol in notice_hash is
373
     defined or referenced.  NAME is the symbol.  ABFD, SECTION and
374
     ADDRESS are the value of the symbol.  If SECTION is
375
     bfd_und_section, this is a reference.  */
376
  boolean (*notice) PARAMS ((struct bfd_link_info *, const char *name,
377
                             bfd *abfd, asection *section, bfd_vma address));
378
};
379
 
380
/* The linker builds link_order structures which tell the code how to
381
   include input data in the output file.  */
382
 
383
/* These are the types of link_order structures.  */
384
 
385
enum bfd_link_order_type
386
{
387
  bfd_undefined_link_order,     /* Undefined.  */
388
  bfd_indirect_link_order,      /* Built from a section.  */
389
  bfd_fill_link_order,          /* Fill with a 16 bit constant.  */
390
  bfd_data_link_order,          /* Set to explicit data.  */
391
  bfd_section_reloc_link_order, /* Relocate against a section.  */
392
  bfd_symbol_reloc_link_order   /* Relocate against a symbol.  */
393
};
394
 
395
/* This is the link_order structure itself.  These form a chain
396
   attached to the section whose contents they are describing.  */
397
 
398
struct bfd_link_order
399
{
400
  /* Next link_order in chain.  */
401
  struct bfd_link_order *next;
402
  /* Type of link_order.  */
403
  enum bfd_link_order_type type;
404
  /* Offset within output section.  */
405
  bfd_vma offset;
406
  /* Size within output section.  */
407
  bfd_size_type size;
408
  /* Type specific information.  */
409
  union
410
    {
411
      struct
412
        {
413
          /* Section to include.  If this is used, then
414
             section->output_section must be the section the
415
             link_order is attached to, section->output_offset must
416
             equal the link_order offset field, and section->_raw_size
417
             must equal the link_order size field.  Maybe these
418
             restrictions should be relaxed someday.  */
419
          asection *section;
420
        } indirect;
421
      struct
422
        {
423
          /* Value to fill with.  */
424
          unsigned int value;
425
        } fill;
426
      struct
427
        {
428
          /* Data to put into file.  The size field gives the number
429
             of bytes which this field points to.  */
430
          bfd_byte *contents;
431
        } data;
432
      struct
433
        {
434
          /* Description of reloc to generate.  Used for
435
             bfd_section_reloc_link_order and
436
             bfd_symbol_reloc_link_order.  */
437
          struct bfd_link_order_reloc *p;
438
        } reloc;
439
    } u;
440
};
441
 
442
/* A linker order of type bfd_section_reloc_link_order or
443
   bfd_symbol_reloc_link_order means to create a reloc against a
444
   section or symbol, respectively.  This is used to implement -Ur to
445
   generate relocs for the constructor tables.  The
446
   bfd_link_order_reloc structure describes the reloc that BFD should
447
   create.  It is similar to a arelent, but I didn't use arelent
448
   because the linker does not know anything about most symbols, and
449
   any asymbol structure it creates will be partially meaningless.
450
   This information could logically be in the bfd_link_order struct,
451
   but I didn't want to waste the space since these types of relocs
452
   are relatively rare.  */
453
 
454
struct bfd_link_order_reloc
455
{
456
  /* Reloc type.  */
457
  bfd_reloc_code_real_type reloc;
458
 
459
  union
460
    {
461
      /* For type bfd_section_reloc_link_order, this is the section
462
         the reloc should be against.  This must be a section in the
463
         output BFD, not any of the input BFDs.  */
464
      asection *section;
465
      /* For type bfd_symbol_reloc_link_order, this is the name of the
466
         symbol the reloc should be against.  */
467
      const char *name;
468
    } u;
469
 
470
  /* Addend to use.  The object file should contain zero.  The BFD
471
     backend is responsible for filling in the contents of the object
472
     file correctly.  For some object file formats (e.g., COFF) the
473
     addend must be stored into in the object file, and for some
474
     (e.g., SPARC a.out) it is kept in the reloc.  */
475
  bfd_vma addend;
476
};
477
 
478
/* Allocate a new link_order for a section.  */
479
extern struct bfd_link_order *bfd_new_link_order PARAMS ((bfd *, asection *));
480
 
481
/* These structures are used to describe version information for the
482
   ELF linker.  These structures could be manipulated entirely inside
483
   BFD, but it would be a pain.  Instead, the regular linker sets up
484
   these structures, and then passes them into BFD.  */
485
 
486
/* Regular expressions for a version.  */
487
 
488
struct bfd_elf_version_expr
489
{
490
  /* Next regular expression for this version.  */
491
  struct bfd_elf_version_expr *next;
492
  /* Regular expression.  */
493
  const char *pattern;
494
  /* Matching function.  */
495
  int (*match) PARAMS((struct bfd_elf_version_expr *, const char *));
496
};
497
 
498
/* Version dependencies.  */
499
 
500
struct bfd_elf_version_deps
501
{
502
  /* Next dependency for this version.  */
503
  struct bfd_elf_version_deps *next;
504
  /* The version which this version depends upon.  */
505
  struct bfd_elf_version_tree *version_needed;
506
};
507
 
508
/* A node in the version tree.  */
509
 
510
struct bfd_elf_version_tree
511
{
512
  /* Next version.  */
513
  struct bfd_elf_version_tree *next;
514
  /* Name of this version.  */
515
  const char *name;
516
  /* Version number.  */
517
  unsigned int vernum;
518
  /* Regular expressions for global symbols in this version.  */
519
  struct bfd_elf_version_expr *globals;
520
  /* Regular expressions for local symbols in this version.  */
521
  struct bfd_elf_version_expr *locals;
522
  /* List of versions which this version depends upon.  */
523
  struct bfd_elf_version_deps *deps;
524
  /* Index of the version name.  This is used within BFD.  */
525
  unsigned int name_indx;
526
  /* Whether this version tree was used.  This is used within BFD.  */
527
  int used;
528
};
529
 
530
#endif

powered by: WebSVN 2.1.0

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