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