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

Subversion Repositories or1k

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Main header file for the bfd library -- portable access to object files.
2
   Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3
   Free Software Foundation, Inc.
4
   Contributed by Cygnus Support.
5
 
6
** NOTE: bfd.h and bfd-in2.h are GENERATED files.  Don't change them;
7
** instead, change bfd-in.h or the other BFD source files processed to
8
** generate these files.
9
 
10
This file is part of BFD, the Binary File Descriptor library.
11
 
12
This program is free software; you can redistribute it and/or modify
13
it under the terms of the GNU General Public License as published by
14
the Free Software Foundation; either version 2 of the License, or
15
(at your option) any later version.
16
 
17
This program is distributed in the hope that it will be useful,
18
but WITHOUT ANY WARRANTY; without even the implied warranty of
19
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
GNU General Public License for more details.
21
 
22
You should have received a copy of the GNU General Public License
23
along with this program; if not, write to the Free Software
24
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
25
 
26
/* bfd.h -- The only header file required by users of the bfd library
27
 
28
The bfd.h file is generated from bfd-in.h and various .c files; if you
29
change it, your changes will probably be lost.
30
 
31
All the prototypes and definitions following the comment "THE FOLLOWING
32
IS EXTRACTED FROM THE SOURCE" are extracted from the source files for
33
BFD.  If you change it, someone oneday will extract it from the source
34
again, and your changes will be lost.  To save yourself from this bind,
35
change the definitions in the source in the bfd directory.  Type "make
36
docs" and then "make headers" in that directory, and magically this file
37
will change to reflect your changes.
38
 
39
If you don't have the tools to perform the extraction, then you are
40
safe from someone on your system trampling over your header files.
41
You should still maintain the equivalence between the source and this
42
file though; every change you make to the .c file should be reflected
43
here.  */
44
 
45
#ifndef __BFD_H_SEEN__
46
#define __BFD_H_SEEN__
47
 
48
#ifdef __cplusplus
49
extern "C" {
50
#endif
51
 
52
#include "ansidecl.h"
53
 
54
/* These two lines get substitutions done by commands in Makefile.in.  */
55
#define BFD_VERSION  "@VERSION@"
56
#define BFD_ARCH_SIZE @wordsize@
57
#define BFD_HOST_64BIT_LONG @BFD_HOST_64BIT_LONG@
58
#if @BFD_HOST_64_BIT_DEFINED@
59
#define BFD_HOST_64_BIT @BFD_HOST_64_BIT@
60
#define BFD_HOST_U_64_BIT @BFD_HOST_U_64_BIT@
61
#endif
62
 
63
#if BFD_ARCH_SIZE >= 64
64
#define BFD64
65
#endif
66
 
67
#ifndef INLINE
68
#if __GNUC__ >= 2
69
#define INLINE __inline__
70
#else
71
#define INLINE
72
#endif
73
#endif
74
 
75
/* forward declaration */
76
typedef struct _bfd bfd;
77
 
78
/* To squelch erroneous compiler warnings ("illegal pointer
79
   combination") from the SVR3 compiler, we would like to typedef
80
   boolean to int (it doesn't like functions which return boolean.
81
   Making sure they are never implicitly declared to return int
82
   doesn't seem to help).  But this file is not configured based on
83
   the host.  */
84
/* General rules: functions which are boolean return true on success
85
   and false on failure (unless they're a predicate).   -- bfd.doc */
86
/* I'm sure this is going to break something and someone is going to
87
   force me to change it. */
88
/* typedef enum boolean {false, true} boolean; */
89
/* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h>  -fnf */
90
/* It gets worse if the host also defines a true/false enum... -sts */
91
/* And even worse if your compiler has built-in boolean types... -law */
92
#if defined (__GNUG__) && (__GNUC_MINOR__ > 5)
93
#define TRUE_FALSE_ALREADY_DEFINED
94
#endif
95
#ifdef MPW
96
/* Pre-emptive strike - get the file with the enum. */
97
#include <Types.h>
98
#define TRUE_FALSE_ALREADY_DEFINED
99
#endif /* MPW */
100
#ifndef TRUE_FALSE_ALREADY_DEFINED
101
typedef enum bfd_boolean {false, true} boolean;
102
#define BFD_TRUE_FALSE
103
#else
104
/* Use enum names that will appear nowhere else.  */
105
typedef enum bfd_boolean {bfd_fffalse, bfd_tttrue} boolean;
106
#endif
107
 
108
/* A pointer to a position in a file.  */
109
/* FIXME:  This should be using off_t from <sys/types.h>.
110
   For now, try to avoid breaking stuff by not including <sys/types.h> here.
111
   This will break on systems with 64-bit file offsets (e.g. 4.4BSD).
112
   Probably the best long-term answer is to avoid using file_ptr AND off_t
113
   in this header file, and to handle this in the BFD implementation
114
   rather than in its interface.  */
115
/* typedef off_t        file_ptr; */
116
typedef long int file_ptr;
117
 
118
/* Support for different sizes of target format ints and addresses.
119
   If the type `long' is at least 64 bits, BFD_HOST_64BIT_LONG will be
120
   set to 1 above.  Otherwise, if gcc is being used, this code will
121
   use gcc's "long long" type.  Otherwise, BFD_HOST_64_BIT must be
122
   defined above.  */
123
 
124
#ifndef BFD_HOST_64_BIT
125
# if BFD_HOST_64BIT_LONG
126
#  define BFD_HOST_64_BIT long
127
#  define BFD_HOST_U_64_BIT unsigned long
128
# else
129
#  ifdef __GNUC__
130
#   if __GNUC__ >= 2
131
#    define BFD_HOST_64_BIT long long
132
#    define BFD_HOST_U_64_BIT unsigned long long
133
#   endif /* __GNUC__ >= 2 */
134
#  endif /* ! defined (__GNUC__) */
135
# endif /* ! BFD_HOST_64BIT_LONG */
136
#endif /* ! defined (BFD_HOST_64_BIT) */
137
 
138
#ifdef BFD64
139
 
140
#ifndef BFD_HOST_64_BIT
141
 #error No 64 bit integer type available
142
#endif /* ! defined (BFD_HOST_64_BIT) */
143
 
144
typedef BFD_HOST_U_64_BIT bfd_vma;
145
typedef BFD_HOST_64_BIT bfd_signed_vma;
146
typedef BFD_HOST_U_64_BIT bfd_size_type;
147
typedef BFD_HOST_U_64_BIT symvalue;
148
 
149
#ifndef fprintf_vma
150
#if BFD_HOST_64BIT_LONG
151
#define sprintf_vma(s,x) sprintf (s, "%016lx", x)
152
#define fprintf_vma(f,x) fprintf (f, "%016lx", x)
153
#else
154
#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
155
#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
156
#define fprintf_vma(s,x) \
157
  fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
158
#define sprintf_vma(s,x) \
159
  sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
160
#endif
161
#endif
162
 
163
#else /* not BFD64  */
164
 
165
/* Represent a target address.  Also used as a generic unsigned type
166
   which is guaranteed to be big enough to hold any arithmetic types
167
   we need to deal with.  */
168
typedef unsigned long bfd_vma;
169
 
170
/* A generic signed type which is guaranteed to be big enough to hold any
171
   arithmetic types we need to deal with.  Can be assumed to be compatible
172
   with bfd_vma in the same way that signed and unsigned ints are compatible
173
   (as parameters, in assignment, etc).  */
174
typedef long bfd_signed_vma;
175
 
176
typedef unsigned long symvalue;
177
typedef unsigned long bfd_size_type;
178
 
179
/* Print a bfd_vma x on stream s.  */
180
#define fprintf_vma(s,x) fprintf(s, "%08lx", x)
181
#define sprintf_vma(s,x) sprintf(s, "%08lx", x)
182
 
183
#endif /* not BFD64  */
184
 
185
#define printf_vma(x) fprintf_vma(stdout,x)
186
 
187
typedef unsigned int flagword;  /* 32 bits of flags */
188
typedef unsigned char bfd_byte;
189
 
190
/** File formats */
191
 
192
typedef enum bfd_format {
193
              bfd_unknown = 0,   /* file format is unknown */
194
              bfd_object,       /* linker/assember/compiler output */
195
              bfd_archive,      /* object archive file */
196
              bfd_core,         /* core dump */
197
              bfd_type_end}     /* marks the end; don't use it! */
198
         bfd_format;
199
 
200
/* Values that may appear in the flags field of a BFD.  These also
201
   appear in the object_flags field of the bfd_target structure, where
202
   they indicate the set of flags used by that backend (not all flags
203
   are meaningful for all object file formats) (FIXME: at the moment,
204
   the object_flags values have mostly just been copied from backend
205
   to another, and are not necessarily correct).  */
206
 
207
/* No flags.  */
208
#define BFD_NO_FLAGS    0x00
209
 
210
/* BFD contains relocation entries.  */
211
#define HAS_RELOC       0x01
212
 
213
/* BFD is directly executable.  */
214
#define EXEC_P          0x02
215
 
216
/* BFD has line number information (basically used for F_LNNO in a
217
   COFF header).  */
218
#define HAS_LINENO      0x04
219
 
220
/* BFD has debugging information.  */
221
#define HAS_DEBUG       0x08
222
 
223
/* BFD has symbols.  */
224
#define HAS_SYMS        0x10
225
 
226
/* BFD has local symbols (basically used for F_LSYMS in a COFF
227
   header).  */
228
#define HAS_LOCALS      0x20
229
 
230
/* BFD is a dynamic object.  */
231
#define DYNAMIC         0x40
232
 
233
/* Text section is write protected (if D_PAGED is not set, this is
234
   like an a.out NMAGIC file) (the linker sets this by default, but
235
   clears it for -r or -N).  */
236
#define WP_TEXT         0x80
237
 
238
/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
239
   linker sets this by default, but clears it for -r or -n or -N).  */
240
#define D_PAGED         0x100
241
 
242
/* BFD is relaxable (this means that bfd_relax_section may be able to
243
   do something) (sometimes bfd_relax_section can do something even if
244
   this is not set).  */
245
#define BFD_IS_RELAXABLE 0x200
246
 
247
/* This may be set before writing out a BFD to request using a
248
   traditional format.  For example, this is used to request that when
249
   writing out an a.out object the symbols not be hashed to eliminate
250
   duplicates.  */
251
#define BFD_TRADITIONAL_FORMAT 0x400
252
 
253
/* This flag indicates that the BFD contents are actually cached in
254
   memory.  If this is set, iostream points to a bfd_in_memory struct.  */
255
#define BFD_IN_MEMORY 0x800
256
 
257
/* symbols and relocation */
258
 
259
/* A count of carsyms (canonical archive symbols).  */
260
typedef unsigned long symindex;
261
 
262
/* How to perform a relocation.  */
263
typedef const struct reloc_howto_struct reloc_howto_type;
264
 
265
#define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
266
 
267
/* General purpose part of a symbol X;
268
   target specific parts are in libcoff.h, libaout.h, etc.  */
269
 
270
#define bfd_get_section(x) ((x)->section)
271
#define bfd_get_output_section(x) ((x)->section->output_section)
272
#define bfd_set_section(x,y) ((x)->section) = (y)
273
#define bfd_asymbol_base(x) ((x)->section->vma)
274
#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)
275
#define bfd_asymbol_name(x) ((x)->name)
276
/*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/
277
#define bfd_asymbol_bfd(x) ((x)->the_bfd)
278
#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)
279
 
280
/* A canonical archive symbol.  */
281
/* This is a type pun with struct ranlib on purpose! */
282
typedef struct carsym {
283
  char *name;
284
  file_ptr file_offset;         /* look here to find the file */
285
} carsym;                       /* to make these you call a carsymogen */
286
 
287
 
288
/* Used in generating armaps (archive tables of contents).
289
   Perhaps just a forward definition would do? */
290
struct orl {                    /* output ranlib */
291
  char **name;                  /* symbol name */
292
  file_ptr pos;                 /* bfd* or file position */
293
  int namidx;                   /* index into string table */
294
};
295
 
296
 
297
/* Linenumber stuff */
298
typedef struct lineno_cache_entry {
299
  unsigned int line_number;     /* Linenumber from start of function*/
300
  union {
301
    struct symbol_cache_entry *sym; /* Function name */
302
    unsigned long offset;       /* Offset into section */
303
  } u;
304
} alent;
305
 
306
/* object and core file sections */
307
 
308
#define align_power(addr, align)        \
309
        ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
310
 
311
typedef struct sec *sec_ptr;
312
 
313
#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
314
#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
315
#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
316
#define bfd_section_name(bfd, ptr) ((ptr)->name)
317
#define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr))
318
#define bfd_section_vma(bfd, ptr) ((ptr)->vma)
319
#define bfd_section_lma(bfd, ptr) ((ptr)->lma)
320
#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
321
#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
322
#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
323
 
324
#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
325
 
326
#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma= (val)), ((ptr)->user_set_vma = (boolean)true), true)
327
#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
328
#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
329
 
330
typedef struct stat stat_type;
331
 
332
typedef enum bfd_print_symbol
333
{
334
  bfd_print_symbol_name,
335
  bfd_print_symbol_more,
336
  bfd_print_symbol_all
337
} bfd_print_symbol_type;
338
 
339
/* Information about a symbol that nm needs.  */
340
 
341
typedef struct _symbol_info
342
{
343
  symvalue value;
344
  char type;
345
  CONST char *name;            /* Symbol name.  */
346
  unsigned char stab_type;     /* Stab type.  */
347
  char stab_other;             /* Stab other. */
348
  short stab_desc;             /* Stab desc.  */
349
  CONST char *stab_name;       /* String for stab type.  */
350
} symbol_info;
351
 
352
/* Get the name of a stabs type code.  */
353
 
354
extern const char *bfd_get_stab_name PARAMS ((int));
355
 
356
/* Hash table routines.  There is no way to free up a hash table.  */
357
 
358
/* An element in the hash table.  Most uses will actually use a larger
359
   structure, and an instance of this will be the first field.  */
360
 
361
struct bfd_hash_entry
362
{
363
  /* Next entry for this hash code.  */
364
  struct bfd_hash_entry *next;
365
  /* String being hashed.  */
366
  const char *string;
367
  /* Hash code.  This is the full hash code, not the index into the
368
     table.  */
369
  unsigned long hash;
370
};
371
 
372
/* A hash table.  */
373
 
374
struct bfd_hash_table
375
{
376
  /* The hash array.  */
377
  struct bfd_hash_entry **table;
378
  /* The number of slots in the hash table.  */
379
  unsigned int size;
380
  /* A function used to create new elements in the hash table.  The
381
     first entry is itself a pointer to an element.  When this
382
     function is first invoked, this pointer will be NULL.  However,
383
     having the pointer permits a hierarchy of method functions to be
384
     built each of which calls the function in the superclass.  Thus
385
     each function should be written to allocate a new block of memory
386
     only if the argument is NULL.  */
387
  struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
388
                                             struct bfd_hash_table *,
389
                                             const char *));
390
   /* An objalloc for this hash table.  This is a struct objalloc *,
391
     but we use PTR to avoid requiring the inclusion of objalloc.h.  */
392
  PTR memory;
393
};
394
 
395
/* Initialize a hash table.  */
396
extern boolean bfd_hash_table_init
397
  PARAMS ((struct bfd_hash_table *,
398
           struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
399
                                       struct bfd_hash_table *,
400
                                       const char *)));
401
 
402
/* Initialize a hash table specifying a size.  */
403
extern boolean bfd_hash_table_init_n
404
  PARAMS ((struct bfd_hash_table *,
405
           struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
406
                                       struct bfd_hash_table *,
407
                                       const char *),
408
           unsigned int size));
409
 
410
/* Free up a hash table.  */
411
extern void bfd_hash_table_free PARAMS ((struct bfd_hash_table *));
412
 
413
/* Look up a string in a hash table.  If CREATE is true, a new entry
414
   will be created for this string if one does not already exist.  The
415
   COPY argument must be true if this routine should copy the string
416
   into newly allocated memory when adding an entry.  */
417
extern struct bfd_hash_entry *bfd_hash_lookup
418
  PARAMS ((struct bfd_hash_table *, const char *, boolean create,
419
           boolean copy));
420
 
421
/* Replace an entry in a hash table.  */
422
extern void bfd_hash_replace
423
  PARAMS ((struct bfd_hash_table *, struct bfd_hash_entry *old,
424
           struct bfd_hash_entry *nw));
425
 
426
/* Base method for creating a hash table entry.  */
427
extern struct bfd_hash_entry *bfd_hash_newfunc
428
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
429
           const char *));
430
 
431
/* Grab some space for a hash table entry.  */
432
extern PTR bfd_hash_allocate PARAMS ((struct bfd_hash_table *,
433
                                      unsigned int));
434
 
435
/* Traverse a hash table in a random order, calling a function on each
436
   element.  If the function returns false, the traversal stops.  The
437
   INFO argument is passed to the function.  */
438
extern void bfd_hash_traverse PARAMS ((struct bfd_hash_table *,
439
                                       boolean (*) (struct bfd_hash_entry *,
440
                                                    PTR),
441
                                       PTR info));
442
 
443
/* Semi-portable string concatenation in cpp.
444
   The CAT4 hack is to avoid a problem with some strict ANSI C preprocessors.
445
   The problem is, "32_" is not a valid preprocessing token, and we don't
446
   want extra underscores (e.g., "nlm_32_").  The XCAT2 macro will cause the
447
   inner CAT macros to be evaluated first, producing still-valid pp-tokens.
448
   Then the final concatenation can be done.  (Sigh.)  */
