Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6324 | serge | 1 | /* Main header file for the bfd library -- portable access to object files. |
2 | |||
3 | Copyright (C) 1990-2015 Free Software Foundation, Inc. |
||
4 | |||
5 | Contributed by Cygnus Support. |
||
6 | |||
7 | This file is part of BFD, the Binary File Descriptor library. |
||
8 | |||
9 | This program is free software; you can redistribute it and/or modify |
||
10 | it under the terms of the GNU General Public License as published by |
||
11 | the Free Software Foundation; either version 3 of the License, or |
||
12 | (at your option) any later version. |
||
13 | |||
14 | This program is distributed in the hope that it will be useful, |
||
15 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
17 | GNU General Public License for more details. |
||
18 | |||
19 | You should have received a copy of the GNU General Public License |
||
20 | along with this program; if not, write to the Free Software |
||
21 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ |
||
22 | |||
23 | #ifndef __BFD_H_SEEN__ |
||
24 | #define __BFD_H_SEEN__ |
||
25 | |||
26 | /* PR 14072: Ensure that config.h is included first. */ |
||
27 | #if !defined PACKAGE && !defined PACKAGE_VERSION |
||
28 | #error config.h must be included before this header |
||
29 | #endif |
||
30 | |||
31 | #ifdef __cplusplus |
||
32 | extern "C" { |
||
33 | #endif |
||
34 | |||
35 | #include "ansidecl.h" |
||
36 | #include "symcat.h" |
||
37 | #include |
||
38 | |||
39 | #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE) |
||
40 | #ifndef SABER |
||
41 | /* This hack is to avoid a problem with some strict ANSI C preprocessors. |
||
42 | The problem is, "32_" is not a valid preprocessing token, and we don't |
||
43 | want extra underscores (e.g., "nlm_32_"). The XCONCAT2 macro will |
||
44 | cause the inner CONCAT2 macros to be evaluated first, producing |
||
45 | still-valid pp-tokens. Then the final concatenation can be done. */ |
||
46 | #undef CONCAT4 |
||
47 | #define CONCAT4(a,b,c,d) XCONCAT2(CONCAT2(a,b),CONCAT2(c,d)) |
||
48 | #endif |
||
49 | #endif |
||
50 | |||
51 | /* This is a utility macro to handle the situation where the code |
||
52 | wants to place a constant string into the code, followed by a |
||
53 | comma and then the length of the string. Doing this by hand |
||
54 | is error prone, so using this macro is safer. */ |
||
55 | #define STRING_COMMA_LEN(STR) (STR), (sizeof (STR) - 1) |
||
56 | /* Unfortunately it is not possible to use the STRING_COMMA_LEN macro |
||
57 | to create the arguments to another macro, since the preprocessor |
||
58 | will mis-count the number of arguments to the outer macro (by not |
||
59 | evaluating STRING_COMMA_LEN and so missing the comma). This is a |
||
60 | problem for example when trying to use STRING_COMMA_LEN to build |
||
61 | the arguments to the strncmp() macro. Hence this alternative |
||
62 | definition of strncmp is provided here. |
||
63 | |||
64 | Note - these macros do NOT work if STR2 is not a constant string. */ |
||
65 | #define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0) |
||
66 | /* strcpy() can have a similar problem, but since we know we are |
||
67 | copying a constant string, we can use memcpy which will be faster |
||
68 | since there is no need to check for a NUL byte inside STR. We |
||
69 | can also save time if we do not need to copy the terminating NUL. */ |
||
70 | #define LITMEMCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2) - 1) |
||
71 | #define LITSTRCPY(DEST,STR2) memcpy ((DEST), (STR2), sizeof (STR2)) |
||
72 | |||
73 | |||
74 | #define BFD_SUPPORTS_PLUGINS @supports_plugins@ |
||
75 | |||
76 | /* The word size used by BFD on the host. This may be 64 with a 32 |
||
77 | bit target if the host is 64 bit, or if other 64 bit targets have |
||
78 | been selected with --enable-targets, or if --enable-64-bit-bfd. */ |
||
79 | #define BFD_ARCH_SIZE @wordsize@ |
||
80 | |||
81 | /* The word size of the default bfd target. */ |
||
82 | #define BFD_DEFAULT_TARGET_SIZE @bfd_default_target_size@ |
||
83 | |||
84 | #define BFD_HOST_64BIT_LONG @BFD_HOST_64BIT_LONG@ |
||
85 | #define BFD_HOST_64BIT_LONG_LONG @BFD_HOST_64BIT_LONG_LONG@ |
||
86 | #if @BFD_HOST_64_BIT_DEFINED@ |
||
87 | #define BFD_HOST_64_BIT @BFD_HOST_64_BIT@ |
||
88 | #define BFD_HOST_U_64_BIT @BFD_HOST_U_64_BIT@ |
||
89 | typedef BFD_HOST_64_BIT bfd_int64_t; |
||
90 | typedef BFD_HOST_U_64_BIT bfd_uint64_t; |
||
91 | #endif |
||
92 | |||
93 | #if BFD_ARCH_SIZE >= 64 |
||
94 | #define BFD64 |
||
95 | #endif |
||
96 | |||
97 | #ifndef INLINE |
||
98 | #if __GNUC__ >= 2 |
||
99 | #define INLINE __inline__ |
||
100 | #else |
||
101 | #define INLINE |
||
102 | #endif |
||
103 | #endif |
||
104 | |||
105 | /* Declaring a type wide enough to hold a host long and a host pointer. */ |
||
106 | #define BFD_HOSTPTR_T @BFD_HOSTPTR_T@ |
||
107 | typedef BFD_HOSTPTR_T bfd_hostptr_t; |
||
108 | |||
109 | /* Forward declaration. */ |
||
110 | typedef struct bfd bfd; |
||
111 | |||
112 | /* Boolean type used in bfd. Too many systems define their own |
||
113 | versions of "boolean" for us to safely typedef a "boolean" of |
||
114 | our own. Using an enum for "bfd_boolean" has its own set of |
||
115 | problems, with strange looking casts required to avoid warnings |
||
116 | on some older compilers. Thus we just use an int. |
||
117 | |||
118 | General rule: Functions which are bfd_boolean return TRUE on |
||
119 | success and FALSE on failure (unless they're a predicate). */ |
||
120 | |||
121 | typedef int bfd_boolean; |
||
122 | #undef FALSE |
||
123 | #undef TRUE |
||
124 | #define FALSE 0 |
||
125 | #define TRUE 1 |
||
126 | |||
127 | #ifdef BFD64 |
||
128 | |||
129 | #ifndef BFD_HOST_64_BIT |
||
130 | #error No 64 bit integer type available |
||
131 | #endif /* ! defined (BFD_HOST_64_BIT) */ |
||
132 | |||
133 | typedef BFD_HOST_U_64_BIT bfd_vma; |
||
134 | typedef BFD_HOST_64_BIT bfd_signed_vma; |
||
135 | typedef BFD_HOST_U_64_BIT bfd_size_type; |
||
136 | typedef BFD_HOST_U_64_BIT symvalue; |
||
137 | |||
138 | #if BFD_HOST_64BIT_LONG |
||
139 | #define BFD_VMA_FMT "l" |
||
140 | #elif defined (__MSVCRT__) |
||
141 | #define BFD_VMA_FMT "I64" |
||
142 | #else |
||
143 | #define BFD_VMA_FMT "ll" |
||
144 | #endif |
||
145 | |||
146 | #ifndef fprintf_vma |
||
147 | #define sprintf_vma(s,x) sprintf (s, "%016" BFD_VMA_FMT "x", x) |
||
148 | #define fprintf_vma(f,x) fprintf (f, "%016" BFD_VMA_FMT "x", x) |
||
149 | #endif |
||
150 | |||
151 | #else /* not BFD64 */ |
||
152 | |||
153 | /* Represent a target address. Also used as a generic unsigned type |
||
154 | which is guaranteed to be big enough to hold any arithmetic types |
||
155 | we need to deal with. */ |
||
156 | typedef unsigned long bfd_vma; |
||
157 | |||
158 | /* A generic signed type which is guaranteed to be big enough to hold any |
||
159 | arithmetic types we need to deal with. Can be assumed to be compatible |
||
160 | with bfd_vma in the same way that signed and unsigned ints are compatible |
||
161 | (as parameters, in assignment, etc). */ |
||
162 | typedef long bfd_signed_vma; |
||
163 | |||
164 | typedef unsigned long symvalue; |
||
165 | typedef unsigned long bfd_size_type; |
||
166 | |||
167 | /* Print a bfd_vma x on stream s. */ |
||
168 | #define BFD_VMA_FMT "l" |
||
169 | #define fprintf_vma(s,x) fprintf (s, "%08" BFD_VMA_FMT "x", x) |
||
170 | #define sprintf_vma(s,x) sprintf (s, "%08" BFD_VMA_FMT "x", x) |
||
171 | |||
172 | #endif /* not BFD64 */ |
||
173 | |||
174 | #define HALF_BFD_SIZE_TYPE \ |
||
175 | (((bfd_size_type) 1) << (8 * sizeof (bfd_size_type) / 2)) |
||
176 | |||
177 | #ifndef BFD_HOST_64_BIT |
||
178 | /* Fall back on a 32 bit type. The idea is to make these types always |
||
179 | available for function return types, but in the case that |
||
180 | BFD_HOST_64_BIT is undefined such a function should abort or |
||
181 | otherwise signal an error. */ |
||
182 | typedef bfd_signed_vma bfd_int64_t; |
||
183 | typedef bfd_vma bfd_uint64_t; |
||
184 | #endif |
||
185 | |||
186 | /* An offset into a file. BFD always uses the largest possible offset |
||
187 | based on the build time availability of fseek, fseeko, or fseeko64. */ |
||
188 | typedef @bfd_file_ptr@ file_ptr; |
||
189 | typedef unsigned @bfd_file_ptr@ ufile_ptr; |
||
190 | |||
191 | extern void bfd_sprintf_vma (bfd *, char *, bfd_vma); |
||
192 | extern void bfd_fprintf_vma (bfd *, void *, bfd_vma); |
||
193 | |||
194 | #define printf_vma(x) fprintf_vma(stdout,x) |
||
195 | #define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x) |
||
196 | |||
197 | typedef unsigned int flagword; /* 32 bits of flags */ |
||
198 | typedef unsigned char bfd_byte; |
||
199 | |||
200 | /* File formats. */ |
||
201 | |||
202 | typedef enum bfd_format |
||
203 | { |
||
204 | bfd_unknown = 0, /* File format is unknown. */ |
||
205 | bfd_object, /* Linker/assembler/compiler output. */ |
||
206 | bfd_archive, /* Object archive file. */ |
||
207 | bfd_core, /* Core dump. */ |
||
208 | bfd_type_end /* Marks the end; don't use it! */ |
||
209 | } |
||
210 | bfd_format; |
||
211 | |||
212 | /* Symbols and relocation. */ |
||
213 | |||
214 | /* A count of carsyms (canonical archive symbols). */ |
||
215 | typedef unsigned long symindex; |
||
216 | |||
217 | /* How to perform a relocation. */ |
||
218 | typedef const struct reloc_howto_struct reloc_howto_type; |
||
219 | |||
220 | #define BFD_NO_MORE_SYMBOLS ((symindex) ~0) |
||
221 | |||
222 | /* General purpose part of a symbol X; |
||
223 | target specific parts are in libcoff.h, libaout.h, etc. */ |
||
224 | |||
225 | #define bfd_get_section(x) ((x)->section) |
||
226 | #define bfd_get_output_section(x) ((x)->section->output_section) |
||
227 | #define bfd_set_section(x,y) ((x)->section) = (y) |
||
228 | #define bfd_asymbol_base(x) ((x)->section->vma) |
||
229 | #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value) |
||
230 | #define bfd_asymbol_name(x) ((x)->name) |
||
231 | /*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/ |
||
232 | #define bfd_asymbol_bfd(x) ((x)->the_bfd) |
||
233 | #define bfd_asymbol_flavour(x) \ |
||
234 | (((x)->flags & BSF_SYNTHETIC) != 0 \ |
||
235 | ? bfd_target_unknown_flavour \ |
||
236 | : bfd_asymbol_bfd (x)->xvec->flavour) |
||
237 | |||
238 | /* A canonical archive symbol. */ |
||
239 | /* This is a type pun with struct ranlib on purpose! */ |
||
240 | typedef struct carsym |
||
241 | { |
||
242 | char *name; |
||
243 | file_ptr file_offset; /* Look here to find the file. */ |
||
244 | } |
||
245 | carsym; /* To make these you call a carsymogen. */ |
||
246 | |||
247 | /* Used in generating armaps (archive tables of contents). |
||
248 | Perhaps just a forward definition would do? */ |
||
249 | struct orl /* Output ranlib. */ |
||
250 | { |
||
251 | char **name; /* Symbol name. */ |
||
252 | union |
||
253 | { |
||
254 | file_ptr pos; |
||
255 | bfd *abfd; |
||
256 | } u; /* bfd* or file position. */ |
||
257 | int namidx; /* Index into string table. */ |
||
258 | }; |
||
259 | |||
260 | /* Linenumber stuff. */ |
||
261 | typedef struct lineno_cache_entry |
||
262 | { |
||
263 | unsigned int line_number; /* Linenumber from start of function. */ |
||
264 | union |
||
265 | { |
||
266 | struct bfd_symbol *sym; /* Function name. */ |
||
267 | bfd_vma offset; /* Offset into section. */ |
||
268 | } u; |
||
269 | } |
||
270 | alent; |
||
271 | |||
272 | /* Object and core file sections. */ |
||
273 | |||
274 | #define align_power(addr, align) \ |
||
275 | (((addr) + ((bfd_vma) 1 << (align)) - 1) & (-((bfd_vma) 1 << (align)))) |
||
276 | |||
277 | typedef struct bfd_section *sec_ptr; |
||
278 | |||
279 | #define bfd_get_section_name(bfd, ptr) ((void) bfd, (ptr)->name) |
||
280 | #define bfd_get_section_vma(bfd, ptr) ((void) bfd, (ptr)->vma) |
||
281 | #define bfd_get_section_lma(bfd, ptr) ((void) bfd, (ptr)->lma) |
||
282 | #define bfd_get_section_alignment(bfd, ptr) ((void) bfd, \ |
||
283 | (ptr)->alignment_power) |
||
284 | #define bfd_section_name(bfd, ptr) ((ptr)->name) |
||
285 | #define bfd_section_size(bfd, ptr) ((ptr)->size) |
||
286 | #define bfd_get_section_size(ptr) ((ptr)->size) |
||
287 | #define bfd_section_vma(bfd, ptr) ((ptr)->vma) |
||
288 | #define bfd_section_lma(bfd, ptr) ((ptr)->lma) |
||
289 | #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power) |
||
290 | #define bfd_get_section_flags(bfd, ptr) ((void) bfd, (ptr)->flags) |
||
291 | #define bfd_get_section_userdata(bfd, ptr) ((void) bfd, (ptr)->userdata) |
||
292 | |||
293 | #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0) |
||
294 | |||
295 | #define bfd_get_section_limit_octets(bfd, sec) \ |
||
296 | ((bfd)->direction != write_direction && (sec)->rawsize != 0 \ |
||
297 | ? (sec)->rawsize : (sec)->size) |
||
298 | |||
299 | /* Find the address one past the end of SEC. */ |
||
300 | #define bfd_get_section_limit(bfd, sec) \ |
||
301 | (bfd_get_section_limit_octets(bfd, sec) / bfd_octets_per_byte (bfd)) |
||
302 | |||
303 | /* Return TRUE if input section SEC has been discarded. */ |
||
304 | #define discarded_section(sec) \ |
||
305 | (!bfd_is_abs_section (sec) \ |
||
306 | && bfd_is_abs_section ((sec)->output_section) \ |
||
307 | && (sec)->sec_info_type != SEC_INFO_TYPE_MERGE \ |
||
308 | && (sec)->sec_info_type != SEC_INFO_TYPE_JUST_SYMS) |
||
309 | |||
310 | typedef enum bfd_print_symbol |
||
311 | { |
||
312 | bfd_print_symbol_name, |
||
313 | bfd_print_symbol_more, |
||
314 | bfd_print_symbol_all |
||
315 | } bfd_print_symbol_type; |
||
316 | |||
317 | /* Information about a symbol that nm needs. */ |
||
318 | |||
319 | typedef struct _symbol_info |
||
320 | { |
||
321 | symvalue value; |
||
322 | char type; |
||
323 | const char *name; /* Symbol name. */ |
||
324 | unsigned char stab_type; /* Stab type. */ |
||
325 | char stab_other; /* Stab other. */ |
||
326 | short stab_desc; /* Stab desc. */ |
||
327 | const char *stab_name; /* String for stab type. */ |
||
328 | } symbol_info; |
||
329 | |||
330 | /* Get the name of a stabs type code. */ |
||
331 | |||
332 | extern const char *bfd_get_stab_name (int); |
||
333 | |||
334 | /* Hash table routines. There is no way to free up a hash table. */ |
||
335 | |||
336 | /* An element in the hash table. Most uses will actually use a larger |
||
337 | structure, and an instance of this will be the first field. */ |
||
338 | |||
339 | struct bfd_hash_entry |
||
340 | { |
||
341 | /* Next entry for this hash code. */ |
||
342 | struct bfd_hash_entry *next; |
||
343 | /* String being hashed. */ |
||
344 | const char *string; |
||
345 | /* Hash code. This is the full hash code, not the index into the |
||
346 | table. */ |
||
347 | unsigned long hash; |
||
348 | }; |
||
349 | |||
350 | /* A hash table. */ |
||
351 | |||
352 | struct bfd_hash_table |
||
353 | { |
||
354 | /* The hash array. */ |
||
355 | struct bfd_hash_entry **table; |
||
356 | /* A function used to create new elements in the hash table. The |
||
357 | first entry is itself a pointer to an element. When this |
||
358 | function is first invoked, this pointer will be NULL. However, |
||
359 | having the pointer permits a hierarchy of method functions to be |
||
360 | built each of which calls the function in the superclass. Thus |
||
361 | each function should be written to allocate a new block of memory |
||
362 | only if the argument is NULL. */ |
||
363 | struct bfd_hash_entry *(*newfunc) |
||
364 | (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); |
||
365 | /* An objalloc for this hash table. This is a struct objalloc *, |
||
366 | but we use void * to avoid requiring the inclusion of objalloc.h. */ |
||
367 | void *memory; |
||
368 | /* The number of slots in the hash table. */ |
||
369 | unsigned int size; |
||
370 | /* The number of entries in the hash table. */ |
||
371 | unsigned int count; |
||
372 | /* The size of elements. */ |
||
373 | unsigned int entsize; |
||
374 | /* If non-zero, don't grow the hash table. */ |
||
375 | unsigned int frozen:1; |
||
376 | }; |
||
377 | |||
378 | /* Initialize a hash table. */ |
||
379 | extern bfd_boolean bfd_hash_table_init |
||
380 | (struct bfd_hash_table *, |
||
381 | struct bfd_hash_entry *(*) (struct bfd_hash_entry *, |
||
382 | struct bfd_hash_table *, |
||
383 | const char *), |
||
384 | unsigned int); |
||
385 | |||
386 | /* Initialize a hash table specifying a size. */ |
||
387 | extern bfd_boolean bfd_hash_table_init_n |
||
388 | (struct bfd_hash_table *, |
||
389 | struct bfd_hash_entry *(*) (struct bfd_hash_entry *, |
||
390 | struct bfd_hash_table *, |
||
391 | const char *), |
||
392 | unsigned int, unsigned int); |
||
393 | |||
394 | /* Free up a hash table. */ |
||
395 | extern void bfd_hash_table_free |
||
396 | (struct bfd_hash_table *); |
||
397 | |||
398 | /* Look up a string in a hash table. If CREATE is TRUE, a new entry |
||
399 | will be created for this string if one does not already exist. The |
||
400 | COPY argument must be TRUE if this routine should copy the string |
||
401 | into newly allocated memory when adding an entry. */ |
||
402 | extern struct bfd_hash_entry *bfd_hash_lookup |
||
403 | (struct bfd_hash_table *, const char *, bfd_boolean create, |
||
404 | bfd_boolean copy); |
||
405 | |||
406 | /* Insert an entry in a hash table. */ |
||
407 | extern struct bfd_hash_entry *bfd_hash_insert |
||
408 | (struct bfd_hash_table *, const char *, unsigned long); |
||
409 | |||
410 | /* Rename an entry in a hash table. */ |
||
411 | extern void bfd_hash_rename |
||
412 | (struct bfd_hash_table *, const char *, struct bfd_hash_entry *); |
||
413 | |||
414 | /* Replace an entry in a hash table. */ |
||
415 | extern void bfd_hash_replace |
||
416 | (struct bfd_hash_table *, struct bfd_hash_entry *old, |
||
417 | struct bfd_hash_entry *nw); |
||
418 | |||
419 | /* Base method for creating a hash table entry. */ |
||
420 | extern struct bfd_hash_entry *bfd_hash_newfunc |
||
421 | (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); |
||
422 | |||
423 | /* Grab some space for a hash table entry. */ |
||
424 | extern void *bfd_hash_allocate |
||
425 | (struct bfd_hash_table *, unsigned int); |
||
426 | |||
427 | /* Traverse a hash table in a random order, calling a function on each |
||
428 | element. If the function returns FALSE, the traversal stops. The |
||
429 | INFO argument is passed to the function. */ |
||
430 | extern void bfd_hash_traverse |
||
431 | (struct bfd_hash_table *, |
||
432 | bfd_boolean (*) (struct bfd_hash_entry *, void *), |
||
433 | void *info); |
||
434 | |||
435 | /* Allows the default size of a hash table to be configured. New hash |
||
436 | tables allocated using bfd_hash_table_init will be created with |
||
437 | this size. */ |
||
438 | extern unsigned long bfd_hash_set_default_size (unsigned long); |
||
439 | |||
440 | /* Types of compressed DWARF debug sections. We currently support |
||
441 | zlib. */ |
||
442 | enum compressed_debug_section_type |
||
443 | { |
||
444 | COMPRESS_DEBUG_NONE = 0, |
||
445 | COMPRESS_DEBUG = 1 << 0, |
||
446 | COMPRESS_DEBUG_GNU_ZLIB = COMPRESS_DEBUG | 1 << 1, |
||
447 | COMPRESS_DEBUG_GABI_ZLIB = COMPRESS_DEBUG | 1 << 2 |
||
448 | }; |
||
449 | |||
450 | /* This structure is used to keep track of stabs in sections |
||
451 | information while linking. */ |
||
452 | |||
453 | struct stab_info |
||
454 | { |
||
455 | /* A hash table used to hold stabs strings. */ |
||
456 | struct bfd_strtab_hash *strings; |
||
457 | /* The header file hash table. */ |
||
458 | struct bfd_hash_table includes; |
||
459 | /* The first .stabstr section. */ |
||
460 | struct bfd_section *stabstr; |
||
461 | }; |
||
462 | |||
463 | #define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table |
||
464 | |||
465 | /* User program access to BFD facilities. */ |
||
466 | |||
467 | /* Direct I/O routines, for programs which know more about the object |
||
468 | file than BFD does. Use higher level routines if possible. */ |
||
469 | |||
470 | extern bfd_size_type bfd_bread (void *, bfd_size_type, bfd *); |
||
471 | extern bfd_size_type bfd_bwrite (const void *, bfd_size_type, bfd *); |
||
472 | extern int bfd_seek (bfd *, file_ptr, int); |
||
473 | extern file_ptr bfd_tell (bfd *); |
||
474 | extern int bfd_flush (bfd *); |
||
475 | extern int bfd_stat (bfd *, struct stat *); |
||
476 | |||
477 | /* Deprecated old routines. */ |
||
478 | #if __GNUC__ |
||
479 | #define bfd_read(BUF, ELTSIZE, NITEMS, ABFD) \ |
||
480 | (warn_deprecated ("bfd_read", __FILE__, __LINE__, __FUNCTION__), \ |
||
481 | bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) |
||
482 | #define bfd_write(BUF, ELTSIZE, NITEMS, ABFD) \ |
||
483 | (warn_deprecated ("bfd_write", __FILE__, __LINE__, __FUNCTION__), \ |
||
484 | bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) |
||
485 | #else |
||
486 | #define bfd_read(BUF, ELTSIZE, NITEMS, ABFD) \ |
||
487 | (warn_deprecated ("bfd_read", (const char *) 0, 0, (const char *) 0), \ |
||
488 | bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) |
||
489 | #define bfd_write(BUF, ELTSIZE, NITEMS, ABFD) \ |
||
490 | (warn_deprecated ("bfd_write", (const char *) 0, 0, (const char *) 0),\ |
||
491 | bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD))) |
||
492 | #endif |
||
493 | extern void warn_deprecated (const char *, const char *, int, const char *); |
||
494 | |||
495 | /* Cast from const char * to char * so that caller can assign to |
||
496 | a char * without a warning. */ |
||
497 | #define bfd_get_filename(abfd) ((char *) (abfd)->filename) |
||
498 | #define bfd_get_cacheable(abfd) ((abfd)->cacheable) |
||
499 | #define bfd_get_format(abfd) ((abfd)->format) |
||
500 | #define bfd_get_target(abfd) ((abfd)->xvec->name) |
||
501 | #define bfd_get_flavour(abfd) ((abfd)->xvec->flavour) |
||
502 | #define bfd_family_coff(abfd) \ |
||
503 | (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \ |
||
504 | bfd_get_flavour (abfd) == bfd_target_xcoff_flavour) |
||
505 | #define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG) |
||
506 | #define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE) |
||
507 | #define bfd_header_big_endian(abfd) \ |
||
508 | ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG) |
||
509 | #define bfd_header_little_endian(abfd) \ |
||
510 | ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE) |
||
511 | #define bfd_get_file_flags(abfd) ((abfd)->flags) |
||
512 | #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags) |
||
513 | #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags) |
||
514 | #define bfd_my_archive(abfd) ((abfd)->my_archive) |
||
515 | #define bfd_has_map(abfd) ((abfd)->has_armap) |
||
516 | #define bfd_is_thin_archive(abfd) ((abfd)->is_thin_archive) |
||
517 | |||
518 | #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types) |
||
519 | #define bfd_usrdata(abfd) ((abfd)->usrdata) |
||
520 | |||
521 | #define bfd_get_start_address(abfd) ((abfd)->start_address) |
||
522 | #define bfd_get_symcount(abfd) ((abfd)->symcount) |
||
523 | #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols) |
||
524 | #define bfd_count_sections(abfd) ((abfd)->section_count) |
||
525 | |||
526 | #define bfd_get_dynamic_symcount(abfd) ((abfd)->dynsymcount) |
||
527 | |||
528 | #define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char) |
||
529 | |||
530 | extern bfd_boolean bfd_cache_close |
||
531 | (bfd *abfd); |
||
532 | /* NB: This declaration should match the autogenerated one in libbfd.h. */ |
||
533 | |||
534 | extern bfd_boolean bfd_cache_close_all (void); |
||
535 | |||
536 | extern bfd_boolean bfd_record_phdr |
||
537 | (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma, |
||
538 | bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **); |
||
539 | |||
540 | /* Byte swapping routines. */ |
||
541 | |||
542 | bfd_uint64_t bfd_getb64 (const void *); |
||
543 | bfd_uint64_t bfd_getl64 (const void *); |
||
544 | bfd_int64_t bfd_getb_signed_64 (const void *); |
||
545 | bfd_int64_t bfd_getl_signed_64 (const void *); |
||
546 | bfd_vma bfd_getb32 (const void *); |
||
547 | bfd_vma bfd_getl32 (const void *); |
||
548 | bfd_signed_vma bfd_getb_signed_32 (const void *); |
||
549 | bfd_signed_vma bfd_getl_signed_32 (const void *); |
||
550 | bfd_vma bfd_getb16 (const void *); |
||
551 | bfd_vma bfd_getl16 (const void *); |
||
552 | bfd_signed_vma bfd_getb_signed_16 (const void *); |
||
553 | bfd_signed_vma bfd_getl_signed_16 (const void *); |
||
554 | void bfd_putb64 (bfd_uint64_t, void *); |
||
555 | void bfd_putl64 (bfd_uint64_t, void *); |
||
556 | void bfd_putb32 (bfd_vma, void *); |
||
557 | void bfd_putl32 (bfd_vma, void *); |
||
558 | void bfd_putb16 (bfd_vma, void *); |
||
559 | void bfd_putl16 (bfd_vma, void *); |
||
560 | |||
561 | /* Byte swapping routines which take size and endiannes as arguments. */ |
||
562 | |||
563 | bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean); |
||
564 | void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean); |
||
565 | |||
566 | #if defined(__STDC__) || defined(ALMOST_STDC) |
||
567 | struct ecoff_debug_info; |
||
568 | struct ecoff_debug_swap; |
||
569 | struct ecoff_extr; |
||
570 | struct bfd_symbol; |
||
571 | struct bfd_link_info; |
||
572 | struct bfd_link_hash_entry; |
||
573 | struct bfd_section_already_linked; |
||
574 | struct bfd_elf_version_tree; |
||
575 | #endif |
||
576 | |||
577 | extern bfd_boolean bfd_section_already_linked_table_init (void); |
||
578 | extern void bfd_section_already_linked_table_free (void); |
||
579 | extern bfd_boolean _bfd_handle_already_linked |
||
580 | (struct bfd_section *, struct bfd_section_already_linked *, |
||
581 | struct bfd_link_info *); |
||
582 | |||
583 | /* Externally visible ECOFF routines. */ |
||
584 | |||
585 | extern bfd_vma bfd_ecoff_get_gp_value |
||
586 | (bfd * abfd); |
||
587 | extern bfd_boolean bfd_ecoff_set_gp_value |
||
588 | (bfd *abfd, bfd_vma gp_value); |
||
589 | extern bfd_boolean bfd_ecoff_set_regmasks |
||
590 | (bfd *abfd, unsigned long gprmask, unsigned long fprmask, |
||
591 | unsigned long *cprmask); |
||
592 | extern void *bfd_ecoff_debug_init |
||
593 | (bfd *output_bfd, struct ecoff_debug_info *output_debug, |
||
594 | const struct ecoff_debug_swap *output_swap, struct bfd_link_info *); |
||
595 | extern void bfd_ecoff_debug_free |
||
596 | (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, |
||
597 | const struct ecoff_debug_swap *output_swap, struct bfd_link_info *); |
||
598 | extern bfd_boolean bfd_ecoff_debug_accumulate |
||
599 | (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, |
||
600 | const struct ecoff_debug_swap *output_swap, bfd *input_bfd, |
||
601 | struct ecoff_debug_info *input_debug, |
||
602 | const struct ecoff_debug_swap *input_swap, struct bfd_link_info *); |
||
603 | extern bfd_boolean bfd_ecoff_debug_accumulate_other |
||
604 | (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, |
||
605 | const struct ecoff_debug_swap *output_swap, bfd *input_bfd, |
||
606 | struct bfd_link_info *); |
||
607 | extern bfd_boolean bfd_ecoff_debug_externals |
||
608 | (bfd *abfd, struct ecoff_debug_info *debug, |
||
609 | const struct ecoff_debug_swap *swap, bfd_boolean relocatable, |
||
610 | bfd_boolean (*get_extr) (struct bfd_symbol *, struct ecoff_extr *), |
||
611 | void (*set_index) (struct bfd_symbol *, bfd_size_type)); |
||
612 | extern bfd_boolean bfd_ecoff_debug_one_external |
||
613 | (bfd *abfd, struct ecoff_debug_info *debug, |
||
614 | const struct ecoff_debug_swap *swap, const char *name, |
||
615 | struct ecoff_extr *esym); |
||
616 | extern bfd_size_type bfd_ecoff_debug_size |
||
617 | (bfd *abfd, struct ecoff_debug_info *debug, |
||
618 | const struct ecoff_debug_swap *swap); |
||
619 | extern bfd_boolean bfd_ecoff_write_debug |
||
620 | (bfd *abfd, struct ecoff_debug_info *debug, |
||
621 | const struct ecoff_debug_swap *swap, file_ptr where); |
||
622 | extern bfd_boolean bfd_ecoff_write_accumulated_debug |
||
623 | (void *handle, bfd *abfd, struct ecoff_debug_info *debug, |
||
624 | const struct ecoff_debug_swap *swap, |
||
625 | struct bfd_link_info *info, file_ptr where); |
||
626 | |||
627 | /* Externally visible ELF routines. */ |
||
628 | |||
629 | struct bfd_link_needed_list |
||
630 | { |
||
631 | struct bfd_link_needed_list *next; |
||
632 | bfd *by; |
||
633 | const char *name; |
||
634 | }; |
||
635 | |||
636 | enum dynamic_lib_link_class { |
||
637 | DYN_NORMAL = 0, |
||
638 | DYN_AS_NEEDED = 1, |
||
639 | DYN_DT_NEEDED = 2, |
||
640 | DYN_NO_ADD_NEEDED = 4, |
||
641 | DYN_NO_NEEDED = 8 |
||
642 | }; |
||
643 | |||
644 | enum notice_asneeded_action { |
||
645 | notice_as_needed, |
||
646 | notice_not_needed, |
||
647 | notice_needed |
||
648 | }; |
||
649 | |||
650 | extern bfd_boolean bfd_elf_record_link_assignment |
||
651 | (bfd *, struct bfd_link_info *, const char *, bfd_boolean, |
||
652 | bfd_boolean); |
||
653 | extern struct bfd_link_needed_list *bfd_elf_get_needed_list |
||
654 | (bfd *, struct bfd_link_info *); |
||
655 | extern bfd_boolean bfd_elf_get_bfd_needed_list |
||
656 | (bfd *, struct bfd_link_needed_list **); |
||
657 | extern bfd_boolean bfd_elf_stack_segment_size (bfd *, struct bfd_link_info *, |
||
658 | const char *, bfd_vma); |
||
659 | extern bfd_boolean bfd_elf_size_dynamic_sections |
||
660 | (bfd *, const char *, const char *, const char *, const char *, const char *, |
||
661 | const char * const *, struct bfd_link_info *, struct bfd_section **); |
||
662 | extern bfd_boolean bfd_elf_size_dynsym_hash_dynstr |
||
663 | (bfd *, struct bfd_link_info *); |
||
664 | extern void bfd_elf_set_dt_needed_name |
||
665 | (bfd *, const char *); |
||
666 | extern const char *bfd_elf_get_dt_soname |
||
667 | (bfd *); |
||
668 | extern void bfd_elf_set_dyn_lib_class |
||
669 | (bfd *, enum dynamic_lib_link_class); |
||
670 | extern int bfd_elf_get_dyn_lib_class |
||
671 | (bfd *); |
||
672 | extern struct bfd_link_needed_list *bfd_elf_get_runpath_list |
||
673 | (bfd *, struct bfd_link_info *); |
||
674 | extern int bfd_elf_discard_info |
||
675 | (bfd *, struct bfd_link_info *); |
||
676 | extern unsigned int _bfd_elf_default_action_discarded |
||
677 | (struct bfd_section *); |
||
678 | |||
679 | /* Return an upper bound on the number of bytes required to store a |
||
680 | copy of ABFD's program header table entries. Return -1 if an error |
||
681 | occurs; bfd_get_error will return an appropriate code. */ |
||
682 | extern long bfd_get_elf_phdr_upper_bound |
||
683 | (bfd *abfd); |
||
684 | |||
685 | /* Copy ABFD's program header table entries to *PHDRS. The entries |
||
686 | will be stored as an array of Elf_Internal_Phdr structures, as |
||
687 | defined in include/elf/internal.h. To find out how large the |
||
688 | buffer needs to be, call bfd_get_elf_phdr_upper_bound. |
||
689 | |||
690 | Return the number of program header table entries read, or -1 if an |
||
691 | error occurs; bfd_get_error will return an appropriate code. */ |
||
692 | extern int bfd_get_elf_phdrs |
||
693 | (bfd *abfd, void *phdrs); |
||
694 | |||
695 | /* Create a new BFD as if by bfd_openr. Rather than opening a file, |
||
696 | reconstruct an ELF file by reading the segments out of remote |
||
697 | memory based on the ELF file header at EHDR_VMA and the ELF program |
||
698 | headers it points to. If non-zero, SIZE is the known extent of the |
||
699 | object. If not null, *LOADBASEP is filled in with the difference |
||
700 | between the VMAs from which the segments were read, and the VMAs |
||
701 | the file headers (and hence BFD's idea of each section's VMA) put |
||
702 | them at. |
||
703 | |||
704 | The function TARGET_READ_MEMORY is called to copy LEN bytes from |
||
705 | the remote memory at target address VMA into the local buffer at |
||
706 | MYADDR; it should return zero on success or an `errno' code on |
||
707 | failure. TEMPL must be a BFD for a target with the word size and |
||
708 | byte order found in the remote memory. */ |
||
709 | extern bfd *bfd_elf_bfd_from_remote_memory |
||
710 | (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep, |
||
711 | int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, |
||
712 | bfd_size_type len)); |
||
713 | |||
714 | extern struct bfd_section *_bfd_elf_tls_setup |
||
715 | (bfd *, struct bfd_link_info *); |
||
716 | |||
717 | extern struct bfd_section * |
||
718 | _bfd_nearby_section (bfd *, struct bfd_section *, bfd_vma); |
||
719 | |||
720 | extern void _bfd_fix_excluded_sec_syms |
||
721 | (bfd *, struct bfd_link_info *); |
||
722 | |||
723 | extern unsigned bfd_m68k_mach_to_features (int); |
||
724 | |||
725 | extern int bfd_m68k_features_to_mach (unsigned); |
||
726 | |||
727 | extern bfd_boolean bfd_m68k_elf32_create_embedded_relocs |
||
728 | (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, |
||
729 | char **); |
||
730 | |||
731 | extern void bfd_elf_m68k_set_target_options (struct bfd_link_info *, int); |
||
732 | |||
733 | extern bfd_boolean bfd_bfin_elf32_create_embedded_relocs |
||
734 | (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, |
||
735 | char **); |
||
736 | |||
737 | extern bfd_boolean bfd_cr16_elf32_create_embedded_relocs |
||
738 | (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, |
||
739 | char **); |
||
740 | |||
741 | /* SunOS shared library support routines for the linker. */ |
||
742 | |||
743 | extern struct bfd_link_needed_list *bfd_sunos_get_needed_list |
||
744 | (bfd *, struct bfd_link_info *); |
||
745 | extern bfd_boolean bfd_sunos_record_link_assignment |
||
746 | (bfd *, struct bfd_link_info *, const char *); |
||
747 | extern bfd_boolean bfd_sunos_size_dynamic_sections |
||
748 | (bfd *, struct bfd_link_info *, struct bfd_section **, |
||
749 | struct bfd_section **, struct bfd_section **); |
||
750 | |||
751 | /* Linux shared library support routines for the linker. */ |
||
752 | |||
753 | extern bfd_boolean bfd_i386linux_size_dynamic_sections |
||
754 | (bfd *, struct bfd_link_info *); |
||
755 | extern bfd_boolean bfd_m68klinux_size_dynamic_sections |
||
756 | (bfd *, struct bfd_link_info *); |
||
757 | extern bfd_boolean bfd_sparclinux_size_dynamic_sections |
||
758 | (bfd *, struct bfd_link_info *); |
||
759 | |||
760 | /* mmap hacks */ |
||
761 | |||
762 | struct _bfd_window_internal; |
||
763 | typedef struct _bfd_window_internal bfd_window_internal; |
||
764 | |||
765 | typedef struct _bfd_window |
||
766 | { |
||
767 | /* What the user asked for. */ |
||
768 | void *data; |
||
769 | bfd_size_type size; |
||
770 | /* The actual window used by BFD. Small user-requested read-only |
||
771 | regions sharing a page may share a single window into the object |
||
772 | file. Read-write versions shouldn't until I've fixed things to |
||
773 | keep track of which portions have been claimed by the |
||
774 | application; don't want to give the same region back when the |
||
775 | application wants two writable copies! */ |
||
776 | struct _bfd_window_internal *i; |
||
777 | } |
||
778 | bfd_window; |
||
779 | |||
780 | extern void bfd_init_window |
||
781 | (bfd_window *); |
||
782 | extern void bfd_free_window |
||
783 | (bfd_window *); |
||
784 | extern bfd_boolean bfd_get_file_window |
||
785 | (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean); |
||
786 | |||
787 | /* XCOFF support routines for the linker. */ |
||
788 | |||
789 | extern bfd_boolean bfd_xcoff_split_import_path |
||
790 | (bfd *, const char *, const char **, const char **); |
||
791 | extern bfd_boolean bfd_xcoff_set_archive_import_path |
||
792 | (struct bfd_link_info *, bfd *, const char *); |
||
793 | extern bfd_boolean bfd_xcoff_link_record_set |
||
794 | (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_size_type); |
||
795 | extern bfd_boolean bfd_xcoff_import_symbol |
||
796 | (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_vma, |
||
797 | const char *, const char *, const char *, unsigned int); |
||
798 | extern bfd_boolean bfd_xcoff_export_symbol |
||
799 | (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *); |
||
800 | extern bfd_boolean bfd_xcoff_link_count_reloc |
||
801 | (bfd *, struct bfd_link_info *, const char *); |
||
802 | extern bfd_boolean bfd_xcoff_record_link_assignment |
||
803 | (bfd *, struct bfd_link_info *, const char *); |
||
804 | extern bfd_boolean bfd_xcoff_size_dynamic_sections |
||
805 | (bfd *, struct bfd_link_info *, const char *, const char *, |
||
806 | unsigned long, unsigned long, unsigned long, bfd_boolean, |
||
807 | int, bfd_boolean, unsigned int, struct bfd_section **, bfd_boolean); |
||
808 | extern bfd_boolean bfd_xcoff_link_generate_rtinit |
||
809 | (bfd *, const char *, const char *, bfd_boolean); |
||
810 | |||
811 | /* XCOFF support routines for ar. */ |
||
812 | extern bfd_boolean bfd_xcoff_ar_archive_set_magic |
||
813 | (bfd *, char *); |
||
814 | |||
815 | /* Externally visible COFF routines. */ |
||
816 | |||
817 | #if defined(__STDC__) || defined(ALMOST_STDC) |
||
818 | struct internal_syment; |
||
819 | union internal_auxent; |
||
820 | #endif |
||
821 | |||
822 | extern bfd_boolean bfd_coff_set_symbol_class |
||
823 | (bfd *, struct bfd_symbol *, unsigned int); |
||
824 | |||
825 | extern bfd_boolean bfd_m68k_coff_create_embedded_relocs |
||
826 | (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, char **); |
||
827 | |||
828 | /* ARM VFP11 erratum workaround support. */ |
||
829 | typedef enum |
||
830 | { |
||
831 | BFD_ARM_VFP11_FIX_DEFAULT, |
||
832 | BFD_ARM_VFP11_FIX_NONE, |
||
833 | BFD_ARM_VFP11_FIX_SCALAR, |
||
834 | BFD_ARM_VFP11_FIX_VECTOR |
||
835 | } bfd_arm_vfp11_fix; |
||
836 | |||
837 | extern void bfd_elf32_arm_init_maps |
||
838 | (bfd *); |
||
839 | |||
840 | extern void bfd_elf32_arm_set_vfp11_fix |
||
841 | (bfd *, struct bfd_link_info *); |
||
842 | |||
843 | extern void bfd_elf32_arm_set_cortex_a8_fix |
||
844 | (bfd *, struct bfd_link_info *); |
||
845 | |||
846 | extern bfd_boolean bfd_elf32_arm_vfp11_erratum_scan |
||
847 | (bfd *, struct bfd_link_info *); |
||
848 | |||
849 | extern void bfd_elf32_arm_vfp11_fix_veneer_locations |
||
850 | (bfd *, struct bfd_link_info *); |
||
851 | |||
852 | /* ARM STM STM32L4XX erratum workaround support. */ |
||
853 | typedef enum |
||
854 | { |
||
855 | BFD_ARM_STM32L4XX_FIX_NONE, |
||
856 | BFD_ARM_STM32L4XX_FIX_DEFAULT, |
||
857 | BFD_ARM_STM32L4XX_FIX_ALL |
||
858 | } bfd_arm_stm32l4xx_fix; |
||
859 | |||
860 | extern void bfd_elf32_arm_set_stm32l4xx_fix |
||
861 | (bfd *, struct bfd_link_info *); |
||
862 | |||
863 | extern bfd_boolean bfd_elf32_arm_stm32l4xx_erratum_scan |
||
864 | (bfd *, struct bfd_link_info *); |
||
865 | |||
866 | extern void bfd_elf32_arm_stm32l4xx_fix_veneer_locations |
||
867 | (bfd *, struct bfd_link_info *); |
||
868 | |||
869 | /* ARM Interworking support. Called from linker. */ |
||
870 | extern bfd_boolean bfd_arm_allocate_interworking_sections |
||
871 | (struct bfd_link_info *); |
||
872 | |||
873 | extern bfd_boolean bfd_arm_process_before_allocation |
||
874 | (bfd *, struct bfd_link_info *, int); |
||
875 | |||
876 | extern bfd_boolean bfd_arm_get_bfd_for_interworking |
||
877 | (bfd *, struct bfd_link_info *); |
||
878 | |||
879 | /* PE ARM Interworking support. Called from linker. */ |
||
880 | extern bfd_boolean bfd_arm_pe_allocate_interworking_sections |
||
881 | (struct bfd_link_info *); |
||
882 | |||
883 | extern bfd_boolean bfd_arm_pe_process_before_allocation |
||
884 | (bfd *, struct bfd_link_info *, int); |
||
885 | |||
886 | extern bfd_boolean bfd_arm_pe_get_bfd_for_interworking |
||
887 | (bfd *, struct bfd_link_info *); |
||
888 | |||
889 | /* ELF ARM Interworking support. Called from linker. */ |
||
890 | extern bfd_boolean bfd_elf32_arm_allocate_interworking_sections |
||
891 | (struct bfd_link_info *); |
||
892 | |||
893 | extern bfd_boolean bfd_elf32_arm_process_before_allocation |
||
894 | (bfd *, struct bfd_link_info *); |
||
895 | |||
896 | void bfd_elf32_arm_set_target_relocs |
||
897 | (bfd *, struct bfd_link_info *, int, char *, int, int, bfd_arm_vfp11_fix, |
||
898 | bfd_arm_stm32l4xx_fix, int, int, int, int, int); |
||
899 | |||
900 | extern bfd_boolean bfd_elf32_arm_get_bfd_for_interworking |
||
901 | (bfd *, struct bfd_link_info *); |
||
902 | |||
903 | extern bfd_boolean bfd_elf32_arm_add_glue_sections_to_bfd |
||
904 | (bfd *, struct bfd_link_info *); |
||
905 | |||
906 | /* ELF ARM mapping symbol support. */ |
||
907 | #define BFD_ARM_SPECIAL_SYM_TYPE_MAP (1 << 0) |
||
908 | #define BFD_ARM_SPECIAL_SYM_TYPE_TAG (1 << 1) |
||
909 | #define BFD_ARM_SPECIAL_SYM_TYPE_OTHER (1 << 2) |
||
910 | #define BFD_ARM_SPECIAL_SYM_TYPE_ANY (~0) |
||
911 | |||
912 | extern bfd_boolean bfd_is_arm_special_symbol_name |
||
913 | (const char *, int); |
||
914 | |||
915 | extern void bfd_elf32_arm_set_byteswap_code |
||
916 | (struct bfd_link_info *, int); |
||
917 | |||
918 | extern void bfd_elf32_arm_use_long_plt (void); |
||
919 | |||
920 | /* ARM Note section processing. */ |
||
921 | extern bfd_boolean bfd_arm_merge_machines |
||
922 | (bfd *, bfd *); |
||
923 | |||
924 | extern bfd_boolean bfd_arm_update_notes |
||
925 | (bfd *, const char *); |
||
926 | |||
927 | extern unsigned int bfd_arm_get_mach_from_notes |
||
928 | (bfd *, const char *); |
||
929 | |||
930 | /* ARM stub generation support. Called from the linker. */ |
||
931 | extern int elf32_arm_setup_section_lists |
||
932 | (bfd *, struct bfd_link_info *); |
||
933 | extern void elf32_arm_next_input_section |
||
934 | (struct bfd_link_info *, struct bfd_section *); |
||
935 | extern bfd_boolean elf32_arm_size_stubs |
||
936 | (bfd *, bfd *, struct bfd_link_info *, bfd_signed_vma, |
||
937 | struct bfd_section * (*) (const char *, struct bfd_section *, unsigned int), |
||
938 | void (*) (void)); |
||
939 | extern bfd_boolean elf32_arm_build_stubs |
||
940 | (struct bfd_link_info *); |
||
941 | |||
942 | /* ARM unwind section editing support. */ |
||
943 | extern bfd_boolean elf32_arm_fix_exidx_coverage |
||
944 | (struct bfd_section **, unsigned int, struct bfd_link_info *, bfd_boolean); |
||
945 | |||
946 | /* C6x unwind section editing support. */ |
||
947 | extern bfd_boolean elf32_tic6x_fix_exidx_coverage |
||
948 | (struct bfd_section **, unsigned int, struct bfd_link_info *, bfd_boolean); |
||
949 | |||
950 | /* PowerPC @tls opcode transform/validate. */ |
||
951 | extern unsigned int _bfd_elf_ppc_at_tls_transform |
||
952 | (unsigned int, unsigned int); |
||
953 | /* PowerPC @tprel opcode transform/validate. */ |
||
954 | extern unsigned int _bfd_elf_ppc_at_tprel_transform |
||
955 | (unsigned int, unsigned int); |
||
956 | |||
957 | extern void bfd_elf64_aarch64_init_maps |
||
958 | (bfd *); |
||
959 | |||
960 | extern void bfd_elf32_aarch64_init_maps |
||
961 | (bfd *); |
||
962 | |||
963 | extern void bfd_elf64_aarch64_set_options |
||
964 | (bfd *, struct bfd_link_info *, int, int, int, int, int); |
||
965 | |||
966 | extern void bfd_elf32_aarch64_set_options |
||
967 | (bfd *, struct bfd_link_info *, int, int, int, int, int); |
||
968 | |||
969 | /* ELF AArch64 mapping symbol support. */ |
||
970 | #define BFD_AARCH64_SPECIAL_SYM_TYPE_MAP (1 << 0) |
||
971 | #define BFD_AARCH64_SPECIAL_SYM_TYPE_TAG (1 << 1) |
||
972 | #define BFD_AARCH64_SPECIAL_SYM_TYPE_OTHER (1 << 2) |
||
973 | #define BFD_AARCH64_SPECIAL_SYM_TYPE_ANY (~0) |
||
974 | extern bfd_boolean bfd_is_aarch64_special_symbol_name |
||
975 | (const char * name, int type); |
||
976 | |||
977 | /* AArch64 stub generation support for ELF64. Called from the linker. */ |
||
978 | extern int elf64_aarch64_setup_section_lists |
||
979 | (bfd *, struct bfd_link_info *); |
||
980 | extern void elf64_aarch64_next_input_section |
||
981 | (struct bfd_link_info *, struct bfd_section *); |
||
982 | extern bfd_boolean elf64_aarch64_size_stubs |
||
983 | (bfd *, bfd *, struct bfd_link_info *, bfd_signed_vma, |
||
984 | struct bfd_section * (*) (const char *, struct bfd_section *), |
||
985 | void (*) (void)); |
||
986 | extern bfd_boolean elf64_aarch64_build_stubs |
||
987 | (struct bfd_link_info *); |
||
988 | /* AArch64 stub generation support for ELF32. Called from the linker. */ |
||
989 | extern int elf32_aarch64_setup_section_lists |
||
990 | (bfd *, struct bfd_link_info *); |
||
991 | extern void elf32_aarch64_next_input_section |
||
992 | (struct bfd_link_info *, struct bfd_section *); |
||
993 | extern bfd_boolean elf32_aarch64_size_stubs |
||
994 | (bfd *, bfd *, struct bfd_link_info *, bfd_signed_vma, |
||
995 | struct bfd_section * (*) (const char *, struct bfd_section *), |
||
996 | void (*) (void)); |
||
997 | extern bfd_boolean elf32_aarch64_build_stubs |
||
998 | (struct bfd_link_info *); |
||
999 | |||
1000 | |||
1001 | /* TI COFF load page support. */ |
||
1002 | extern void bfd_ticoff_set_section_load_page |
||
1003 | (struct bfd_section *, int); |
||
1004 | |||
1005 | extern int bfd_ticoff_get_section_load_page |
||
1006 | (struct bfd_section *); |
||
1007 | |||
1008 | /* H8/300 functions. */ |
||
1009 | extern bfd_vma bfd_h8300_pad_address |
||
1010 | (bfd *, bfd_vma); |
||
1011 | |||
1012 | /* IA64 Itanium code generation. Called from linker. */ |
||
1013 | extern void bfd_elf32_ia64_after_parse |
||
1014 | (int); |
||
1015 | |||
1016 | extern void bfd_elf64_ia64_after_parse |
||
1017 | (int); |
||
1018 | |||
1019 | /* V850 Note manipulation routines. */ |
||
1020 | extern bfd_boolean v850_elf_create_sections |
||
1021 | (struct bfd_link_info *); |
||
1022 | |||
1023 | extern bfd_boolean v850_elf_set_note |
||
1024 | (bfd *, unsigned int, unsigned int);><>><>><>><>><>><>><>><>><>><>><>><> |