449
#ifndef CAT
450
#ifdef SABER
451
#define CAT(a,b)        a##b
452
#define CAT3(a,b,c)     a##b##c
453
#define CAT4(a,b,c,d)   a##b##c##d
454
#else
455
#if defined(__STDC__) || defined(ALMOST_STDC)
456
#define CAT(a,b) a##b
457
#define CAT3(a,b,c) a##b##c
458
#define XCAT2(a,b)      CAT(a,b)
459
#define CAT4(a,b,c,d)   XCAT2(CAT(a,b),CAT(c,d))
460
#else
461
#define CAT(a,b) a/**/b
462
#define CAT3(a,b,c) a/**/b/**/c
463
#define CAT4(a,b,c,d)   a/**/b/**/c/**/d
464
#endif
465
#endif
466
#endif
467
 
468
#define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table
469
 
470
/* User program access to BFD facilities */
471
 
472
/* Direct I/O routines, for programs which know more about the object
473
   file than BFD does.  Use higher level routines if possible.  */
474
 
475
extern bfd_size_type bfd_read
476
  PARAMS ((PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
477
extern bfd_size_type bfd_write
478
  PARAMS ((const PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
479
extern int bfd_seek PARAMS ((bfd *abfd, file_ptr fp, int direction));
480
extern long bfd_tell PARAMS ((bfd *abfd));
481
extern int bfd_flush PARAMS ((bfd *abfd));
482
extern int bfd_stat PARAMS ((bfd *abfd, struct stat *));
483
 
484
 
485
/* Cast from const char * to char * so that caller can assign to
486
   a char * without a warning.  */
487
#define bfd_get_filename(abfd) ((char *) (abfd)->filename)
488
#define bfd_get_cacheable(abfd) ((abfd)->cacheable)
489
#define bfd_get_format(abfd) ((abfd)->format)
490
#define bfd_get_target(abfd) ((abfd)->xvec->name)
491
#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)
492
#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
493
#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)
494
#define bfd_header_big_endian(abfd) \
495
  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)
496
#define bfd_header_little_endian(abfd) \
497
  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
498
#define bfd_get_file_flags(abfd) ((abfd)->flags)
499
#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
500
#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
501
#define bfd_my_archive(abfd) ((abfd)->my_archive)
502
#define bfd_has_map(abfd) ((abfd)->has_armap)
503
 
504
#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
505
#define bfd_usrdata(abfd) ((abfd)->usrdata)
506
 
507
#define bfd_get_start_address(abfd) ((abfd)->start_address)
508
#define bfd_get_symcount(abfd) ((abfd)->symcount)
509
#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
510
#define bfd_count_sections(abfd) ((abfd)->section_count)
511
 
512
#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
513
 
514
#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (boolean)(bool)), true)
515
 
516
extern boolean bfd_record_phdr
517
  PARAMS ((bfd *, unsigned long, boolean, flagword, boolean, bfd_vma,
518
           boolean, boolean, unsigned int, struct sec **));
519
 
520
/* Byte swapping routines.  */
521
 
522
bfd_vma         bfd_getb64         PARAMS ((const unsigned char *));
523
bfd_vma         bfd_getl64         PARAMS ((const unsigned char *));
524
bfd_signed_vma  bfd_getb_signed_64 PARAMS ((const unsigned char *));
525
bfd_signed_vma  bfd_getl_signed_64 PARAMS ((const unsigned char *));
526
bfd_vma         bfd_getb32         PARAMS ((const unsigned char *));
527
bfd_vma         bfd_getl32         PARAMS ((const unsigned char *));
528
bfd_signed_vma  bfd_getb_signed_32 PARAMS ((const unsigned char *));
529
bfd_signed_vma  bfd_getl_signed_32 PARAMS ((const unsigned char *));
530
bfd_vma         bfd_getb16         PARAMS ((const unsigned char *));
531
bfd_vma         bfd_getl16         PARAMS ((const unsigned char *));
532
bfd_signed_vma  bfd_getb_signed_16 PARAMS ((const unsigned char *));
533
bfd_signed_vma  bfd_getl_signed_16 PARAMS ((const unsigned char *));
534
void            bfd_putb64         PARAMS ((bfd_vma, unsigned char *));
535
void            bfd_putl64         PARAMS ((bfd_vma, unsigned char *));
536
void            bfd_putb32         PARAMS ((bfd_vma, unsigned char *));
537
void            bfd_putl32         PARAMS ((bfd_vma, unsigned char *));
538
void            bfd_putb16         PARAMS ((bfd_vma, unsigned char *));
539
void            bfd_putl16         PARAMS ((bfd_vma, unsigned char *));
540
 
541
/* Externally visible ECOFF routines.  */
542
 
543
#if defined(__STDC__) || defined(ALMOST_STDC)
544
struct ecoff_debug_info;
545
struct ecoff_debug_swap;
546
struct ecoff_extr;
547
struct symbol_cache_entry;
548
struct bfd_link_info;
549
struct bfd_link_hash_entry;
550
struct bfd_elf_version_tree;
551
#endif
552
extern bfd_vma bfd_ecoff_get_gp_value PARAMS ((bfd * abfd));
553
extern boolean bfd_ecoff_set_gp_value PARAMS ((bfd *abfd, bfd_vma gp_value));
554
extern boolean bfd_ecoff_set_regmasks
555
  PARAMS ((bfd *abfd, unsigned long gprmask, unsigned long fprmask,
556
           unsigned long *cprmask));
557
extern PTR bfd_ecoff_debug_init
558
  PARAMS ((bfd *output_bfd, struct ecoff_debug_info *output_debug,
559
           const struct ecoff_debug_swap *output_swap,
560
           struct bfd_link_info *));
561
extern void bfd_ecoff_debug_free
562
  PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
563
           const struct ecoff_debug_swap *output_swap,
564
           struct bfd_link_info *));
565
extern boolean bfd_ecoff_debug_accumulate
566
  PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
567
           const struct ecoff_debug_swap *output_swap,
568
           bfd *input_bfd, struct ecoff_debug_info *input_debug,
569
           const struct ecoff_debug_swap *input_swap,
570
           struct bfd_link_info *));
571
extern boolean bfd_ecoff_debug_accumulate_other
572
  PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
573
           const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
574
           struct bfd_link_info *));
575
extern boolean bfd_ecoff_debug_externals
576
  PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
577
           const struct ecoff_debug_swap *swap,
578
           boolean relocateable,
579
           boolean (*get_extr) (struct symbol_cache_entry *,
580
                                struct ecoff_extr *),
581
           void (*set_index) (struct symbol_cache_entry *,
582
                              bfd_size_type)));
583
extern boolean bfd_ecoff_debug_one_external
584
  PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
585
           const struct ecoff_debug_swap *swap,
586
           const char *name, struct ecoff_extr *esym));
587
extern bfd_size_type bfd_ecoff_debug_size
588
  PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
589
           const struct ecoff_debug_swap *swap));
590
extern boolean bfd_ecoff_write_debug
591
  PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
592
           const struct ecoff_debug_swap *swap, file_ptr where));
593
extern boolean bfd_ecoff_write_accumulated_debug
594
  PARAMS ((PTR handle, bfd *abfd, struct ecoff_debug_info *debug,
595
           const struct ecoff_debug_swap *swap,
596
           struct bfd_link_info *info, file_ptr where));
597
extern boolean bfd_mips_ecoff_create_embedded_relocs
598
  PARAMS ((bfd *, struct bfd_link_info *, struct sec *, struct sec *,
599
           char **));
600
 
601
/* Externally visible ELF routines.  */
602
 
603
struct bfd_link_needed_list
604
{
605
  struct bfd_link_needed_list *next;
606
  bfd *by;
607
  const char *name;
608
};
609
 
610
extern boolean bfd_elf32_record_link_assignment
611
  PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean));
612
extern boolean bfd_elf64_record_link_assignment
613
  PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean));
614
extern struct bfd_link_needed_list *bfd_elf_get_needed_list
615
  PARAMS ((bfd *, struct bfd_link_info *));
616
extern boolean bfd_elf_get_bfd_needed_list
617
  PARAMS ((bfd *, struct bfd_link_needed_list **));
618
extern boolean bfd_elf32_size_dynamic_sections
619
  PARAMS ((bfd *, const char *, const char *, boolean, const char *,
620
           const char * const *, struct bfd_link_info *, struct sec **,
621
           struct bfd_elf_version_tree *));
622
extern boolean bfd_elf64_size_dynamic_sections
623
  PARAMS ((bfd *, const char *, const char *, boolean, const char *,
624
           const char * const *, struct bfd_link_info *, struct sec **,
625
           struct bfd_elf_version_tree *));
626
extern void bfd_elf_set_dt_needed_name PARAMS ((bfd *, const char *));
627
extern const char *bfd_elf_get_dt_soname PARAMS ((bfd *));
628
 
629
/* Return an upper bound on the number of bytes required to store a
630
   copy of ABFD's program header table entries.  Return -1 if an error
631
   occurs; bfd_get_error will return an appropriate code.  */
632
extern long bfd_get_elf_phdr_upper_bound PARAMS ((bfd *abfd));
633
 
634
/* Copy ABFD's program header table entries to *PHDRS.  The entries
635
   will be stored as an array of Elf_Internal_Phdr structures, as
636
   defined in include/elf/internal.h.  To find out how large the
637
   buffer needs to be, call bfd_get_elf_phdr_upper_bound.
638
 
639
   Return the number of program header table entries read, or -1 if an
640
   error occurs; bfd_get_error will return an appropriate code.  */
641
extern int bfd_get_elf_phdrs PARAMS ((bfd *abfd, void *phdrs));
642
 
643
/* SunOS shared library support routines for the linker.  */
644
 
645
extern struct bfd_link_needed_list *bfd_sunos_get_needed_list
646
  PARAMS ((bfd *, struct bfd_link_info *));
647
extern boolean bfd_sunos_record_link_assignment
648
  PARAMS ((bfd *, struct bfd_link_info *, const char *));
649
extern boolean bfd_sunos_size_dynamic_sections
650
  PARAMS ((bfd *, struct bfd_link_info *, struct sec **, struct sec **,
651
           struct sec **));
652
 
653
/* Linux shared library support routines for the linker.  */
654
 
655
extern boolean bfd_i386linux_size_dynamic_sections
656
  PARAMS ((bfd *, struct bfd_link_info *));
657
extern boolean bfd_m68klinux_size_dynamic_sections
658
  PARAMS ((bfd *, struct bfd_link_info *));
659
extern boolean bfd_sparclinux_size_dynamic_sections
660
  PARAMS ((bfd *, struct bfd_link_info *));
661
 
662
/* mmap hacks */
663
 
664
struct _bfd_window_internal;
665
typedef struct _bfd_window_internal bfd_window_internal;
666
 
667
typedef struct _bfd_window {
668
  /* What the user asked for.  */
669
  PTR data;
670
  bfd_size_type size;
671
  /* The actual window used by BFD.  Small user-requested read-only
672
     regions sharing a page may share a single window into the object
673
     file.  Read-write versions shouldn't until I've fixed things to
674
     keep track of which portions have been claimed by the
675
     application; don't want to give the same region back when the
676
     application wants two writable copies!  */
677
  struct _bfd_window_internal *i;
678
} bfd_window;
679
 
680
extern void bfd_init_window PARAMS ((bfd_window *));
681
extern void bfd_free_window PARAMS ((bfd_window *));
682
extern boolean bfd_get_file_window
683
  PARAMS ((bfd *, file_ptr, bfd_size_type, bfd_window *, boolean));
684
 
685
/* XCOFF support routines for the linker.  */
686
 
687
extern boolean bfd_xcoff_link_record_set
688
  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
689
           bfd_size_type));
690
extern boolean bfd_xcoff_import_symbol
691
  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
692
           bfd_vma, const char *, const char *, const char *));
693
extern boolean bfd_xcoff_export_symbol
694
  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
695
           boolean));
696
extern boolean bfd_xcoff_link_count_reloc
697
  PARAMS ((bfd *, struct bfd_link_info *, const char *));
698
extern boolean bfd_xcoff_record_link_assignment
699
  PARAMS ((bfd *, struct bfd_link_info *, const char *));
700
extern boolean bfd_xcoff_size_dynamic_sections
701
  PARAMS ((bfd *, struct bfd_link_info *, const char *, const char *,
702
           unsigned long, unsigned long, unsigned long, boolean,
703
           int, boolean, boolean, struct sec **));
704
 
705
/* Externally visible COFF routines.  */
706
 
707
#if defined(__STDC__) || defined(ALMOST_STDC)
708
struct internal_syment;
709
union internal_auxent;
710
#endif
711
 
712
extern boolean bfd_coff_get_syment
713
  PARAMS ((bfd *, struct symbol_cache_entry *, struct internal_syment *));
714
 
715
extern boolean bfd_coff_get_auxent
716
  PARAMS ((bfd *, struct symbol_cache_entry *, int, union internal_auxent *));
717
 
718
extern boolean bfd_coff_set_symbol_class
719
  PARAMS ((bfd *, struct symbol_cache_entry *, unsigned int));
720
 
721
/* ARM Interworking support.  Called from linker.  */
722
extern boolean bfd_arm_allocate_interworking_sections
723
  PARAMS ((struct bfd_link_info *));
724
 
725
extern boolean bfd_arm_process_before_allocation
726
  PARAMS ((bfd *, struct bfd_link_info *, int));
727
 
728
extern boolean bfd_arm_get_bfd_for_interworking
729
  PARAMS ((bfd *, struct bfd_link_info *));
730
 
731
/* PE ARM Interworking support.  Called from linker.  */
732
extern boolean bfd_arm_pe_allocate_interworking_sections
733
  PARAMS ((struct bfd_link_info *));
734
 
735
extern boolean bfd_arm_pe_process_before_allocation
736
  PARAMS ((bfd *, struct bfd_link_info *, int));
737
 
738
extern boolean bfd_arm_pe_get_bfd_for_interworking
739
  PARAMS ((bfd *, struct bfd_link_info *));
740
 
741
/* ELF ARM Interworking support.  Called from linker.  */
742
extern boolean bfd_elf32_arm_allocate_interworking_sections
743
  PARAMS ((struct bfd_link_info *));
744
 
745
extern boolean bfd_elf32_arm_process_before_allocation
746
  PARAMS ((bfd *, struct bfd_link_info *, int));
747
 
748
extern boolean bfd_elf32_arm_get_bfd_for_interworking
749
  PARAMS ((bfd *, struct bfd_link_info *));
750
 
751
/* And more from the source.  */
752
void
753
bfd_init PARAMS ((void));
754
 
755
bfd *
756
bfd_openr PARAMS ((CONST char *filename, CONST char *target));
757
 
758
bfd *
759
bfd_fdopenr PARAMS ((CONST char *filename, CONST char *target, int fd));
760
 
761
bfd *
762
bfd_openstreamr PARAMS ((const char *, const char *, PTR));
763
 
764
bfd *
765
bfd_openw PARAMS ((CONST char *filename, CONST char *target));
766
 
767
boolean
768
bfd_close PARAMS ((bfd *abfd));
769
 
770
boolean
771
bfd_close_all_done PARAMS ((bfd *));
772
 
773
bfd *
774
bfd_create PARAMS ((CONST char *filename, bfd *templ));
775
 
776
boolean
777
bfd_make_writable PARAMS ((bfd *abfd));
778
 
779
boolean
780
bfd_make_readable PARAMS ((bfd *abfd));
781
 
782
 
783
 /* Byte swapping macros for user section data.  */
784
 
785
#define bfd_put_8(abfd, val, ptr) \
786
                ((void) (*((unsigned char *)(ptr)) = (unsigned char)(val)))
787
#define bfd_put_signed_8 \
788
               bfd_put_8
789
#define bfd_get_8(abfd, ptr) \
790
                (*(unsigned char *)(ptr))
791
#define bfd_get_signed_8(abfd, ptr) \
792
               ((*(unsigned char *)(ptr) ^ 0x80) - 0x80)
793
 
794
#define bfd_put_16(abfd, val, ptr) \
795
                BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
796
#define bfd_put_signed_16 \
797
                bfd_put_16
798
#define bfd_get_16(abfd, ptr) \
799
                BFD_SEND(abfd, bfd_getx16, (ptr))
800
#define bfd_get_signed_16(abfd, ptr) \
801
                BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
802
 
803
#define bfd_put_32(abfd, val, ptr) \
804
                BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
805
#define bfd_put_signed_32 \
806
                bfd_put_32
807
#define bfd_get_32(abfd, ptr) \
808
                BFD_SEND(abfd, bfd_getx32, (ptr))
809
#define bfd_get_signed_32(abfd, ptr) \
810
                BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
811
 
812
#define bfd_put_64(abfd, val, ptr) \
813
                BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
814
#define bfd_put_signed_64 \
815
                bfd_put_64
816
#define bfd_get_64(abfd, ptr) \
817
                BFD_SEND(abfd, bfd_getx64, (ptr))
818
#define bfd_get_signed_64(abfd, ptr) \
819
                BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
820
 
821
#define bfd_get(bits, abfd, ptr)                               \
822
                ((bits) == 8 ? bfd_get_8 (abfd, ptr)           \
823
                : (bits) == 16 ? bfd_get_16 (abfd, ptr)        \
824
                : (bits) == 32 ? bfd_get_32 (abfd, ptr)        \
825
                : (bits) == 64 ? bfd_get_64 (abfd, ptr)        \
826
                : (abort (), (bfd_vma) - 1))
827
 
828
#define bfd_put(bits, abfd, val, ptr)                          \
829
                ((bits) == 8 ? bfd_put_8 (abfd, val, ptr)      \
830
                : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)   \
831
                : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)   \
832
                : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)   \
833
                : (abort (), (void) 0))
834
 
835
 
836
 /* Byte swapping macros for file header data.  */
837
 
838
#define bfd_h_put_8(abfd, val, ptr) \
839
               bfd_put_8 (abfd, val, ptr)
840
#define bfd_h_put_signed_8(abfd, val, ptr) \
841
               bfd_put_8 (abfd, val, ptr)
842
#define bfd_h_get_8(abfd, ptr) \
843
               bfd_get_8 (abfd, ptr)
844
#define bfd_h_get_signed_8(abfd, ptr) \
845
               bfd_get_signed_8 (abfd, ptr)
846
 
847
#define bfd_h_put_16(abfd, val, ptr) \
848
                BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
849
#define bfd_h_put_signed_16 \
850
                bfd_h_put_16
851
#define bfd_h_get_16(abfd, ptr) \
852
                BFD_SEND(abfd, bfd_h_getx16,(ptr))
853
#define bfd_h_get_signed_16(abfd, ptr) \
854
                BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr))
855
 
856
#define bfd_h_put_32(abfd, val, ptr) \
857
                BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
858
#define bfd_h_put_signed_32 \
859
                bfd_h_put_32
860
#define bfd_h_get_32(abfd, ptr) \
861
                BFD_SEND(abfd, bfd_h_getx32,(ptr))
862
#define bfd_h_get_signed_32(abfd, ptr) \
863
                BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr))
864
 
865
#define bfd_h_put_64(abfd, val, ptr) \
866
                BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
867
#define bfd_h_put_signed_64 \
868
                bfd_h_put_64
869
#define bfd_h_get_64(abfd, ptr) \
870
                BFD_SEND(abfd, bfd_h_getx64,(ptr))
871
#define bfd_h_get_signed_64(abfd, ptr) \
872
                BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr))
873
 
874
  /* This structure is used for a comdat section, as in PE.  A comdat
875
    section is associated with a particular symbol.  When the linker
876
    sees a comdat section, it keeps only one of the sections with a
877
    given name and associated with a given symbol. */
878
 
879
struct bfd_comdat_info
880
{
881
   /* The name of the symbol associated with a comdat section.  */
882
  const char *name;
883
 
884
   /* The local symbol table index of the symbol associated with a
885
     comdat section.  This is only meaningful to the object file format
886
     specific code; it is not an index into the list returned by
887
     bfd_canonicalize_symtab.  */
888
  long symbol;
889
 
890
   /* If this section is being discarded, the linker uses this field
891
     to point to the input section which is being kept.  */
892
  struct sec *sec;
893
};
894
 
895
typedef struct sec
896
{
897
         /* The name of the section; the name isn't a copy, the pointer is
898
        the same as that passed to bfd_make_section. */
899
 
900
    CONST char *name;
901
 
902
         /* Which section is it; 0..nth.      */
903
 
904
   int index;
905
 
906
         /* The next section in the list belonging to the BFD, or NULL. */
907
 
908
    struct sec *next;
909
 
910
         /* The field flags contains attributes of the section. Some
911
           flags are read in from the object file, and some are
912
           synthesized from other information.  */
913
 
914
    flagword flags;
915
 
916
#define SEC_NO_FLAGS   0x000
917
 
918
         /* Tells the OS to allocate space for this section when loading.
919
           This is clear for a section containing debug information
920
           only. */
921
#define SEC_ALLOC      0x001
922
 
923
         /* Tells the OS to load the section from the file when loading.
924
           This is clear for a .bss section. */
925
#define SEC_LOAD       0x002
926
 
927
         /* The section contains data still to be relocated, so there is
928
           some relocation information too. */
929
#define SEC_RELOC      0x004
930
 
931
#if 0    /* Obsolete ? */
932
#define SEC_BALIGN     0x008
933
#endif
934
 
935
         /* A signal to the OS that the section contains read only
936
          data. */
937
#define SEC_READONLY   0x010
938
 
939
         /* The section contains code only. */
940
#define SEC_CODE       0x020
941
 
942
         /* The section contains data only. */
943
#define SEC_DATA       0x040
944
 
945
         /* The section will reside in ROM. */
946
#define SEC_ROM        0x080
947
 
948
         /* The section contains constructor information. This section
949
           type is used by the linker to create lists of constructors and
950
           destructors used by <<g++>>. When a back end sees a symbol
951
           which should be used in a constructor list, it creates a new
952
           section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
953
           the symbol to it, and builds a relocation. To build the lists
954
           of constructors, all the linker has to do is catenate all the
955
           sections called <<__CTOR_LIST__>> and relocate the data
956
           contained within - exactly the operations it would peform on
957
           standard data. */
958
#define SEC_CONSTRUCTOR 0x100
959
 
960
         /* The section is a constructor, and should be placed at the
961
          end of the text, data, or bss section(?). */
962
#define SEC_CONSTRUCTOR_TEXT 0x1100
963
#define SEC_CONSTRUCTOR_DATA 0x2100
964
#define SEC_CONSTRUCTOR_BSS  0x3100
965
 
966
         /* The section has contents - a data section could be
967
           <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be
968
           <<SEC_HAS_CONTENTS>> */
969
#define SEC_HAS_CONTENTS 0x200
970
 
971
         /* An instruction to the linker to not output the section
972
           even if it has information which would normally be written. */
973
#define SEC_NEVER_LOAD 0x400
974
 
975
         /* The section is a COFF shared library section.  This flag is
976
           only for the linker.  If this type of section appears in
977
           the input file, the linker must copy it to the output file
978
           without changing the vma or size.  FIXME: Although this
979
           was originally intended to be general, it really is COFF
980
           specific (and the flag was renamed to indicate this).  It
981
           might be cleaner to have some more general mechanism to
982
           allow the back end to control what the linker does with
983
           sections. */
984
#define SEC_COFF_SHARED_LIBRARY 0x800
985
 
986
         /* The section contains common symbols (symbols may be defined
987
           multiple times, the value of a symbol is the amount of
988
           space it requires, and the largest symbol value is the one
989
           used).  Most targets have exactly one of these (which we
990
           translate to bfd_com_section_ptr), but ECOFF has two. */
991
#define SEC_IS_COMMON 0x8000
992
 
993
         /* The section contains only debugging information.  For
994
           example, this is set for ELF .debug and .stab sections.
995
           strip tests this flag to see if a section can be
996
           discarded. */
997
#define SEC_DEBUGGING 0x10000
998
 
999
         /* The contents of this section are held in memory pointed to
1000
           by the contents field.  This is checked by
1001
           bfd_get_section_contents, and the data is retrieved from
1002
           memory if appropriate.  */
1003
#define SEC_IN_MEMORY 0x20000
1004
 
1005
         /* The contents of this section are to be excluded by the
1006
           linker for executable and shared objects unless those
1007
           objects are to be further relocated.  */
1008
#define SEC_EXCLUDE 0x40000
1009
 
1010
        /* The contents of this section are to be sorted by the
1011
          based on the address specified in the associated symbol
1012
          table.  */
1013
#define SEC_SORT_ENTRIES 0x80000
1014
 
1015
        /* When linking, duplicate sections of the same name should be
1016
          discarded, rather than being combined into a single section as
1017
          is usually done.  This is similar to how common symbols are
1018
          handled.  See SEC_LINK_DUPLICATES below.  */
1019
#define SEC_LINK_ONCE 0x100000
1020
 
1021
        /* If SEC_LINK_ONCE is set, this bitfield describes how the linker
1022
          should handle duplicate sections.  */
1023
#define SEC_LINK_DUPLICATES 0x600000
1024
 
1025
        /* This value for SEC_LINK_DUPLICATES means that duplicate
1026
          sections with the same name should simply be discarded. */
1027
#define SEC_LINK_DUPLICATES_DISCARD 0x0
1028
 
1029
        /* This value for SEC_LINK_DUPLICATES means that the linker
1030
          should warn if there are any duplicate sections, although
1031
          it should still only link one copy.  */
1032
#define SEC_LINK_DUPLICATES_ONE_ONLY 0x200000
1033
 
1034
        /* This value for SEC_LINK_DUPLICATES means that the linker
1035
          should warn if any duplicate sections are a different size.  */
1036
#define SEC_LINK_DUPLICATES_SAME_SIZE 0x400000
1037
 
1038
        /* This value for SEC_LINK_DUPLICATES means that the linker
1039
          should warn if any duplicate sections contain different
1040
          contents.  */
1041
#define SEC_LINK_DUPLICATES_SAME_CONTENTS 0x600000
1042
 
1043
        /* This section was created by the linker as part of dynamic
1044
          relocation or other arcane processing.  It is skipped when
1045
          going through the first-pass output, trusting that someone
1046
          else up the line will take care of it later.  */
1047
#define SEC_LINKER_CREATED 0x800000
1048
 
1049
        /* This section should not be subject to garbage collection.  */
1050
#define SEC_KEEP 0x1000000
1051
 
1052
        /* This section contains "short" data, and should be placed
1053
          "near" the GP.  */
1054
#define SEC_SMALL_DATA 0x2000000
1055
 
1056
        /* This section contains data which may be shared with other
1057
          executables or shared objects.  */
1058
#define SEC_SHARED 0x4000000
1059
 
1060
        /* When a section with this flag is being linked, then if the size of
1061
          the input section is less than a page, it should not cross a page
1062
          boundary.  If the size of the input section is one page or more, it
1063
          should be aligned on a page boundary.  */
1064
#define SEC_BLOCK 0x8000000
1065
 
1066
        /* Conditionally link this section; do not link if there are no
1067
          references found to any symbol in the section.  */
1068
#define SEC_CLINK 0x10000000
1069
 
1070
        /*  End of section flags.  */
1071
 
1072
        /* Some internal packed boolean fields.  */
1073
 
1074
        /* See the vma field.  */
1075
       unsigned int user_set_vma : 1;
1076
 
1077
        /* Whether relocations have been processed.  */
1078
       unsigned int reloc_done : 1;
1079
 
1080
        /* A mark flag used by some of the linker backends.  */
1081
       unsigned int linker_mark : 1;
1082
 
1083
        /* A mark flag used by some linker backends for garbage collection.  */
1084
       unsigned int gc_mark : 1;
1085
 
1086
        /* End of internal packed boolean fields.  */
1087
 
1088
        /*  The virtual memory address of the section - where it will be
1089
           at run time.  The symbols are relocated against this.  The
1090
           user_set_vma flag is maintained by bfd; if it's not set, the
1091
           backend can assign addresses (for example, in <<a.out>>, where
1092
           the default address for <<.data>> is dependent on the specific
1093
           target and various flags).  */
1094
 
1095
   bfd_vma vma;
1096
 
1097
        /*  The load address of the section - where it would be in a
1098
           rom image; really only used for writing section header
1099
           information. */
1100
 
1101
   bfd_vma lma;
1102
 
1103
         /* The size of the section in octets, as it will be output.
1104
           Contains a value even if the section has no contents (e.g., the
1105
           size of <<.bss>>).  This will be filled in after relocation.  */
1106
 
1107
   bfd_size_type _cooked_size;
1108
 
1109
         /* The original size on disk of the section, in octets.  Normally this
1110
           value is the same as the size, but if some relaxing has
1111
           been done, then this value will be bigger.  */
1112
 
1113
   bfd_size_type _raw_size;
1114
 
1115
         /* If this section is going to be output, then this value is the
1116
           offset in *bytes* into the output section of the first byte in the
1117
           input section (byte ==> smallest addressable unit on the
1118
           target).  In most cases, if this was going to start at the
1119
           100th octet (8-bit quantity) in the output section, this value
1120
           would be 100.  However, if the target byte size is 16 bits
1121
           (bfd_octets_per_byte is "2"), this value would be 50. */
1122
 
1123
   bfd_vma output_offset;
1124
 
1125
         /* The output section through which to map on output. */
1126
 
1127
   struct sec *output_section;
1128
 
1129
         /* The alignment requirement of the section, as an exponent of 2 -
1130
           e.g., 3 aligns to 2^3 (or 8). */
1131
 
1132
   unsigned int alignment_power;
1133
 
1134
         /* If an input section, a pointer to a vector of relocation
1135
           records for the data in this section. */
1136
 
1137
   struct reloc_cache_entry *relocation;
1138
 
1139
         /* If an output section, a pointer to a vector of pointers to
1140
           relocation records for the data in this section. */
1141
 
1142
   struct reloc_cache_entry **orelocation;
1143
 
1144
         /* The number of relocation records in one of the above  */
1145
 
1146
   unsigned reloc_count;
1147
 
1148
         /* Information below is back end specific - and not always used
1149
           or updated.  */
1150
 
1151
         /* File position of section data    */
1152
 
1153
   file_ptr filepos;
1154
 
1155
         /* File position of relocation info */
1156
 
1157
   file_ptr rel_filepos;
1158
 
1159
         /* File position of line data       */
1160
 
1161
   file_ptr line_filepos;
1162
 
1163
         /* Pointer to data for applications */
1164
 
1165
   PTR userdata;
1166
 
1167
         /* If the SEC_IN_MEMORY flag is set, this points to the actual
1168
           contents.  */
1169
   unsigned char *contents;
1170
 
1171
         /* Attached line number information */
1172
 
1173
   alent *lineno;
1174
 
1175
         /* Number of line number records   */
1176
 
1177
   unsigned int lineno_count;
1178
 
1179
         /* Optional information about a COMDAT entry; NULL if not COMDAT */
1180
 
1181
   struct bfd_comdat_info *comdat;
1182
 
1183
         /* When a section is being output, this value changes as more
1184
           linenumbers are written out */
1185
 
1186
   file_ptr moving_line_filepos;
1187
 
1188
         /* What the section number is in the target world  */
1189
 
1190
   int target_index;
1191
 
1192
   PTR used_by_bfd;
1193
 
1194
         /* If this is a constructor section then here is a list of the
1195
           relocations created to relocate items within it. */
1196
 
1197
   struct relent_chain *constructor_chain;
1198
 
1199
         /* The BFD which owns the section. */
1200
 
1201
   bfd *owner;
1202
 
1203
         /* A symbol which points at this section only */
1204
   struct symbol_cache_entry *symbol;
1205
   struct symbol_cache_entry **symbol_ptr_ptr;
1206
 
1207
   struct bfd_link_order *link_order_head;
1208
   struct bfd_link_order *link_order_tail;
1209
} asection ;
1210
 
1211
     /* These sections are global, and are managed by BFD.  The application
1212
       and target back end are not permitted to change the values in
1213
       these sections.  New code should use the section_ptr macros rather
1214
       than referring directly to the const sections.  The const sections
1215
       may eventually vanish.  */
1216
#define BFD_ABS_SECTION_NAME "*ABS*"
1217
#define BFD_UND_SECTION_NAME "*UND*"
1218
#define BFD_COM_SECTION_NAME "*COM*"
1219
#define BFD_IND_SECTION_NAME "*IND*"
1220
 
1221
     /* the absolute section */
1222
extern const asection bfd_abs_section;
1223
#define bfd_abs_section_ptr ((asection *) &bfd_abs_section)
1224
#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
1225
     /* Pointer to the undefined section */
1226
extern const asection bfd_und_section;
1227
#define bfd_und_section_ptr ((asection *) &bfd_und_section)
1228
#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
1229
     /* Pointer to the common section */
1230
extern const asection bfd_com_section;
1231
#define bfd_com_section_ptr ((asection *) &bfd_com_section)
1232
     /* Pointer to the indirect section */
1233
extern const asection bfd_ind_section;
1234
#define bfd_ind_section_ptr ((asection *) &bfd_ind_section)
1235
#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
1236
 
1237
extern const struct symbol_cache_entry * const bfd_abs_symbol;
1238
extern const struct symbol_cache_entry * const bfd_com_symbol;
1239
extern const struct symbol_cache_entry * const bfd_und_symbol;
1240
extern const struct symbol_cache_entry * const bfd_ind_symbol;
1241
#define bfd_get_section_size_before_reloc(section) \
1242
     ((section)->reloc_done ? (abort (), (bfd_size_type) 1) \
1243
                            : (section)->_raw_size)
1244
#define bfd_get_section_size_after_reloc(section) \
1245
     ((section)->reloc_done ? (section)->_cooked_size \
1246
                            : (abort (), (bfd_size_type) 1))
1247
asection *
1248
bfd_get_section_by_name PARAMS ((bfd *abfd, CONST char *name));
1249
 
1250
asection *
1251
bfd_make_section_old_way PARAMS ((bfd *abfd, CONST char *name));
1252
 
1253
asection *
1254
bfd_make_section_anyway PARAMS ((bfd *abfd, CONST char *name));
1255
 
1256
asection *
1257
bfd_make_section PARAMS ((bfd *, CONST char *name));
1258
 
1259
boolean
1260
bfd_set_section_flags PARAMS ((bfd *abfd, asection *sec, flagword flags));
1261
 
1262
void
1263
bfd_map_over_sections PARAMS ((bfd *abfd,
1264
    void (*func)(bfd *abfd,
1265
    asection *sect,
1266
    PTR obj),
1267
    PTR obj));
1268
 
1269
boolean
1270
bfd_set_section_size PARAMS ((bfd *abfd, asection *sec, bfd_size_type val));
1271
 
1272
boolean
1273
bfd_set_section_contents
1274
 PARAMS ((bfd *abfd,
1275
    asection *section,
1276
    PTR data,
1277
    file_ptr offset,
1278
    bfd_size_type count));
1279
 
1280
boolean
1281
bfd_get_section_contents
1282
 PARAMS ((bfd *abfd, asection *section, PTR location,
1283
    file_ptr offset, bfd_size_type count));
1284
 
1285
boolean
1286
bfd_copy_private_section_data PARAMS ((bfd *ibfd, asection *isec, bfd *obfd, asection *osec));
1287
 
1288
#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
1289
     BFD_SEND (obfd, _bfd_copy_private_section_data, \
1290
               (ibfd, isection, obfd, osection))
1291
void
1292
_bfd_strip_section_from_output
1293
 PARAMS ((struct bfd_link_info *info, asection *section));
1294
 
1295
enum bfd_architecture
1296
{
1297
  bfd_arch_unknown,    /* File arch not known */
1298
  bfd_arch_obscure,    /* Arch known, not one of these */
1299
  bfd_arch_m68k,       /* Motorola 68xxx */
1300
#define bfd_mach_m68000 1
1301
#define bfd_mach_m68008 2
1302
#define bfd_mach_m68010 3
1303
#define bfd_mach_m68020 4
1304
#define bfd_mach_m68030 5
1305
#define bfd_mach_m68040 6
1306
#define bfd_mach_m68060 7
1307
#define bfd_mach_cpu32  8
1308
  bfd_arch_vax,        /* DEC Vax */
1309
  bfd_arch_i960,       /* Intel 960 */
1310
     /* The order of the following is important.
1311
       lower number indicates a machine type that
1312
       only accepts a subset of the instructions
1313
       available to machines with higher numbers.
1314
       The exception is the "ca", which is
1315
       incompatible with all other machines except
1316
       "core". */
1317
 
1318
#define bfd_mach_i960_core      1
1319
#define bfd_mach_i960_ka_sa     2
1320
#define bfd_mach_i960_kb_sb     3
1321
#define bfd_mach_i960_mc        4
1322
#define bfd_mach_i960_xa        5
1323
#define bfd_mach_i960_ca        6
1324
#define bfd_mach_i960_jx        7
1325
#define bfd_mach_i960_hx        8
1326
 
1327
  bfd_arch_or32,       /* OpenRISC 32 */
1328
  bfd_arch_or16,       /* OpenRISC 16 */
1329
 
1330
  bfd_arch_a29k,       /* AMD 29000 */
1331
  bfd_arch_sparc,      /* SPARC */
1332
#define bfd_mach_sparc                 1
1333
 /* The difference between v8plus and v9 is that v9 is a true 64 bit env.  */
1334
#define bfd_mach_sparc_sparclet        2
1335
#define bfd_mach_sparc_sparclite       3
1336
#define bfd_mach_sparc_v8plus          4
1337
#define bfd_mach_sparc_v8plusa         5  /* with ultrasparc add'ns */
1338
#define bfd_mach_sparc_sparclite_le    6
1339
#define bfd_mach_sparc_v9              7
1340
#define bfd_mach_sparc_v9a             8  /* with ultrasparc add'ns */
1341
 /* Nonzero if MACH has the v9 instruction set.  */
1342
#define bfd_mach_sparc_v9_p(mach) \
1343
  ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a)
1344
  bfd_arch_mips,       /* MIPS Rxxxx */
1345
#define bfd_mach_mips3000              3000
1346
#define bfd_mach_mips3900              3900
1347
#define bfd_mach_mips4000              4000
1348
#define bfd_mach_mips4010              4010
1349
#define bfd_mach_mips4100              4100
1350
#define bfd_mach_mips4111              4111
1351
#define bfd_mach_mips4300              4300
1352
#define bfd_mach_mips4400              4400
1353
#define bfd_mach_mips4600              4600
1354
#define bfd_mach_mips4650              4650
1355
#define bfd_mach_mips5000              5000
1356
#define bfd_mach_mips6000              6000
1357
#define bfd_mach_mips8000              8000
1358
#define bfd_mach_mips10000             10000
1359
#define bfd_mach_mips16                16
1360
  bfd_arch_i386,       /* Intel 386 */
1361
#define bfd_mach_i386_i386 0
1362
#define bfd_mach_i386_i8086 1
1363
#define bfd_mach_i386_i386_intel_syntax 2
1364
  bfd_arch_we32k,      /* AT&T WE32xxx */
1365
  bfd_arch_tahoe,      /* CCI/Harris Tahoe */
1366
  bfd_arch_i860,       /* Intel 860 */
1367
  bfd_arch_i370,       /* IBM 360/370 Mainframes */
1368
  bfd_arch_romp,       /* IBM ROMP PC/RT */
1369
  bfd_arch_alliant,    /* Alliant */
1370
  bfd_arch_convex,     /* Convex */
1371
  bfd_arch_m88k,       /* Motorola 88xxx */
1372
  bfd_arch_pyramid,    /* Pyramid Technology */
1373
  bfd_arch_h8300,      /* Hitachi H8/300 */
1374
#define bfd_mach_h8300   1
1375
#define bfd_mach_h8300h  2
1376
#define bfd_mach_h8300s  3
1377
  bfd_arch_powerpc,    /* PowerPC */
1378
  bfd_arch_rs6000,     /* IBM RS/6000 */
1379
  bfd_arch_hppa,       /* HP PA RISC */
1380
  bfd_arch_d10v,       /* Mitsubishi D10V */
1381
#define bfd_mach_d10v          0
1382
#define bfd_mach_d10v_ts2      2
1383
#define bfd_mach_d10v_ts3      3
1384
  bfd_arch_d30v,       /* Mitsubishi D30V */
1385
  bfd_arch_z8k,        /* Zilog Z8000 */
1386
#define bfd_mach_z8001         1
1387
#define bfd_mach_z8002         2
1388
  bfd_arch_h8500,      /* Hitachi H8/500 */
1389
  bfd_arch_sh,         /* Hitachi SH */
1390
#define bfd_mach_sh            0
1391
#define bfd_mach_sh2        0x20
1392
#define bfd_mach_sh_dsp     0x2d
1393
#define bfd_mach_sh3        0x30
1394
#define bfd_mach_sh3_dsp    0x3d
1395
#define bfd_mach_sh3e       0x3e
1396
#define bfd_mach_sh4        0x40
1397
  bfd_arch_alpha,      /* Dec Alpha */
1398
#define bfd_mach_alpha_ev4  0x10
1399
#define bfd_mach_alpha_ev5  0x20
1400
#define bfd_mach_alpha_ev6  0x30
1401
  bfd_arch_arm,        /* Advanced Risc Machines ARM */
1402
#define bfd_mach_arm_2         1
1403
#define bfd_mach_arm_2a        2
1404
#define bfd_mach_arm_3         3
1405
#define bfd_mach_arm_3M        4
1406
#define bfd_mach_arm_4         5
1407
#define bfd_mach_arm_4T        6
1408
#define bfd_mach_arm_5         7
1409
#define bfd_mach_arm_5T        8
1410
  bfd_arch_ns32k,      /* National Semiconductors ns32000 */
1411
  bfd_arch_w65,        /* WDC 65816 */
1412
  bfd_arch_tic30,      /* Texas Instruments TMS320C30 */
1413
  bfd_arch_tic54x,     /* Texas Instruments TMS320C54X */
1414
  bfd_arch_tic80,      /* TI TMS320c80 (MVP) */
1415
  bfd_arch_v850,       /* NEC V850 */
1416
#define bfd_mach_v850          0
1417
#define bfd_mach_v850e         'E'
1418
#define bfd_mach_v850ea        'A'
1419
  bfd_arch_arc,        /* Argonaut RISC Core */
1420
#define bfd_mach_arc_base 0
1421
  bfd_arch_m32r,       /* Mitsubishi M32R/D */
1422
#define bfd_mach_m32r          0  /* backwards compatibility */
1423
#define bfd_mach_m32rx         'x'
1424
  bfd_arch_mn10200,    /* Matsushita MN10200 */
1425
  bfd_arch_mn10300,    /* Matsushita MN10300 */
1426
#define bfd_mach_mn10300               300
1427
#define bfd_mach_am33          330
1428
  bfd_arch_fr30,
1429
#define bfd_mach_fr30          0x46523330
1430
  bfd_arch_mcore,
1431
  bfd_arch_pj,
1432
  bfd_arch_avr,        /* Atmel AVR microcontrollers */
1433
#define bfd_mach_avr1          1
1434
#define bfd_mach_avr2          2
1435
#define bfd_mach_avr3          3
1436
#define bfd_mach_avr4          4
1437
  bfd_arch_last
1438
  };
1439
 
1440
typedef struct bfd_arch_info
1441
{
1442
  int bits_per_word;
1443
  int bits_per_address;
1444
  int bits_per_byte;
1445
  enum bfd_architecture arch;
1446
  unsigned long mach;
1447
  const char *arch_name;
1448
  const char *printable_name;
1449
  unsigned int section_align_power;
1450
  /* true if this is the default machine for the architecture */
1451
  boolean the_default;
1452
  const struct bfd_arch_info * (*compatible)
1453
       PARAMS ((const struct bfd_arch_info *a,
1454
                const struct bfd_arch_info *b));
1455
 
1456
  boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
1457
 
1458
  const struct bfd_arch_info *next;
1459
} bfd_arch_info_type;
1460
const char *
1461
bfd_printable_name PARAMS ((bfd *abfd));
1462
 
1463
const bfd_arch_info_type *
1464
bfd_scan_arch PARAMS ((const char *string));
1465
 
1466
const char **
1467
bfd_arch_list PARAMS ((void));
1468
 
1469
const bfd_arch_info_type *
1470
bfd_arch_get_compatible PARAMS ((
1471
    const bfd *abfd,
1472
    const bfd *bbfd));
1473
 
1474
void
1475
bfd_set_arch_info PARAMS ((bfd *abfd, const bfd_arch_info_type *arg));
1476
 
1477
enum bfd_architecture
1478
bfd_get_arch PARAMS ((bfd *abfd));
1479
 
1480
unsigned long
1481
bfd_get_mach PARAMS ((bfd *abfd));
1482
 
1483
unsigned int
1484
bfd_arch_bits_per_byte PARAMS ((bfd *abfd));
1485
 
1486
unsigned int
1487
bfd_arch_bits_per_address PARAMS ((bfd *abfd));
1488
 
1489
const bfd_arch_info_type *
1490
bfd_get_arch_info PARAMS ((bfd *abfd));
1491
 
1492
const bfd_arch_info_type *
1493
bfd_lookup_arch
1494
 PARAMS ((enum bfd_architecture
1495
    arch,
1496
    unsigned long machine));
1497
 
1498
const char *
1499
bfd_printable_arch_mach
1500
 PARAMS ((enum bfd_architecture arch, unsigned long machine));
1501
 
1502
unsigned int
1503
bfd_octets_per_byte PARAMS ((bfd *abfd));
1504
 
1505
unsigned int
1506
bfd_arch_mach_octets_per_byte PARAMS ((enum bfd_architecture arch,
1507
    unsigned long machine));
1508
 
1509
typedef enum bfd_reloc_status
1510
{
1511
        /* No errors detected */
1512
  bfd_reloc_ok,
1513
 
1514
        /* The relocation was performed, but there was an overflow. */
1515
  bfd_reloc_overflow,
1516
 
1517
        /* The address to relocate was not within the section supplied. */
1518
  bfd_reloc_outofrange,
1519
 
1520
        /* Used by special functions */
1521
  bfd_reloc_continue,
1522
 
1523
        /* Unsupported relocation size requested. */
1524
  bfd_reloc_notsupported,
1525
 
1526
        /* Unused */
1527
  bfd_reloc_other,
1528
 
1529
        /* The symbol to relocate against was undefined. */
1530
  bfd_reloc_undefined,
1531
 
1532
        /* The relocation was performed, but may not be ok - presently
1533
          generated only when linking i960 coff files with i960 b.out
1534
          symbols.  If this type is returned, the error_message argument
1535
          to bfd_perform_relocation will be set.  */
1536
  bfd_reloc_dangerous
1537
 }
1538
 bfd_reloc_status_type;
1539
 
1540
 
1541
typedef struct reloc_cache_entry
1542
{
1543
        /* A pointer into the canonical table of pointers  */
1544
  struct symbol_cache_entry **sym_ptr_ptr;
1545
 
1546
        /* offset in section */
1547
  bfd_size_type address;
1548
 
1549
        /* addend for relocation value */
1550
  bfd_vma addend;
1551
 
1552
        /* Pointer to how to perform the required relocation */
1553
  reloc_howto_type *howto;
1554
 
1555
} arelent;
1556
enum complain_overflow
1557
{
1558
        /* Do not complain on overflow. */
1559
  complain_overflow_dont,
1560
 
1561
        /* Complain if the bitfield overflows, whether it is considered
1562
          as signed or unsigned. */
1563
  complain_overflow_bitfield,
1564
 
1565
        /* Complain if the value overflows when considered as signed
1566
          number. */
1567
  complain_overflow_signed,
1568
 
1569
        /* Complain if the value overflows when considered as an
1570
          unsigned number. */
1571
  complain_overflow_unsigned
1572
};
1573
 
1574
struct reloc_howto_struct
1575
{
1576
        /*  The type field has mainly a documentary use - the back end can
1577
           do what it wants with it, though normally the back end's
1578
           external idea of what a reloc number is stored
1579
           in this field. For example, a PC relative word relocation
1580
           in a coff environment has the type 023 - because that's
1581
           what the outside world calls a R_PCRWORD reloc. */
1582
  unsigned int type;
1583
 
1584
        /*  The value the final relocation is shifted right by. This drops
1585
           unwanted data from the relocation.  */
1586
  unsigned int rightshift;
1587
 
1588
        /*  The size of the item to be relocated.  This is *not* a
1589
           power-of-two measure.  To get the number of bytes operated
1590
           on by a type of relocation, use bfd_get_reloc_size.  */
1591
  int size;
1592
 
1593
        /*  The number of bits in the item to be relocated.  This is used
1594
           when doing overflow checking.  */
1595
  unsigned int bitsize;
1596
 
1597
        /*  Notes that the relocation is relative to the location in the
1598
           data section of the addend. The relocation function will
1599
           subtract from the relocation value the address of the location
1600
           being relocated. */
1601
  boolean pc_relative;
1602
 
1603
        /*  The bit position of the reloc value in the destination.
1604
           The relocated value is left shifted by this amount. */
1605
  unsigned int bitpos;
1606
 
1607
        /* What type of overflow error should be checked for when
1608
          relocating. */
1609
  enum complain_overflow complain_on_overflow;
1610
 
1611
        /* If this field is non null, then the supplied function is
1612
          called rather than the normal function. This allows really
1613
          strange relocation methods to be accomodated (e.g., i960 callj
1614
          instructions). */
1615
  bfd_reloc_status_type (*special_function)
1616
                                   PARAMS ((bfd *abfd,
1617
                                            arelent *reloc_entry,
1618
                                            struct symbol_cache_entry *symbol,
1619
                                            PTR data,
1620
                                            asection *input_section,
1621
                                            bfd *output_bfd,
1622
                                            char **error_message));
1623
 
1624
        /* The textual name of the relocation type. */
1625
  char *name;
1626
 
1627
        /* Some formats record a relocation addend in the section contents
1628
          rather than with the relocation.  For ELF formats this is the
1629
          distinction between USE_REL and USE_RELA (though the code checks
1630
          for USE_REL == 1/0).  The value of this field is TRUE if the
1631
          addend is recorded with the section contents; when performing a
1632
          partial link (ld -r) the section contents (the data) will be
1633
          modified.  The value of this field is FALSE if addends are
1634
          recorded with the relocation (in arelent.addend); when performing
1635
          a partial link the relocation will be modified.
1636
          All relocations for all ELF USE_RELA targets should set this field
1637
          to FALSE (values of TRUE should be looked on with suspicion).
1638
          However, the converse is not true: not all relocations of all ELF
1639
          USE_REL targets set this field to TRUE.  Why this is so is peculiar
1640
          to each particular target.  For relocs that aren't used in partial
1641
          links (e.g. GOT stuff) it doesn't matter what this is set to.  */
1642
  boolean partial_inplace;
1643
 
1644
        /* The src_mask selects which parts of the read in data
1645
          are to be used in the relocation sum.  E.g., if this was an 8 bit
1646
          byte of data which we read and relocated, this would be
1647
          0x000000ff. When we have relocs which have an addend, such as
1648
          sun4 extended relocs, the value in the offset part of a
1649
          relocating field is garbage so we never use it. In this case
1650
          the mask would be 0x00000000. */
1651
  bfd_vma src_mask;
1652
 
1653
        /* The dst_mask selects which parts of the instruction are replaced
1654
          into the instruction. In most cases src_mask == dst_mask,
1655
          except in the above special case, where dst_mask would be
1656
          0x000000ff, and src_mask would be 0x00000000.   */
1657
  bfd_vma dst_mask;
1658
 
1659
        /* When some formats create PC relative instructions, they leave
1660
          the value of the pc of the place being relocated in the offset
1661
          slot of the instruction, so that a PC relative relocation can
1662
          be made just by adding in an ordinary offset (e.g., sun3 a.out).
1663
          Some formats leave the displacement part of an instruction
1664
          empty (e.g., m88k bcs); this flag signals the fact.*/
1665
  boolean pcrel_offset;
1666
 
1667
};
1668
#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
1669
  {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
1670
#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
1671
 
1672
#define EMPTY_HOWTO(C) \
1673
  HOWTO((C),0,0,0,false,0,complain_overflow_dont,NULL,NULL,false,0,0,false)
1674
 
1675
#define HOWTO_PREPARE(relocation, symbol)      \
1676
  {                                            \
1677
  if (symbol != (asymbol *)NULL) {             \
1678
    if (bfd_is_com_section (symbol->section)) { \
1679
      relocation = 0;                          \
1680
    }                                          \
1681
    else {                                     \
1682
      relocation = symbol->value;              \
1683
    }                                          \
1684
  }                                            \
1685
}
1686
unsigned int
1687
bfd_get_reloc_size  PARAMS ((reloc_howto_type *));
1688
 
1689
typedef struct relent_chain {
1690
  arelent relent;
1691
  struct   relent_chain *next;
1692
} arelent_chain;
1693
bfd_reloc_status_type
1694
 
1695
bfd_check_overflow
1696
 PARAMS ((enum complain_overflow how,
1697
    unsigned int bitsize,
1698
    unsigned int rightshift,
1699
    unsigned int addrsize,
1700
    bfd_vma relocation));
1701
 
1702
bfd_reloc_status_type
1703
 
1704
bfd_perform_relocation
1705
 PARAMS ((bfd *abfd,
1706
    arelent *reloc_entry,
1707
    PTR data,
1708
    asection *input_section,
1709
    bfd *output_bfd,
1710
    char **error_message));
1711
 
1712
bfd_reloc_status_type
1713
 
1714
bfd_install_relocation
1715
 PARAMS ((bfd *abfd,
1716
    arelent *reloc_entry,
1717
    PTR data, bfd_vma data_start,
1718
    asection *input_section,
1719
    char **error_message));
1720
 
1721
enum bfd_reloc_code_real {
1722
  _dummy_first_bfd_reloc_code_real,
1723
 
1724
 
1725
/* Basic absolute relocations of N bits. */
1726
  BFD_RELOC_64,
1727
  BFD_RELOC_32,
1728
  BFD_RELOC_26,
1729
  BFD_RELOC_24,
1730
  BFD_RELOC_16,
1731
  BFD_RELOC_14,
1732
  BFD_RELOC_8,
1733
 
1734
/* PC-relative relocations.  Sometimes these are relative to the address
1735
of the relocation itself; sometimes they are relative to the start of
1736
the section containing the relocation.  It depends on the specific target.
1737
 
1738
The 24-bit relocation is used in some Intel 960 configurations. */
1739
  BFD_RELOC_64_PCREL,
1740
  BFD_RELOC_32_PCREL,
1741
  BFD_RELOC_24_PCREL,
1742
  BFD_RELOC_16_PCREL,
1743
  BFD_RELOC_12_PCREL,
1744
  BFD_RELOC_8_PCREL,
1745
 
1746
/* For ELF. */
1747
  BFD_RELOC_32_GOT_PCREL,
1748
  BFD_RELOC_16_GOT_PCREL,
1749
  BFD_RELOC_8_GOT_PCREL,
1750
  BFD_RELOC_32_GOTOFF,
1751
  BFD_RELOC_16_GOTOFF,
1752
  BFD_RELOC_LO16_GOTOFF,
1753
  BFD_RELOC_HI16_GOTOFF,
1754
  BFD_RELOC_HI16_S_GOTOFF,
1755
  BFD_RELOC_8_GOTOFF,
1756
  BFD_RELOC_32_PLT_PCREL,
1757
  BFD_RELOC_24_PLT_PCREL,
1758
  BFD_RELOC_16_PLT_PCREL,
1759
  BFD_RELOC_8_PLT_PCREL,
1760
  BFD_RELOC_32_PLTOFF,
1761
  BFD_RELOC_16_PLTOFF,
1762
  BFD_RELOC_LO16_PLTOFF,
1763
  BFD_RELOC_HI16_PLTOFF,
1764
  BFD_RELOC_HI16_S_PLTOFF,
1765
  BFD_RELOC_8_PLTOFF,
1766
 
1767
/* Relocations used by 68K ELF. */
1768
  BFD_RELOC_68K_GLOB_DAT,
1769
  BFD_RELOC_68K_JMP_SLOT,
1770
  BFD_RELOC_68K_RELATIVE,
1771
 
1772
/* Linkage-table relative. */
1773
  BFD_RELOC_32_BASEREL,
1774
  BFD_RELOC_16_BASEREL,
1775
  BFD_RELOC_LO16_BASEREL,
1776
  BFD_RELOC_HI16_BASEREL,
1777
  BFD_RELOC_HI16_S_BASEREL,
1778
  BFD_RELOC_8_BASEREL,
1779
  BFD_RELOC_RVA,
1780
 
1781
/* Absolute 8-bit relocation, but used to form an address like 0xFFnn. */
1782
  BFD_RELOC_8_FFnn,
1783
 
1784
/* These PC-relative relocations are stored as word displacements --
1785
i.e., byte displacements shifted right two bits.  The 30-bit word
1786
displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1787
SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
1788
signed 16-bit displacement is used on the MIPS, and the 23-bit
1789
displacement is used on the Alpha. */
1790
  BFD_RELOC_32_PCREL_S2,
1791
  BFD_RELOC_16_PCREL_S2,
1792
  BFD_RELOC_23_PCREL_S2,
1793
 
1794
/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1795
the target word.  These are used on the SPARC. */
1796
  BFD_RELOC_HI22,
1797
  BFD_RELOC_LO10,
1798
 
1799
/* For systems that allocate a Global Pointer register, these are
1800
displacements off that register.  These relocation types are
1801
handled specially, because the value the register will have is
1802
decided relatively late. */
1803
  BFD_RELOC_GPREL16,
1804
  BFD_RELOC_GPREL32,
1805
 
1806
/* Reloc types used for i960/b.out. */
1807
  BFD_RELOC_I960_CALLJ,
1808
 
1809
/* SPARC ELF relocations.  There is probably some overlap with other
1810
relocation types already defined. */
1811
  BFD_RELOC_NONE,
1812
  BFD_RELOC_SPARC_WDISP22,
1813
  BFD_RELOC_SPARC22,
1814
  BFD_RELOC_SPARC13,
1815
  BFD_RELOC_SPARC_GOT10,
1816
  BFD_RELOC_SPARC_GOT13,
1817
  BFD_RELOC_SPARC_GOT22,
1818
  BFD_RELOC_SPARC_PC10,
1819
  BFD_RELOC_SPARC_PC22,
1820
  BFD_RELOC_SPARC_WPLT30,
1821
  BFD_RELOC_SPARC_COPY,
1822
  BFD_RELOC_SPARC_GLOB_DAT,
1823
  BFD_RELOC_SPARC_JMP_SLOT,
1824
  BFD_RELOC_SPARC_RELATIVE,
1825
  BFD_RELOC_SPARC_UA32,
1826
 
1827
/* I think these are specific to SPARC a.out (e.g., Sun 4). */
1828
  BFD_RELOC_SPARC_BASE13,
1829
  BFD_RELOC_SPARC_BASE22,
1830
 
1831
/* SPARC64 relocations */
1832
#define BFD_RELOC_SPARC_64 BFD_RELOC_64
1833
  BFD_RELOC_SPARC_10,
1834
  BFD_RELOC_SPARC_11,
1835
  BFD_RELOC_SPARC_OLO10,
1836
  BFD_RELOC_SPARC_HH22,
1837
  BFD_RELOC_SPARC_HM10,
1838
  BFD_RELOC_SPARC_LM22,
1839
  BFD_RELOC_SPARC_PC_HH22,
1840
  BFD_RELOC_SPARC_PC_HM10,
1841
  BFD_RELOC_SPARC_PC_LM22,
1842
  BFD_RELOC_SPARC_WDISP16,
1843
  BFD_RELOC_SPARC_WDISP19,
1844
  BFD_RELOC_SPARC_7,
1845
  BFD_RELOC_SPARC_6,
1846
  BFD_RELOC_SPARC_5,
1847
#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL
1848
  BFD_RELOC_SPARC_PLT64,
1849
  BFD_RELOC_SPARC_HIX22,
1850
  BFD_RELOC_SPARC_LOX10,
1851
  BFD_RELOC_SPARC_H44,
1852
  BFD_RELOC_SPARC_M44,
1853
  BFD_RELOC_SPARC_L44,
1854
  BFD_RELOC_SPARC_REGISTER,
1855
 
1856
/* SPARC little endian relocation */
1857
  BFD_RELOC_SPARC_REV32,
1858
 
1859
/* Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
1860
"addend" in some special way.
1861
For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1862
writing; when reading, it will be the absolute section symbol.  The
1863
addend is the displacement in bytes of the "lda" instruction from
1864
the "ldah" instruction (which is at the address of this reloc). */
1865
  BFD_RELOC_ALPHA_GPDISP_HI16,
1866
 
1867
/* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1868
with GPDISP_HI16 relocs.  The addend is ignored when writing the
1869
relocations out, and is filled in with the file's GP value on
1870
reading, for convenience. */
1871
  BFD_RELOC_ALPHA_GPDISP_LO16,
1872
 
1873
/* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1874
relocation except that there is no accompanying GPDISP_LO16
1875
relocation. */
1876
  BFD_RELOC_ALPHA_GPDISP,
1877
 
1878
/* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1879
the assembler turns it into a LDQ instruction to load the address of
1880
the symbol, and then fills in a register in the real instruction.
1881
 
1882
The LITERAL reloc, at the LDQ instruction, refers to the .lita
1883
section symbol.  The addend is ignored when writing, but is filled
1884
in with the file's GP value on reading, for convenience, as with the
1885
GPDISP_LO16 reloc.
1886
 
1887
The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1888
It should refer to the symbol to be referenced, as with 16_GOTOFF,
1889
but it generates output not based on the position within the .got
1890
section, but relative to the GP value chosen for the file during the
1891
final link stage.
1892
 
1893
The LITUSE reloc, on the instruction using the loaded address, gives
1894
information to the linker that it might be able to use to optimize
1895
away some literal section references.  The symbol is ignored (read
1896
as the absolute section symbol), and the "addend" indicates the type
1897
of instruction using the register:
1898
1 - "memory" fmt insn
1899
2 - byte-manipulation (byte offset reg)
1900
3 - jsr (target of branch)
1901
 
1902
The GNU linker currently doesn't do any of this optimizing. */
1903
  BFD_RELOC_ALPHA_LITERAL,
1904
  BFD_RELOC_ALPHA_ELF_LITERAL,
1905
  BFD_RELOC_ALPHA_LITUSE,
1906
 
1907
/* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to
1908
process the explicit !<reloc>!sequence relocations, and are mapped
1909
into the normal relocations at the end of processing. */
1910
  BFD_RELOC_ALPHA_USER_LITERAL,
1911
  BFD_RELOC_ALPHA_USER_LITUSE_BASE,
1912
  BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF,
1913
  BFD_RELOC_ALPHA_USER_LITUSE_JSR,
1914
  BFD_RELOC_ALPHA_USER_GPDISP,
1915
  BFD_RELOC_ALPHA_USER_GPRELHIGH,
1916
  BFD_RELOC_ALPHA_USER_GPRELLOW,
1917
 
1918
/* The HINT relocation indicates a value that should be filled into the
1919
"hint" field of a jmp/jsr/ret instruction, for possible branch-
1920
prediction logic which may be provided on some processors. */
1921
  BFD_RELOC_ALPHA_HINT,
1922
 
1923
/* The LINKAGE relocation outputs a linkage pair in the object file,
1924
which is filled by the linker. */
1925
  BFD_RELOC_ALPHA_LINKAGE,
1926
 
1927
/* The CODEADDR relocation outputs a STO_CA in the object file,
1928
which is filled by the linker. */
1929
  BFD_RELOC_ALPHA_CODEADDR,
1930
 
1931
/* Bits 27..2 of the relocation address shifted right 2 bits;
1932
simple reloc otherwise. */
1933
  BFD_RELOC_MIPS_JMP,
1934
 
1935
/* The MIPS16 jump instruction. */
1936
  BFD_RELOC_MIPS16_JMP,
1937
 
1938
/* MIPS16 GP relative reloc. */
1939
  BFD_RELOC_MIPS16_GPREL,
1940
 
1941
/* High 16 bits of 32-bit value; simple reloc. */
1942
  BFD_RELOC_HI16,
1943
 
1944
/* High 16 bits of 32-bit value but the low 16 bits will be sign
1945
extended and added to form the final result.  If the low 16
1946
bits form a negative number, we need to add one to the high value
1947
to compensate for the borrow when the low bits are added. */
1948
  BFD_RELOC_HI16_S,
1949
 
1950
/* Low 16 bits. */
1951
  BFD_RELOC_LO16,
1952
 
1953
/* Like BFD_RELOC_HI16_S, but PC relative. */
1954
  BFD_RELOC_PCREL_HI16_S,
1955
 
1956
/* Like BFD_RELOC_LO16, but PC relative. */
1957
  BFD_RELOC_PCREL_LO16,
1958
 
1959
/* Relocation relative to the global pointer. */
1960
#define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16
1961
 
1962
/* Relocation against a MIPS literal section. */
1963
  BFD_RELOC_MIPS_LITERAL,
1964
 
1965
/* MIPS ELF relocations. */
1966
  BFD_RELOC_MIPS_GOT16,
1967
  BFD_RELOC_MIPS_CALL16,
1968
#define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32
1969
  BFD_RELOC_MIPS_GOT_HI16,
1970
  BFD_RELOC_MIPS_GOT_LO16,
1971
  BFD_RELOC_MIPS_CALL_HI16,
1972
  BFD_RELOC_MIPS_CALL_LO16,
1973
  BFD_RELOC_MIPS_SUB,
1974
  BFD_RELOC_MIPS_GOT_PAGE,
1975
  BFD_RELOC_MIPS_GOT_OFST,
1976
  BFD_RELOC_MIPS_GOT_DISP,
1977
 
1978
 
1979
/* i386/elf relocations */
1980
  BFD_RELOC_386_GOT32,
1981
  BFD_RELOC_386_PLT32,
1982
  BFD_RELOC_386_COPY,
1983
  BFD_RELOC_386_GLOB_DAT,
1984
  BFD_RELOC_386_JUMP_SLOT,
1985
  BFD_RELOC_386_RELATIVE,
1986
  BFD_RELOC_386_GOTOFF,
1987
  BFD_RELOC_386_GOTPC,
1988
 
1989
/* ns32k relocations */
1990
  BFD_RELOC_NS32K_IMM_8,
1991
  BFD_RELOC_NS32K_IMM_16,
1992
  BFD_RELOC_NS32K_IMM_32,
1993
  BFD_RELOC_NS32K_IMM_8_PCREL,
1994
  BFD_RELOC_NS32K_IMM_16_PCREL,
1995
  BFD_RELOC_NS32K_IMM_32_PCREL,
1996
  BFD_RELOC_NS32K_DISP_8,
1997
  BFD_RELOC_NS32K_DISP_16,
1998
  BFD_RELOC_NS32K_DISP_32,
1999
  BFD_RELOC_NS32K_DISP_8_PCREL,
2000
  BFD_RELOC_NS32K_DISP_16_PCREL,
2001
  BFD_RELOC_NS32K_DISP_32_PCREL,
2002
 
2003
/* Picojava relocs.  Not all of these appear in object files. */
2004
  BFD_RELOC_PJ_CODE_HI16,
2005
  BFD_RELOC_PJ_CODE_LO16,
2006
  BFD_RELOC_PJ_CODE_DIR16,
2007
  BFD_RELOC_PJ_CODE_DIR32,
2008
  BFD_RELOC_PJ_CODE_REL16,
2009
  BFD_RELOC_PJ_CODE_REL32,
2010
 
2011
/* Power(rs6000) and PowerPC relocations. */
2012
  BFD_RELOC_PPC_B26,
2013
  BFD_RELOC_PPC_BA26,
2014
  BFD_RELOC_PPC_TOC16,
2015
  BFD_RELOC_PPC_B16,
2016
  BFD_RELOC_PPC_B16_BRTAKEN,
2017
  BFD_RELOC_PPC_B16_BRNTAKEN,
2018
  BFD_RELOC_PPC_BA16,
2019
  BFD_RELOC_PPC_BA16_BRTAKEN,
2020
  BFD_RELOC_PPC_BA16_BRNTAKEN,
2021
  BFD_RELOC_PPC_COPY,
2022
  BFD_RELOC_PPC_GLOB_DAT,
2023
  BFD_RELOC_PPC_JMP_SLOT,
2024
  BFD_RELOC_PPC_RELATIVE,
2025
  BFD_RELOC_PPC_LOCAL24PC,
2026
  BFD_RELOC_PPC_EMB_NADDR32,
2027
  BFD_RELOC_PPC_EMB_NADDR16,
2028
  BFD_RELOC_PPC_EMB_NADDR16_LO,
2029
  BFD_RELOC_PPC_EMB_NADDR16_HI,
2030
  BFD_RELOC_PPC_EMB_NADDR16_HA,
2031
  BFD_RELOC_PPC_EMB_SDAI16,
2032
  BFD_RELOC_PPC_EMB_SDA2I16,
2033
  BFD_RELOC_PPC_EMB_SDA2REL,
2034
  BFD_RELOC_PPC_EMB_SDA21,
2035
  BFD_RELOC_PPC_EMB_MRKREF,
2036
  BFD_RELOC_PPC_EMB_RELSEC16,
2037
  BFD_RELOC_PPC_EMB_RELST_LO,
2038
  BFD_RELOC_PPC_EMB_RELST_HI,
2039
  BFD_RELOC_PPC_EMB_RELST_HA,
2040
  BFD_RELOC_PPC_EMB_BIT_FLD,
2041
  BFD_RELOC_PPC_EMB_RELSDA,
2042
 
2043
/* IBM 370/390 relocations */
2044
  BFD_RELOC_I370_D12,
2045
 
2046
/* The type of reloc used to build a contructor table - at the moment
2047
probably a 32 bit wide absolute relocation, but the target can choose.
2048
It generally does map to one of the other relocation types. */
2049
  BFD_RELOC_CTOR,
2050
 
2051
/* ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
2052
not stored in the instruction. */
2053
  BFD_RELOC_ARM_PCREL_BRANCH,
2054
 
2055
/* ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
2056
not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2057
field in the instruction. */
2058
  BFD_RELOC_ARM_PCREL_BLX,
2059
 
2060
/* Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
2061
not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2062
field in the instruction. */
2063
  BFD_RELOC_THUMB_PCREL_BLX,
2064
 
2065
/* These relocs are only used within the ARM assembler.  They are not
2066
(at present) written to any object files. */
2067
  BFD_RELOC_ARM_IMMEDIATE,
2068
  BFD_RELOC_ARM_ADRL_IMMEDIATE,
2069
  BFD_RELOC_ARM_OFFSET_IMM,
2070
  BFD_RELOC_ARM_SHIFT_IMM,
2071
  BFD_RELOC_ARM_SWI,
2072
  BFD_RELOC_ARM_MULTI,
2073
  BFD_RELOC_ARM_CP_OFF_IMM,
2074
  BFD_RELOC_ARM_ADR_IMM,
2075
  BFD_RELOC_ARM_LDR_IMM,
2076
  BFD_RELOC_ARM_LITERAL,
2077
  BFD_RELOC_ARM_IN_POOL,
2078
  BFD_RELOC_ARM_OFFSET_IMM8,
2079
  BFD_RELOC_ARM_HWLITERAL,
2080
  BFD_RELOC_ARM_THUMB_ADD,
2081
  BFD_RELOC_ARM_THUMB_IMM,
2082
  BFD_RELOC_ARM_THUMB_SHIFT,
2083
  BFD_RELOC_ARM_THUMB_OFFSET,
2084
  BFD_RELOC_ARM_GOT12,
2085
  BFD_RELOC_ARM_GOT32,
2086
  BFD_RELOC_ARM_JUMP_SLOT,
2087
  BFD_RELOC_ARM_COPY,
2088
  BFD_RELOC_ARM_GLOB_DAT,
2089
  BFD_RELOC_ARM_PLT32,
2090
  BFD_RELOC_ARM_RELATIVE,
2091
  BFD_RELOC_ARM_GOTOFF,
2092
  BFD_RELOC_ARM_GOTPC,
2093
 
2094
/* Hitachi SH relocs.  Not all of these appear in object files. */
2095
  BFD_RELOC_SH_PCDISP8BY2,
2096
  BFD_RELOC_SH_PCDISP12BY2,
2097
  BFD_RELOC_SH_IMM4,
2098
  BFD_RELOC_SH_IMM4BY2,
2099
  BFD_RELOC_SH_IMM4BY4,
2100
  BFD_RELOC_SH_IMM8,
2101
  BFD_RELOC_SH_IMM8BY2,
2102
  BFD_RELOC_SH_IMM8BY4,
2103
  BFD_RELOC_SH_PCRELIMM8BY2,
2104
  BFD_RELOC_SH_PCRELIMM8BY4,
2105
  BFD_RELOC_SH_SWITCH16,
2106
  BFD_RELOC_SH_SWITCH32,
2107
  BFD_RELOC_SH_USES,
2108
  BFD_RELOC_SH_COUNT,
2109
  BFD_RELOC_SH_ALIGN,
2110
  BFD_RELOC_SH_CODE,
2111
  BFD_RELOC_SH_DATA,
2112
  BFD_RELOC_SH_LABEL,
2113
  BFD_RELOC_SH_LOOP_START,
2114
  BFD_RELOC_SH_LOOP_END,
2115
 
2116
/* Thumb 23-, 12- and 9-bit pc-relative branches.  The lowest bit must
2117
be zero and is not stored in the instruction. */
2118
  BFD_RELOC_THUMB_PCREL_BRANCH9,
2119
  BFD_RELOC_THUMB_PCREL_BRANCH12,
2120
  BFD_RELOC_THUMB_PCREL_BRANCH23,
2121
 
2122
/* Argonaut RISC Core (ARC) relocs.
2123
ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
2124
not stored in the instruction.  The high 20 bits are installed in bits 26
2125
through 7 of the instruction. */
2126
  BFD_RELOC_ARC_B22_PCREL,
2127
 
2128
/* ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
2129
stored in the instruction.  The high 24 bits are installed in bits 23
2130
through 0. */
2131
  BFD_RELOC_ARC_B26,
2132
 
2133
/* Mitsubishi D10V relocs.
2134
This is a 10-bit reloc with the right 2 bits
2135
assumed to be 0. */
2136
  BFD_RELOC_D10V_10_PCREL_R,
2137
 
2138
/* Mitsubishi D10V relocs.
2139
This is a 10-bit reloc with the right 2 bits
2140
assumed to be 0.  This is the same as the previous reloc
2141
except it is in the left container, i.e.,
2142
shifted left 15 bits. */
2143
  BFD_RELOC_D10V_10_PCREL_L,
2144
 
2145
/* This is an 18-bit reloc with the right 2 bits
2146
assumed to be 0. */
2147
  BFD_RELOC_D10V_18,
2148
 
2149
/* This is an 18-bit reloc with the right 2 bits
2150
assumed to be 0. */
2151
  BFD_RELOC_D10V_18_PCREL,
2152
 
2153
/* Mitsubishi D30V relocs.
2154
This is a 6-bit absolute reloc. */
2155
  BFD_RELOC_D30V_6,
2156
 
2157
/* This is a 6-bit pc-relative reloc with
2158
the right 3 bits assumed to be 0. */
2159
  BFD_RELOC_D30V_9_PCREL,
2160
 
2161
/* This is a 6-bit pc-relative reloc with
2162
the right 3 bits assumed to be 0. Same
2163
as the previous reloc but on the right side
2164
of the container. */
2165
  BFD_RELOC_D30V_9_PCREL_R,
2166
 
2167
/* This is a 12-bit absolute reloc with the
2168
right 3 bitsassumed to be 0. */
2169
  BFD_RELOC_D30V_15,
2170
 
2171
/* This is a 12-bit pc-relative reloc with
2172
the right 3 bits assumed to be 0. */
2173
  BFD_RELOC_D30V_15_PCREL,
2174
 
2175
/* This is a 12-bit pc-relative reloc with
2176
the right 3 bits assumed to be 0. Same
2177
as the previous reloc but on the right side
2178
of the container. */
2179
  BFD_RELOC_D30V_15_PCREL_R,
2180
 
2181
/* This is an 18-bit absolute reloc with
2182
the right 3 bits assumed to be 0. */
2183
  BFD_RELOC_D30V_21,
2184
 
2185
/* This is an 18-bit pc-relative reloc with
2186
the right 3 bits assumed to be 0. */
2187
  BFD_RELOC_D30V_21_PCREL,
2188
 
2189
/* This is an 18-bit pc-relative reloc with
2190
the right 3 bits assumed to be 0. Same
2191
as the previous reloc but on the right side
2192
of the container. */
2193
  BFD_RELOC_D30V_21_PCREL_R,
2194
 
2195
/* This is a 32-bit absolute reloc. */
2196
  BFD_RELOC_D30V_32,
2197
 
2198
/* This is a 32-bit pc-relative reloc. */
2199
  BFD_RELOC_D30V_32_PCREL,
2200
 
2201
/* Mitsubishi M32R relocs.
2202
This is a 24 bit absolute address. */
2203
  BFD_RELOC_M32R_24,
2204
 
2205
/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. */
2206
  BFD_RELOC_M32R_10_PCREL,
2207
 
2208
/* This is an 18-bit reloc with the right 2 bits assumed to be 0. */
2209
  BFD_RELOC_M32R_18_PCREL,
2210
 
2211
/* This is a 26-bit reloc with the right 2 bits assumed to be 0. */
2212
  BFD_RELOC_M32R_26_PCREL,
2213
 
2214
/* This is a 16-bit reloc containing the high 16 bits of an address
2215
used when the lower 16 bits are treated as unsigned. */
2216
  BFD_RELOC_M32R_HI16_ULO,
2217
 
2218
/* This is a 16-bit reloc containing the high 16 bits of an address
2219
used when the lower 16 bits are treated as signed. */
2220
  BFD_RELOC_M32R_HI16_SLO,
2221
 
2222
/* This is a 16-bit reloc containing the lower 16 bits of an address. */
2223
  BFD_RELOC_M32R_LO16,
2224
 
2225
/* This is a 16-bit reloc containing the small data area offset for use in
2226
add3, load, and store instructions. */
2227
  BFD_RELOC_M32R_SDA16,
2228
 
2229
/* This is a 9-bit reloc */
2230
  BFD_RELOC_V850_9_PCREL,
2231
 
2232
/* This is a 22-bit reloc */
2233
  BFD_RELOC_V850_22_PCREL,
2234
 
2235
/* This is a 16 bit offset from the short data area pointer. */
2236
  BFD_RELOC_V850_SDA_16_16_OFFSET,
2237
 
2238
/* This is a 16 bit offset (of which only 15 bits are used) from the
2239
short data area pointer. */
2240
  BFD_RELOC_V850_SDA_15_16_OFFSET,
2241
 
2242
/* This is a 16 bit offset from the zero data area pointer. */
2243
  BFD_RELOC_V850_ZDA_16_16_OFFSET,
2244
 
2245
/* This is a 16 bit offset (of which only 15 bits are used) from the
2246
zero data area pointer. */
2247
  BFD_RELOC_V850_ZDA_15_16_OFFSET,
2248
 
2249
/* This is an 8 bit offset (of which only 6 bits are used) from the
2250
tiny data area pointer. */
2251
  BFD_RELOC_V850_TDA_6_8_OFFSET,
2252
 
2253
/* This is an 8bit offset (of which only 7 bits are used) from the tiny
2254
data area pointer. */
2255
  BFD_RELOC_V850_TDA_7_8_OFFSET,
2256
 
2257
/* This is a 7 bit offset from the tiny data area pointer. */
2258
  BFD_RELOC_V850_TDA_7_7_OFFSET,
2259
 
2260
/* This is a 16 bit offset from the tiny data area pointer. */
2261
  BFD_RELOC_V850_TDA_16_16_OFFSET,
2262
 
2263
/* This is a 5 bit offset (of which only 4 bits are used) from the tiny
2264
data area pointer. */
2265
  BFD_RELOC_V850_TDA_4_5_OFFSET,
2266
 
2267
/* This is a 4 bit offset from the tiny data area pointer. */
2268
  BFD_RELOC_V850_TDA_4_4_OFFSET,
2269
 
2270
/* This is a 16 bit offset from the short data area pointer, with the
2271
bits placed non-contigously in the instruction. */
2272
  BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET,
2273
 
2274
/* This is a 16 bit offset from the zero data area pointer, with the
2275
bits placed non-contigously in the instruction. */
2276
  BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET,
2277
 
2278
/* This is a 6 bit offset from the call table base pointer. */
2279
  BFD_RELOC_V850_CALLT_6_7_OFFSET,
2280
 
2281
/* This is a 16 bit offset from the call table base pointer. */
2282
  BFD_RELOC_V850_CALLT_16_16_OFFSET,
2283
 
2284
 
2285
/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2286
instruction. */
2287
  BFD_RELOC_MN10300_32_PCREL,
2288
 
2289
/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2290
instruction. */
2291
  BFD_RELOC_MN10300_16_PCREL,
2292
 
2293
/* This is a 8bit DP reloc for the tms320c30, where the most
2294
significant 8 bits of a 24 bit word are placed into the least
2295
significant 8 bits of the opcode. */
2296
  BFD_RELOC_TIC30_LDP,
2297
 
2298
/* This is a 7bit reloc for the tms320c54x, where the least
2299
significant 7 bits of a 16 bit word are placed into the least
2300
significant 7 bits of the opcode. */
2301
  BFD_RELOC_TIC54X_PARTLS7,
2302
 
2303
/* This is a 9bit DP reloc for the tms320c54x, where the most
2304
significant 9 bits of a 16 bit word are placed into the least
2305
significant 9 bits of the opcode. */
2306
  BFD_RELOC_TIC54X_PARTMS9,
2307
 
2308
/* This is an extended address 23-bit reloc for the tms320c54x. */
2309
  BFD_RELOC_TIC54X_23,
2310
 
2311
/* This is a 16-bit reloc for the tms320c54x, where the least
2312
significant 16 bits of a 23-bit extended address are placed into
2313
the opcode. */
2314
  BFD_RELOC_TIC54X_16_OF_23,
2315
 
2316
/* This is a reloc for the tms320c54x, where the most
2317
significant 7 bits of a 23-bit extended address are placed into
2318
the opcode. */
2319
  BFD_RELOC_TIC54X_MS7_OF_23,
2320
 
2321
/* This is a 48 bit reloc for the FR30 that stores 32 bits. */
2322
  BFD_RELOC_FR30_48,
2323
 
2324
/* This is a 32 bit reloc for the FR30 that stores 20 bits split up into
2325
two sections. */
2326
  BFD_RELOC_FR30_20,
2327
 
2328
/* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
2329
4 bits. */
2330
  BFD_RELOC_FR30_6_IN_4,
2331
 
2332
/* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
2333
into 8 bits. */
2334
  BFD_RELOC_FR30_8_IN_8,
2335
 
2336
/* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
2337
into 8 bits. */
2338
  BFD_RELOC_FR30_9_IN_8,
2339
 
2340
/* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
2341
into 8 bits. */
2342
  BFD_RELOC_FR30_10_IN_8,
2343
 
2344
/* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
2345
short offset into 8 bits. */
2346
  BFD_RELOC_FR30_9_PCREL,
2347
 
2348
/* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
2349
short offset into 11 bits. */
2350
  BFD_RELOC_FR30_12_PCREL,
2351
 
2352
/* Motorola Mcore relocations. */
2353
  BFD_RELOC_MCORE_PCREL_IMM8BY4,
2354
  BFD_RELOC_MCORE_PCREL_IMM11BY2,
2355
  BFD_RELOC_MCORE_PCREL_IMM4BY2,
2356
  BFD_RELOC_MCORE_PCREL_32,
2357
  BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2,
2358
  BFD_RELOC_MCORE_RVA,
2359
 
2360
/* This is a 16 bit reloc for the AVR that stores 8 bit pc relative
2361
short offset into 7 bits. */
2362
  BFD_RELOC_AVR_7_PCREL,
2363
 
2364
/* This is a 16 bit reloc for the AVR that stores 13 bit pc relative
2365
short offset into 12 bits. */
2366
  BFD_RELOC_AVR_13_PCREL,
2367
 
2368
/* This is a 16 bit reloc for the AVR that stores 17 bit value (usually
2369
program memory address) into 16 bits. */
2370
  BFD_RELOC_AVR_16_PM,
2371
 
2372
/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2373
data memory address) into 8 bit immediate value of LDI insn. */
2374
  BFD_RELOC_AVR_LO8_LDI,
2375
 
2376
/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2377
of data memory address) into 8 bit immediate value of LDI insn. */
2378
  BFD_RELOC_AVR_HI8_LDI,
2379
 
2380
/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2381
of program memory address) into 8 bit immediate value of LDI insn. */
2382
  BFD_RELOC_AVR_HH8_LDI,
2383
 
2384
/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2385
(usually data memory address) into 8 bit immediate value of SUBI insn. */
2386
  BFD_RELOC_AVR_LO8_LDI_NEG,
2387
 
2388
/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2389
(high 8 bit of data memory address) into 8 bit immediate value of
2390
SUBI insn. */
2391
  BFD_RELOC_AVR_HI8_LDI_NEG,
2392
 
2393
/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2394
(most high 8 bit of program memory address) into 8 bit immediate value
2395
of LDI or SUBI insn. */
2396
  BFD_RELOC_AVR_HH8_LDI_NEG,
2397
 
2398
/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2399
command address) into 8 bit immediate value of LDI insn. */
2400
  BFD_RELOC_AVR_LO8_LDI_PM,
2401
 
2402
/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2403
of command address) into 8 bit immediate value of LDI insn. */
2404
  BFD_RELOC_AVR_HI8_LDI_PM,
2405
 
2406
/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2407
of command address) into 8 bit immediate value of LDI insn. */
2408
  BFD_RELOC_AVR_HH8_LDI_PM,
2409
 
2410
/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2411
(usually command address) into 8 bit immediate value of SUBI insn. */
2412
  BFD_RELOC_AVR_LO8_LDI_PM_NEG,
2413
 
2414
/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2415
(high 8 bit of 16 bit command address) into 8 bit immediate value
2416
of SUBI insn. */
2417
  BFD_RELOC_AVR_HI8_LDI_PM_NEG,
2418
 
2419
/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2420
(high 6 bit of 22 bit command address) into 8 bit immediate
2421
value of SUBI insn. */
2422
  BFD_RELOC_AVR_HH8_LDI_PM_NEG,
2423
 
2424
/* This is a 32 bit reloc for the AVR that stores 23 bit value
2425
into 22 bits. */
2426
  BFD_RELOC_AVR_CALL,
2427
 
2428
/* These two relocations are used by the linker to determine which of
2429
the entries in a C++ virtual function table are actually used.  When
2430
the --gc-sections option is given, the linker will zero out the entries
2431
that are not used, so that the code for those functions need not be
2432
included in the output.
2433
 
2434
VTABLE_INHERIT is a zero-space relocation used to describe to the
2435
linker the inheritence tree of a C++ virtual function table.  The
2436
relocation's symbol should be the parent class' vtable, and the
2437
relocation should be located at the child vtable.
2438
 
2439
VTABLE_ENTRY is a zero-space relocation that describes the use of a
2440
virtual function table entry.  The reloc's symbol should refer to the
2441
table of the class mentioned in the code.  Off of that base, an offset
2442
describes the entry that is being used.  For Rela hosts, this offset
2443
is stored in the reloc's addend.  For Rel hosts, we are forced to put
2444
this offset in the reloc's section offset. */
2445
  BFD_RELOC_VTABLE_INHERIT,
2446
  BFD_RELOC_VTABLE_ENTRY,
2447
  BFD_RELOC_UNUSED };
2448
typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2449
reloc_howto_type *
2450
 
2451
bfd_reloc_type_lookup  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
2452
 
2453
const char *
2454
bfd_get_reloc_code_name  PARAMS ((bfd_reloc_code_real_type code));
2455
 
2456
 
2457
typedef struct symbol_cache_entry
2458
{
2459
        /* A pointer to the BFD which owns the symbol. This information
2460
          is necessary so that a back end can work out what additional
2461
          information (invisible to the application writer) is carried
2462
          with the symbol.
2463
 
2464
          This field is *almost* redundant, since you can use section->owner
2465
          instead, except that some symbols point to the global sections
2466
          bfd_{abs,com,und}_section.  This could be fixed by making
2467
          these globals be per-bfd (or per-target-flavor).  FIXME. */
2468
 
2469
  struct _bfd *the_bfd;  /* Use bfd_asymbol_bfd(sym) to access this field. */
2470
 
2471
        /* The text of the symbol. The name is left alone, and not copied; the
2472
          application may not alter it. */
2473
  CONST char *name;
2474
 
2475
        /* The value of the symbol.  This really should be a union of a
2476
          numeric value with a pointer, since some flags indicate that
2477
          a pointer to another symbol is stored here.  */
2478
  symvalue value;
2479
 
2480
        /* Attributes of a symbol: */
2481
 
2482
#define BSF_NO_FLAGS    0x00
2483
 
2484
        /* The symbol has local scope; <<static>> in <<C>>. The value
2485
          is the offset into the section of the data. */
2486
#define BSF_LOCAL      0x01
2487
 
2488
        /* The symbol has global scope; initialized data in <<C>>. The
2489
          value is the offset into the section of the data. */
2490
#define BSF_GLOBAL     0x02
2491
 
2492
        /* The symbol has global scope and is exported. The value is
2493
          the offset into the section of the data. */
2494
#define BSF_EXPORT     BSF_GLOBAL  /* no real difference */
2495
 
2496
        /* A normal C symbol would be one of:
2497
          <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
2498
          <<BSF_GLOBAL>> */
2499
 
2500
        /* The symbol is a debugging record. The value has an arbitary
2501
          meaning, unless BSF_DEBUGGING_RELOC is also set.  */
2502
#define BSF_DEBUGGING  0x08
2503
 
2504
        /* The symbol denotes a function entry point.  Used in ELF,
2505
          perhaps others someday.  */
2506
#define BSF_FUNCTION    0x10
2507
 
2508
        /* Used by the linker. */
2509
#define BSF_KEEP        0x20
2510
#define BSF_KEEP_G      0x40
2511
 
2512
        /* A weak global symbol, overridable without warnings by
2513
          a regular global symbol of the same name.  */
2514
#define BSF_WEAK        0x80
2515
 
2516
        /* This symbol was created to point to a section, e.g. ELF's
2517
          STT_SECTION symbols.  */
2518
#define BSF_SECTION_SYM 0x100
2519
 
2520
        /* The symbol used to be a common symbol, but now it is
2521
          allocated. */
2522
#define BSF_OLD_COMMON  0x200
2523
 
2524
        /* The default value for common data. */
2525
#define BFD_FORT_COMM_DEFAULT_VALUE 0
2526
 
2527
        /* In some files the type of a symbol sometimes alters its
2528
          location in an output file - ie in coff a <<ISFCN>> symbol
2529
          which is also <<C_EXT>> symbol appears where it was
2530
          declared and not at the end of a section.  This bit is set
2531
          by the target BFD part to convey this information. */
2532
 
2533
#define BSF_NOT_AT_END    0x400
2534
 
2535
        /* Signal that the symbol is the label of constructor section. */
2536
#define BSF_CONSTRUCTOR   0x800
2537
 
2538
        /* Signal that the symbol is a warning symbol.  The name is a
2539
          warning.  The name of the next symbol is the one to warn about;
2540
          if a reference is made to a symbol with the same name as the next
2541
          symbol, a warning is issued by the linker. */
2542
#define BSF_WARNING       0x1000
2543
 
2544
        /* Signal that the symbol is indirect.  This symbol is an indirect
2545
          pointer to the symbol with the same name as the next symbol. */
2546
#define BSF_INDIRECT      0x2000
2547
 
2548
        /* BSF_FILE marks symbols that contain a file name.  This is used
2549
          for ELF STT_FILE symbols.  */
2550
#define BSF_FILE          0x4000
2551
 
2552
        /* Symbol is from dynamic linking information.  */
2553
#define BSF_DYNAMIC       0x8000
2554
 
2555
        /* The symbol denotes a data object.  Used in ELF, and perhaps
2556
          others someday.  */
2557
#define BSF_OBJECT        0x10000
2558
 
2559
        /* This symbol is a debugging symbol.  The value is the offset
2560
          into the section of the data.  BSF_DEBUGGING should be set
2561
          as well.  */
2562
#define BSF_DEBUGGING_RELOC 0x20000
2563
 
2564
  flagword flags;
2565
 
2566
        /* A pointer to the section to which this symbol is
2567
          relative.  This will always be non NULL, there are special
2568
          sections for undefined and absolute symbols.  */
2569
  struct sec *section;
2570
 
2571
        /* Back end special data.  */
2572
  union
2573
    {
2574
      PTR p;
2575
      bfd_vma i;
2576
    } udata;
2577
 
2578
} asymbol;
2579
#define bfd_get_symtab_upper_bound(abfd) \
2580
     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
2581
boolean
2582
bfd_is_local_label PARAMS ((bfd *abfd, asymbol *sym));
2583
 
2584
boolean
2585
bfd_is_local_label_name PARAMS ((bfd *abfd, const char *name));
2586
 
2587
#define bfd_is_local_label_name(abfd, name) \
2588
     BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
2589
#define bfd_canonicalize_symtab(abfd, location) \
2590
     BFD_SEND (abfd, _bfd_canonicalize_symtab,\
2591
                  (abfd, location))
2592
boolean
2593
bfd_set_symtab  PARAMS ((bfd *abfd, asymbol **location, unsigned int count));
2594
 
2595
void
2596
bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol));
2597
 
2598
#define bfd_make_empty_symbol(abfd) \
2599
     BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
2600
#define bfd_make_debug_symbol(abfd,ptr,size) \
2601
        BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
2602
int
2603
bfd_decode_symclass PARAMS ((asymbol *symbol));
2604
 
2605
boolean
2606
bfd_is_undefined_symclass  PARAMS ((int symclass));
2607
 
2608
void
2609
bfd_symbol_info PARAMS ((asymbol *symbol, symbol_info *ret));
2610
 
2611
boolean
2612
bfd_copy_private_symbol_data PARAMS ((bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym));
2613
 
2614
#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
2615
     BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
2616
               (ibfd, isymbol, obfd, osymbol))
2617
struct _bfd
2618
{
2619
     /* The filename the application opened the BFD with.  */
2620
    CONST char *filename;
2621
 
2622
     /* A pointer to the target jump table.             */
2623
    const struct bfd_target *xvec;
2624
 
2625
     /* To avoid dragging too many header files into every file that
2626
       includes `<<bfd.h>>', IOSTREAM has been declared as a "char
2627
       *", and MTIME as a "long".  Their correct types, to which they
2628
       are cast when used, are "FILE *" and "time_t".    The iostream
2629
       is the result of an fopen on the filename.  However, if the
2630
       BFD_IN_MEMORY flag is set, then iostream is actually a pointer
2631
       to a bfd_in_memory struct.  */
2632
    PTR iostream;
2633
 
2634
     /* Is the file descriptor being cached?  That is, can it be closed as
2635
       needed, and re-opened when accessed later?  */
2636
 
2637
    boolean cacheable;
2638
 
2639
     /* Marks whether there was a default target specified when the
2640
       BFD was opened. This is used to select which matching algorithm
2641
       to use to choose the back end. */
2642
 
2643
    boolean target_defaulted;
2644
 
2645
     /* The caching routines use these to maintain a
2646
       least-recently-used list of BFDs */
2647
 
2648
    struct _bfd *lru_prev, *lru_next;
2649
 
2650
     /* When a file is closed by the caching routines, BFD retains
2651
       state information on the file here: */
2652
 
2653
    file_ptr where;
2654
 
2655
     /* and here: (``once'' means at least once) */
2656
 
2657
    boolean opened_once;
2658
 
2659
     /* Set if we have a locally maintained mtime value, rather than
2660
       getting it from the file each time: */
2661
 
2662
    boolean mtime_set;
2663
 
2664
     /* File modified time, if mtime_set is true: */
2665
 
2666
    long mtime;
2667
 
2668
     /* Reserved for an unimplemented file locking extension.*/
2669
 
2670
    int ifd;
2671
 
2672
     /* The format which belongs to the BFD. (object, core, etc.) */
2673
 
2674
    bfd_format format;
2675
 
2676
     /* The direction the BFD was opened with*/
2677
 
2678
    enum bfd_direction {no_direction = 0,
2679
                        read_direction = 1,
2680
                        write_direction = 2,
2681
                        both_direction = 3} direction;
2682
 
2683
     /* Format_specific flags*/
2684
 
2685
    flagword flags;
2686
 
2687
     /* Currently my_archive is tested before adding origin to
2688
       anything. I believe that this can become always an add of
2689
       origin, with origin set to 0 for non archive files.   */
2690
 
2691
    file_ptr origin;
2692
 
2693
     /* Remember when output has begun, to stop strange things
2694
       from happening. */
2695
    boolean output_has_begun;
2696
 
2697
     /* Pointer to linked list of sections*/
2698
    struct sec  *sections;
2699
 
2700
     /* The number of sections */
2701
    unsigned int section_count;
2702
 
2703
     /* Stuff only useful for object files:
2704
       The start address. */
2705
    bfd_vma start_address;
2706
 
2707
     /* Used for input and output*/
2708
    unsigned int symcount;
2709
 
2710
     /* Symbol table for output BFD (with symcount entries) */
2711
    struct symbol_cache_entry  **outsymbols;
2712
 
2713
     /* Pointer to structure which contains architecture information*/
2714
    const struct bfd_arch_info *arch_info;
2715
 
2716
     /* Stuff only useful for archives:*/
2717
    PTR arelt_data;
2718
    struct _bfd *my_archive;      /* The containing archive BFD.  */
2719
    struct _bfd *next;            /* The next BFD in the archive.  */
2720
    struct _bfd *archive_head;    /* The first BFD in the archive.  */
2721
    boolean has_armap;
2722
 
2723
     /* A chain of BFD structures involved in a link.  */
2724
    struct _bfd *link_next;
2725
 
2726
     /* A field used by _bfd_generic_link_add_archive_symbols.  This will
2727
       be used only for archive elements.  */
2728
    int archive_pass;
2729
 
2730
     /* Used by the back end to hold private data. */
2731
 
2732
    union
2733
      {
2734
      struct aout_data_struct *aout_data;
2735
      struct artdata *aout_ar_data;
2736
      struct _oasys_data *oasys_obj_data;
2737
      struct _oasys_ar_data *oasys_ar_data;
2738
      struct coff_tdata *coff_obj_data;
2739
      struct pe_tdata *pe_obj_data;
2740
      struct xcoff_tdata *xcoff_obj_data;
2741
      struct ecoff_tdata *ecoff_obj_data;
2742
      struct ieee_data_struct *ieee_data;
2743
      struct ieee_ar_data_struct *ieee_ar_data;
2744
      struct srec_data_struct *srec_data;
2745
      struct ihex_data_struct *ihex_data;
2746
      struct tekhex_data_struct *tekhex_data;
2747
      struct elf_obj_tdata *elf_obj_data;
2748
      struct nlm_obj_tdata *nlm_obj_data;
2749
      struct bout_data_struct *bout_data;
2750
      struct sun_core_struct *sun_core_data;
2751
      struct sco5_core_struct *sco5_core_data;
2752
      struct trad_core_struct *trad_core_data;
2753
      struct som_data_struct *som_data;
2754
      struct hpux_core_struct *hpux_core_data;
2755
      struct hppabsd_core_struct *hppabsd_core_data;
2756
      struct sgi_core_struct *sgi_core_data;
2757
      struct lynx_core_struct *lynx_core_data;
2758
      struct osf_core_struct *osf_core_data;
2759
      struct cisco_core_struct *cisco_core_data;
2760
      struct versados_data_struct *versados_data;
2761
      struct netbsd_core_struct *netbsd_core_data;
2762
      PTR any;
2763
      } tdata;
2764
 
2765
     /* Used by the application to hold private data*/
2766
    PTR usrdata;
2767
 
2768
   /* Where all the allocated stuff under this BFD goes.  This is a
2769
     struct objalloc *, but we use PTR to avoid requiring the inclusion of
2770
     objalloc.h.  */
2771
    PTR memory;
2772
};
2773
 
2774
typedef enum bfd_error
2775
{
2776
  bfd_error_no_error = 0,
2777
  bfd_error_system_call,
2778
  bfd_error_invalid_target,
2779
  bfd_error_wrong_format,
2780
  bfd_error_invalid_operation,
2781
  bfd_error_no_memory,
2782
  bfd_error_no_symbols,
2783
  bfd_error_no_armap,
2784
  bfd_error_no_more_archived_files,
2785
  bfd_error_malformed_archive,
2786
  bfd_error_file_not_recognized,
2787
  bfd_error_file_ambiguously_recognized,
2788
  bfd_error_no_contents,
2789
  bfd_error_nonrepresentable_section,
2790
  bfd_error_no_debug_section,
2791
  bfd_error_bad_value,
2792
  bfd_error_file_truncated,
2793
  bfd_error_file_too_big,
2794
  bfd_error_invalid_error_code
2795
} bfd_error_type;
2796
 
2797
bfd_error_type
2798
bfd_get_error  PARAMS ((void));
2799
 
2800
void
2801
bfd_set_error  PARAMS ((bfd_error_type error_tag));
2802
 
2803
CONST char *
2804
bfd_errmsg  PARAMS ((bfd_error_type error_tag));
2805
 
2806
void
2807
bfd_perror  PARAMS ((CONST char *message));
2808
 
2809
typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...));
2810
 
2811
bfd_error_handler_type
2812
bfd_set_error_handler  PARAMS ((bfd_error_handler_type));
2813
 
2814
void
2815
bfd_set_error_program_name  PARAMS ((const char *));
2816
 
2817
bfd_error_handler_type
2818
bfd_get_error_handler  PARAMS ((void));
2819
 
2820
long
2821
bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect));
2822
 
2823
long
2824
bfd_canonicalize_reloc
2825
 PARAMS ((bfd *abfd,
2826
    asection *sec,
2827
    arelent **loc,
2828
    asymbol **syms));
2829
 
2830
void
2831
bfd_set_reloc
2832
 PARAMS ((bfd *abfd, asection *sec, arelent **rel, unsigned int count)
2833
 
2834
    );
2835
 
2836
boolean
2837
bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags));
2838
 
2839
boolean
2840
bfd_set_start_address PARAMS ((bfd *abfd, bfd_vma vma));
2841
 
2842
long
2843
bfd_get_mtime PARAMS ((bfd *abfd));
2844
 
2845
long
2846
bfd_get_size PARAMS ((bfd *abfd));
2847
 
2848
int
2849
bfd_get_gp_size PARAMS ((bfd *abfd));
2850
 
2851
void
2852
bfd_set_gp_size PARAMS ((bfd *abfd, int i));
2853
 
2854
bfd_vma
2855
bfd_scan_vma PARAMS ((CONST char *string, CONST char **end, int base));
2856
 
2857
boolean
2858
bfd_copy_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
2859
 
2860
#define bfd_copy_private_bfd_data(ibfd, obfd) \
2861
     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
2862
               (ibfd, obfd))
2863
boolean
2864
bfd_merge_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
2865
 
2866
#define bfd_merge_private_bfd_data(ibfd, obfd) \
2867
     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
2868
               (ibfd, obfd))
2869
boolean
2870
bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags));
2871
 
2872
#define bfd_set_private_flags(abfd, flags) \
2873
     BFD_SEND (abfd, _bfd_set_private_flags, \
2874
               (abfd, flags))
2875
#define bfd_sizeof_headers(abfd, reloc) \
2876
     BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
2877
 
2878
#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
2879
     BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
2880
 
2881
        /* Do these three do anything useful at all, for any back end?  */
2882
#define bfd_debug_info_start(abfd) \
2883
        BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
2884
 
2885
#define bfd_debug_info_end(abfd) \
2886
        BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
2887
 
2888
#define bfd_debug_info_accumulate(abfd, section) \
2889
        BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
2890
 
2891
 
2892
#define bfd_stat_arch_elt(abfd, stat) \
2893
        BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
2894
 
2895
#define bfd_update_armap_timestamp(abfd) \
2896
        BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
2897
 
2898
#define bfd_set_arch_mach(abfd, arch, mach)\
2899
        BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
2900
 
2901
#define bfd_relax_section(abfd, section, link_info, again) \
2902
       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
2903
 
2904
#define bfd_gc_sections(abfd, link_info) \
2905
       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
2906
 
2907
#define bfd_link_hash_table_create(abfd) \
2908
       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
2909
 
2910
#define bfd_link_add_symbols(abfd, info) \
2911
       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
2912
 
2913
#define bfd_final_link(abfd, info) \
2914
       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
2915
 
2916
#define bfd_free_cached_info(abfd) \
2917
       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
2918
 
2919
#define bfd_get_dynamic_symtab_upper_bound(abfd) \
2920
       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
2921
 
2922
#define bfd_print_private_bfd_data(abfd, file)\
2923
       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
2924
 
2925
#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
2926
       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
2927
 
2928
#define bfd_get_dynamic_reloc_upper_bound(abfd) \
2929
       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
2930
 
2931
#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
2932
       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
2933
 
2934
extern bfd_byte *bfd_get_relocated_section_contents
2935
       PARAMS ((bfd *, struct bfd_link_info *,
2936
                 struct bfd_link_order *, bfd_byte *,
2937
                 boolean, asymbol **));
2938
 
2939
symindex
2940
bfd_get_next_mapent PARAMS ((bfd *abfd, symindex previous, carsym **sym));
2941
 
2942
boolean
2943
bfd_set_archive_head PARAMS ((bfd *output, bfd *new_head));
2944
 
2945
bfd *
2946
bfd_openr_next_archived_file PARAMS ((bfd *archive, bfd *previous));
2947
 
2948
CONST char *
2949
bfd_core_file_failing_command PARAMS ((bfd *abfd));
2950
 
2951
int
2952
bfd_core_file_failing_signal PARAMS ((bfd *abfd));
2953
 
2954
boolean
2955
core_file_matches_executable_p
2956
 PARAMS ((bfd *core_bfd, bfd *exec_bfd));
2957
 
2958
#define BFD_SEND(bfd, message, arglist) \
2959
               ((*((bfd)->xvec->message)) arglist)
2960
 
2961
#ifdef DEBUG_BFD_SEND
2962
#undef BFD_SEND
2963
#define BFD_SEND(bfd, message, arglist) \
2964
  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
2965
    ((*((bfd)->xvec->message)) arglist) : \
2966
    (bfd_assert (__FILE__,__LINE__), NULL))
2967
#endif
2968
#define BFD_SEND_FMT(bfd, message, arglist) \
2969
            (((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
2970
 
2971
#ifdef DEBUG_BFD_SEND
2972
#undef BFD_SEND_FMT
2973
#define BFD_SEND_FMT(bfd, message, arglist) \
2974
  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
2975
   (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) : \
2976
   (bfd_assert (__FILE__,__LINE__), NULL))
2977
#endif
2978
enum bfd_flavour {
2979
  bfd_target_unknown_flavour,
2980
  bfd_target_aout_flavour,
2981
  bfd_target_coff_flavour,
2982
  bfd_target_ecoff_flavour,
2983
  bfd_target_elf_flavour,
2984
  bfd_target_ieee_flavour,
2985
  bfd_target_nlm_flavour,
2986
  bfd_target_oasys_flavour,
2987
  bfd_target_tekhex_flavour,
2988
  bfd_target_srec_flavour,
2989
  bfd_target_ihex_flavour,
2990
  bfd_target_som_flavour,
2991
  bfd_target_os9k_flavour,
2992
  bfd_target_versados_flavour,
2993
  bfd_target_msdos_flavour,
2994
  bfd_target_ovax_flavour,
2995
  bfd_target_evax_flavour
2996
};
2997
 
2998
enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };
2999
 
3000
 /* Forward declaration.  */
3001
typedef struct bfd_link_info _bfd_link_info;
3002
 
3003
typedef struct bfd_target
3004
{
3005
  char *name;
3006
  enum bfd_flavour flavour;
3007
  enum bfd_endian byteorder;
3008
  enum bfd_endian header_byteorder;
3009
  flagword object_flags;
3010
  flagword section_flags;
3011
  char symbol_leading_char;
3012
  char ar_pad_char;
3013
  unsigned short ar_max_namelen;
3014
  bfd_vma      (*bfd_getx64) PARAMS ((const bfd_byte *));
3015
  bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((const bfd_byte *));
3016
  void         (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *));
3017
  bfd_vma      (*bfd_getx32) PARAMS ((const bfd_byte *));
3018
  bfd_signed_vma (*bfd_getx_signed_32) PARAMS ((const bfd_byte *));
3019
  void         (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *));
3020
  bfd_vma      (*bfd_getx16) PARAMS ((const bfd_byte *));
3021
  bfd_signed_vma (*bfd_getx_signed_16) PARAMS ((const bfd_byte *));
3022
  void         (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *));
3023
  bfd_vma      (*bfd_h_getx64) PARAMS ((const bfd_byte *));
3024
  bfd_signed_vma (*bfd_h_getx_signed_64) PARAMS ((const bfd_byte *));
3025
  void         (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *));
3026
  bfd_vma      (*bfd_h_getx32) PARAMS ((const bfd_byte *));
3027
  bfd_signed_vma (*bfd_h_getx_signed_32) PARAMS ((const bfd_byte *));
3028
  void         (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *));
3029
  bfd_vma      (*bfd_h_getx16) PARAMS ((const bfd_byte *));
3030
  bfd_signed_vma (*bfd_h_getx_signed_16) PARAMS ((const bfd_byte *));
3031
  void         (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *));
3032
  const struct bfd_target *(*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *));
3033
  boolean             (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *));
3034
  boolean             (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *));
3035
 
3036
   /* Generic entry points.  */
3037
#define BFD_JUMP_TABLE_GENERIC(NAME)\
3038
CAT(NAME,_close_and_cleanup),\
3039
CAT(NAME,_bfd_free_cached_info),\
3040
CAT(NAME,_new_section_hook),\
3041
CAT(NAME,_get_section_contents),\
3042
CAT(NAME,_get_section_contents_in_window)
3043
 
3044
   /* Called when the BFD is being closed to do any necessary cleanup.  */
3045
  boolean       (*_close_and_cleanup) PARAMS ((bfd *));
3046
   /* Ask the BFD to free all cached information.  */
3047
  boolean (*_bfd_free_cached_info) PARAMS ((bfd *));
3048
   /* Called when a new section is created.  */
3049
  boolean       (*_new_section_hook) PARAMS ((bfd *, sec_ptr));
3050
   /* Read the contents of a section.  */
3051
  boolean       (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
3052
                                            file_ptr, bfd_size_type));
3053
  boolean       (*_bfd_get_section_contents_in_window)
3054
                          PARAMS ((bfd *, sec_ptr, bfd_window *,
3055
                                   file_ptr, bfd_size_type));
3056
 
3057
   /* Entry points to copy private data.  */
3058
#define BFD_JUMP_TABLE_COPY(NAME)\
3059
CAT(NAME,_bfd_copy_private_bfd_data),\
3060
CAT(NAME,_bfd_merge_private_bfd_data),\
3061
CAT(NAME,_bfd_copy_private_section_data),\
3062
CAT(NAME,_bfd_copy_private_symbol_data),\
3063
CAT(NAME,_bfd_set_private_flags),\
3064
CAT(NAME,_bfd_print_private_bfd_data)\
3065
   /* Called to copy BFD general private data from one object file
3066
     to another.  */
3067
  boolean       (*_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *));
3068
   /* Called to merge BFD general private data from one object file
3069
     to a common output file when linking.  */
3070
  boolean       (*_bfd_merge_private_bfd_data) PARAMS ((bfd *, bfd *));
3071
   /* Called to copy BFD private section data from one object file
3072
     to another.  */
3073
  boolean       (*_bfd_copy_private_section_data) PARAMS ((bfd *, sec_ptr,
3074
                                                       bfd *, sec_ptr));
3075
   /* Called to copy BFD private symbol data from one symbol
3076
     to another.  */
3077
  boolean       (*_bfd_copy_private_symbol_data) PARAMS ((bfd *, asymbol *,
3078
                                                          bfd *, asymbol *));
3079
   /* Called to set private backend flags */
3080
  boolean       (*_bfd_set_private_flags) PARAMS ((bfd *, flagword));
3081
 
3082
   /* Called to print private BFD data */
3083
  boolean       (*_bfd_print_private_bfd_data) PARAMS ((bfd *, PTR));
3084
 
3085
   /* Core file entry points.  */
3086
#define BFD_JUMP_TABLE_CORE(NAME)\
3087
CAT(NAME,_core_file_failing_command),\
3088
CAT(NAME,_core_file_failing_signal),\
3089
CAT(NAME,_core_file_matches_executable_p)
3090
  char *   (*_core_file_failing_command) PARAMS ((bfd *));
3091
  int      (*_core_file_failing_signal) PARAMS ((bfd *));
3092
  boolean  (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *));
3093
 
3094
   /* Archive entry points.  */
3095
#define BFD_JUMP_TABLE_ARCHIVE(NAME)\
3096
CAT(NAME,_slurp_armap),\
3097
CAT(NAME,_slurp_extended_name_table),\
3098
CAT(NAME,_construct_extended_name_table),\
3099
CAT(NAME,_truncate_arname),\
3100
CAT(NAME,_write_armap),\
3101
CAT(NAME,_read_ar_hdr),\
3102
CAT(NAME,_openr_next_archived_file),\
3103
CAT(NAME,_get_elt_at_index),\
3104
CAT(NAME,_generic_stat_arch_elt),\
3105
CAT(NAME,_update_armap_timestamp)
3106
  boolean  (*_bfd_slurp_armap) PARAMS ((bfd *));
3107
  boolean  (*_bfd_slurp_extended_name_table) PARAMS ((bfd *));
3108
  boolean  (*_bfd_construct_extended_name_table)
3109
             PARAMS ((bfd *, char **, bfd_size_type *, const char **));
3110
  void     (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *));
3111
  boolean  (*write_armap) PARAMS ((bfd *arch,
3112
                              unsigned int elength,
3113
                              struct orl *map,
3114
                              unsigned int orl_count,
3115
                              int stridx));
3116
  PTR (*_bfd_read_ar_hdr_fn) PARAMS ((bfd *));
3117
  bfd *    (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev));
3118
#define bfd_get_elt_at_index(b,i) BFD_SEND(b, _bfd_get_elt_at_index, (b,i))
3119
  bfd *    (*_bfd_get_elt_at_index) PARAMS ((bfd *, symindex));
3120
  int      (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *));
3121
  boolean  (*_bfd_update_armap_timestamp) PARAMS ((bfd *));
3122
 
3123
   /* Entry points used for symbols.  */
3124
#define BFD_JUMP_TABLE_SYMBOLS(NAME)\
3125
CAT(NAME,_get_symtab_upper_bound),\
3126
CAT(NAME,_get_symtab),\
3127
CAT(NAME,_make_empty_symbol),\
3128
CAT(NAME,_print_symbol),\
3129
CAT(NAME,_get_symbol_info),\
3130
CAT(NAME,_bfd_is_local_label_name),\
3131
CAT(NAME,_get_lineno),\
3132
CAT(NAME,_find_nearest_line),\
3133
CAT(NAME,_bfd_make_debug_symbol),\
3134
CAT(NAME,_read_minisymbols),\
3135
CAT(NAME,_minisymbol_to_symbol)
3136
  long  (*_bfd_get_symtab_upper_bound) PARAMS ((bfd *));
3137
  long  (*_bfd_canonicalize_symtab) PARAMS ((bfd *,
3138
                                             struct symbol_cache_entry **));
3139
  struct symbol_cache_entry  *
3140
                (*_bfd_make_empty_symbol) PARAMS ((bfd *));
3141
  void          (*_bfd_print_symbol) PARAMS ((bfd *, PTR,
3142
                                      struct symbol_cache_entry *,
3143
                                      bfd_print_symbol_type));
3144
#define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
3145
  void          (*_bfd_get_symbol_info) PARAMS ((bfd *,
3146
                                      struct symbol_cache_entry *,
3147
                                      symbol_info *));
3148
#define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e))
3149
  boolean       (*_bfd_is_local_label_name) PARAMS ((bfd *, const char *));
3150
 
3151
  alent *    (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *));
3152
  boolean    (*_bfd_find_nearest_line) PARAMS ((bfd *abfd,
3153
                    struct sec *section, struct symbol_cache_entry **symbols,
3154
                    bfd_vma offset, CONST char **file, CONST char **func,
3155
                    unsigned int *line));
3156
  /* Back-door to allow format-aware applications to create debug symbols
3157
    while using BFD for everything else.  Currently used by the assembler
3158
    when creating COFF files.  */
3159
  asymbol *  (*_bfd_make_debug_symbol) PARAMS ((
3160
       bfd *abfd,
3161
       void *ptr,
3162
       unsigned long size));
3163
#define bfd_read_minisymbols(b, d, m, s) \
3164
  BFD_SEND (b, _read_minisymbols, (b, d, m, s))
3165
  long  (*_read_minisymbols) PARAMS ((bfd *, boolean, PTR *,
3166
                                      unsigned int *));
3167
#define bfd_minisymbol_to_symbol(b, d, m, f) \
3168
  BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
3169
  asymbol *(*_minisymbol_to_symbol) PARAMS ((bfd *, boolean, const PTR,
3170
                                             asymbol *));
3171
 
3172
   /* Routines for relocs.  */
3173
#define BFD_JUMP_TABLE_RELOCS(NAME)\
3174
CAT(NAME,_get_reloc_upper_bound),\
3175
CAT(NAME,_canonicalize_reloc),\
3176
CAT(NAME,_bfd_reloc_type_lookup)
3177
  long  (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr));
3178
  long  (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **,
3179
                                            struct symbol_cache_entry **));
3180
   /* See documentation on reloc types.  */
3181
  reloc_howto_type *
3182
       (*reloc_type_lookup) PARAMS ((bfd *abfd,
3183
                                     bfd_reloc_code_real_type code));
3184
 
3185
   /* Routines used when writing an object file.  */
3186
#define BFD_JUMP_TABLE_WRITE(NAME)\
3187
CAT(NAME,_set_arch_mach),\
3188
CAT(NAME,_set_section_contents)
3189
  boolean    (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture,
3190
                    unsigned long));
3191
  boolean       (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
3192
                                            file_ptr, bfd_size_type));
3193
 
3194
   /* Routines used by the linker.  */
3195
#define BFD_JUMP_TABLE_LINK(NAME)\
3196
CAT(NAME,_sizeof_headers),\
3197
CAT(NAME,_bfd_get_relocated_section_contents),\
3198
CAT(NAME,_bfd_relax_section),\
3199
CAT(NAME,_bfd_link_hash_table_create),\
3200
CAT(NAME,_bfd_link_add_symbols),\
3201
CAT(NAME,_bfd_final_link),\
3202
CAT(NAME,_bfd_link_split_section),\
3203
CAT(NAME,_bfd_gc_sections)
3204
  int        (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean));
3205
  bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *,
3206
                    struct bfd_link_info *, struct bfd_link_order *,
3207
                    bfd_byte *data, boolean relocateable,
3208
                    struct symbol_cache_entry **));
3209
 
3210
  boolean    (*_bfd_relax_section) PARAMS ((bfd *, struct sec *,
3211
                    struct bfd_link_info *, boolean *again));
3212
 
3213
   /* Create a hash table for the linker.  Different backends store
3214
     different information in this table.  */
3215
  struct bfd_link_hash_table *(*_bfd_link_hash_table_create) PARAMS ((bfd *));
3216
 
3217
   /* Add symbols from this object file into the hash table.  */
3218
  boolean (*_bfd_link_add_symbols) PARAMS ((bfd *, struct bfd_link_info *));
3219
 
3220
   /* Do a link based on the link_order structures attached to each
3221
     section of the BFD.  */
3222
  boolean (*_bfd_final_link) PARAMS ((bfd *, struct bfd_link_info *));
3223
 
3224
   /* Should this section be split up into smaller pieces during linking.  */
3225
  boolean (*_bfd_link_split_section) PARAMS ((bfd *, struct sec *));
3226
 
3227
   /* Remove sections that are not referenced from the output.  */
3228
  boolean (*_bfd_gc_sections) PARAMS ((bfd *, struct bfd_link_info *));
3229
 
3230
   /* Routines to handle dynamic symbols and relocs.  */
3231
#define BFD_JUMP_TABLE_DYNAMIC(NAME)\
3232
CAT(NAME,_get_dynamic_symtab_upper_bound),\
3233
CAT(NAME,_canonicalize_dynamic_symtab),\
3234
CAT(NAME,_get_dynamic_reloc_upper_bound),\
3235
CAT(NAME,_canonicalize_dynamic_reloc)
3236
   /* Get the amount of memory required to hold the dynamic symbols. */
3237
  long  (*_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd *));
3238
   /* Read in the dynamic symbols.  */
3239
  long  (*_bfd_canonicalize_dynamic_symtab)
3240
    PARAMS ((bfd *, struct symbol_cache_entry **));
3241
   /* Get the amount of memory required to hold the dynamic relocs.  */
3242
  long  (*_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd *));
3243
   /* Read in the dynamic relocs.  */
3244
  long  (*_bfd_canonicalize_dynamic_reloc)
3245
    PARAMS ((bfd *, arelent **, struct symbol_cache_entry **));
3246
 
3247
  /* Opposite endian version of this target.  */
3248
 const struct bfd_target * alternative_target;
3249
 
3250
 PTR backend_data;
3251
 
3252
} bfd_target;
3253
boolean
3254
bfd_set_default_target  PARAMS ((const char *name));
3255
 
3256
const bfd_target *
3257
bfd_find_target PARAMS ((CONST char *target_name, bfd *abfd));
3258
 
3259
const char **
3260
bfd_target_list PARAMS ((void));
3261
 
3262
const bfd_target *
3263
bfd_search_for_target  PARAMS ((int (* search_func)(const bfd_target *, void *), void *));
3264
 
3265
boolean
3266
bfd_check_format PARAMS ((bfd *abfd, bfd_format format));
3267
 
3268
boolean
3269
bfd_check_format_matches PARAMS ((bfd *abfd, bfd_format format, char ***matching));
3270
 
3271
boolean
3272
bfd_set_format PARAMS ((bfd *abfd, bfd_format format));
3273
 
3274
CONST char *
3275
bfd_format_string PARAMS ((bfd_format format));
3276
 
3277
#ifdef __cplusplus
3278
}
3279
#endif
3280
#endif

powered by: WebSVN 2.1.0

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