Commit | Line | Data |
---|---|---|
00539ee3 | 1 | /* Main header file for the bfd library -- portable access to object files. |
b6090f4d | 2 | Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc. |
63ffe5ef SC |
3 | Contributed by Cygnus Support. |
4 | ||
1fa5371e KR |
5 | ** NOTE: bfd.h and bfd-in2.h are GENERATED files. Don't change them; |
6 | ** instead, change bfd-in.h or the other BFD source files processed to | |
7 | ** generate these files. | |
8 | ||
63ffe5ef SC |
9 | This file is part of BFD, the Binary File Descriptor library. |
10 | ||
11 | This program is free software; you can redistribute it and/or modify | |
12 | it under the terms of the GNU General Public License as published by | |
13 | the Free Software Foundation; either version 2 of the License, or | |
14 | (at your option) any later version. | |
15 | ||
16 | This program is distributed in the hope that it will be useful, | |
17 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 | GNU General Public License for more details. | |
20 | ||
21 | You should have received a copy of the GNU General Public License | |
22 | along with this program; if not, write to the Free Software | |
23 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
24 | ||
25 | /* bfd.h -- The only header file required by users of the bfd library | |
26 | ||
00539ee3 JG |
27 | The bfd.h file is generated from bfd-in.h and various .c files; if you |
28 | change it, your changes will probably be lost. | |
63ffe5ef SC |
29 | |
30 | All the prototypes and definitions following the comment "THE FOLLOWING | |
31 | IS EXTRACTED FROM THE SOURCE" are extracted from the source files for | |
32 | BFD. If you change it, someone oneday will extract it from the source | |
33 | again, and your changes will be lost. To save yourself from this bind, | |
34 | change the definitions in the source in the bfd directory. Type "make | |
35 | docs" and then "make headers" in that directory, and magically this file | |
36 | will change to reflect your changes. | |
37 | ||
38 | If you don't have the tools to perform the extraction, then you are | |
39 | safe from someone on your system trampling over your header files. | |
40 | You should still maintain the equivalence between the source and this | |
41 | file though; every change you make to the .c file should be reflected | |
42 | here. */ | |
43 | ||
44 | #ifndef __BFD_H_SEEN__ | |
45 | #define __BFD_H_SEEN__ | |
46 | ||
47 | #include "ansidecl.h" | |
48 | #include "obstack.h" | |
49 | ||
034a8a56 KR |
50 | #define BFD_VERSION "2.2" |
51 | ||
52 | #define BFD_ARCH_SIZE @WORDSIZE@ | |
53 | ||
54 | #if BFD_ARCH_SIZE >= 64 | |
55 | #define BFD64 | |
56 | #endif | |
57 | ||
1fa5371e KR |
58 | #ifndef INLINE |
59 | #if __GNUC__ >= 2 | |
60 | #define INLINE __inline__ | |
61 | #else | |
62 | #define INLINE | |
63 | #endif | |
64 | #endif | |
65 | ||
58488bc6 KR |
66 | /* 64-bit type definition (if any) from bfd's sysdep.h goes here */ |
67 | ||
63ffe5ef SC |
68 | |
69 | /* forward declaration */ | |
70 | typedef struct _bfd bfd; | |
71 | ||
034a8a56 KR |
72 | /* To squelch erroneous compiler warnings ("illegal pointer |
73 | combination") from the SVR3 compiler, we would like to typedef | |
74 | boolean to int (it doesn't like functions which return boolean. | |
75 | Making sure they are never implicitly declared to return int | |
76 | doesn't seem to help). But this file is not configured based on | |
77 | the host. */ | |
63ffe5ef SC |
78 | /* General rules: functions which are boolean return true on success |
79 | and false on failure (unless they're a predicate). -- bfd.doc */ | |
80 | /* I'm sure this is going to break something and someone is going to | |
81 | force me to change it. */ | |
f004165e JG |
82 | /* typedef enum boolean {false, true} boolean; */ |
83 | /* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h> -fnf */ | |
84 | typedef enum bfd_boolean {false, true} boolean; | |
63ffe5ef | 85 | |
00539ee3 JG |
86 | /* A pointer to a position in a file. */ |
87 | /* FIXME: This should be using off_t from <sys/types.h>. | |
88 | For now, try to avoid breaking stuff by not including <sys/types.h> here. | |
89 | This will break on systems with 64-bit file offsets (e.g. 4.4BSD). | |
90 | Probably the best long-term answer is to avoid using file_ptr AND off_t | |
91 | in this header file, and to handle this in the BFD implementation | |
92 | rather than in its interface. */ | |
93 | /* typedef off_t file_ptr; */ | |
94 | typedef long int file_ptr; | |
63ffe5ef | 95 | |
034a8a56 KR |
96 | /* Support for different sizes of target format ints and addresses. If the |
97 | host implements 64-bit values, it defines HOST_64_BIT to be the appropriate | |
98 | type. Otherwise, this code will fall back on gcc's "long long" type if gcc | |
99 | is being used. HOST_64_BIT must be defined in such a way as to be a valid | |
100 | type name by itself or with "unsigned" prefixed. It should be a signed | |
101 | type by itself. | |
102 | ||
103 | If neither is the case, then compilation will fail if 64-bit targets are | |
104 | requested. If you don't request any 64-bit targets, you should be safe. */ | |
105 | ||
106 | #ifdef BFD64 | |
107 | ||
108 | #if defined (__GNUC__) && !defined (HOST_64_BIT) | |
109 | #define HOST_64_BIT long long | |
110 | typedef HOST_64_BIT int64_type; | |
111 | typedef unsigned HOST_64_BIT uint64_type; | |
112 | #endif | |
63ffe5ef | 113 | |
1fa5371e KR |
114 | #if !defined (uint64_type) && defined (__GNUC__) |
115 | #define uint64_type unsigned long long | |
116 | #define int64_type long long | |
4c3721d5 ILT |
117 | #define uint64_typeLOW(x) ((unsigned long)(((x) & 0xffffffff))) |
118 | #define uint64_typeHIGH(x) ((unsigned long)(((x) >> 32) & 0xffffffff)) | |
1fa5371e KR |
119 | #endif |
120 | ||
14e3c2e4 JK |
121 | typedef unsigned HOST_64_BIT bfd_vma; |
122 | typedef HOST_64_BIT bfd_signed_vma; | |
123 | typedef unsigned HOST_64_BIT bfd_size_type; | |
124 | typedef unsigned HOST_64_BIT symvalue; | |
63ffe5ef | 125 | #define fprintf_vma(s,x) \ |
4c3721d5 | 126 | fprintf(s,"%08lx%08lx", uint64_typeHIGH(x), uint64_typeLOW(x)) |
1fa5371e | 127 | #define sprintf_vma(s,x) \ |
4c3721d5 | 128 | sprintf(s,"%08lx%08lx", uint64_typeHIGH(x), uint64_typeLOW(x)) |
034a8a56 | 129 | #else /* not BFD64 */ |
14e3c2e4 JK |
130 | |
131 | /* Represent a target address. Also used as a generic unsigned type | |
132 | which is guaranteed to be big enough to hold any arithmetic types | |
133 | we need to deal with. */ | |
63ffe5ef | 134 | typedef unsigned long bfd_vma; |
14e3c2e4 JK |
135 | |
136 | /* A generic signed type which is guaranteed to be big enough to hold any | |
137 | arithmetic types we need to deal with. Can be assumed to be compatible | |
138 | with bfd_vma in the same way that signed and unsigned ints are compatible | |
139 | (as parameters, in assignment, etc). */ | |
140 | typedef long bfd_signed_vma; | |
141 | ||
63ffe5ef SC |
142 | typedef unsigned long symvalue; |
143 | typedef unsigned long bfd_size_type; | |
14e3c2e4 JK |
144 | |
145 | /* Print a bfd_vma x on stream s. */ | |
63ffe5ef | 146 | #define fprintf_vma(s,x) fprintf(s, "%08lx", x) |
1fa5371e | 147 | #define sprintf_vma(s,x) sprintf(s, "%08lx", x) |
034a8a56 | 148 | #endif /* not BFD64 */ |
e98e6ec1 | 149 | #define printf_vma(x) fprintf_vma(stdout,x) |
63ffe5ef SC |
150 | |
151 | typedef unsigned int flagword; /* 32 bits of flags */ | |
152 | \f | |
153 | /** File formats */ | |
154 | ||
155 | typedef enum bfd_format { | |
156 | bfd_unknown = 0, /* file format is unknown */ | |
157 | bfd_object, /* linker/assember/compiler output */ | |
158 | bfd_archive, /* object archive file */ | |
159 | bfd_core, /* core dump */ | |
160 | bfd_type_end} /* marks the end; don't use it! */ | |
161 | bfd_format; | |
162 | ||
8d12f138 ILT |
163 | /* Values that may appear in the flags field of a BFD. These also |
164 | appear in the object_flags field of the bfd_target structure, where | |
165 | they indicate the set of flags used by that backend (not all flags | |
166 | are meaningful for all object file formats) (FIXME: at the moment, | |
167 | the object_flags values have mostly just been copied from backend | |
168 | to another, and are not necessarily correct). */ | |
169 | ||
170 | /* No flags. */ | |
294eaca4 | 171 | #define NO_FLAGS 0x00 |
8d12f138 ILT |
172 | |
173 | /* BFD contains relocation entries. */ | |
294eaca4 | 174 | #define HAS_RELOC 0x01 |
8d12f138 ILT |
175 | |
176 | /* BFD is directly executable. */ | |
294eaca4 | 177 | #define EXEC_P 0x02 |
8d12f138 ILT |
178 | |
179 | /* BFD has line number information (basically used for F_LNNO in a | |
180 | COFF header). */ | |
294eaca4 | 181 | #define HAS_LINENO 0x04 |
8d12f138 ILT |
182 | |
183 | /* BFD has debugging information. */ | |
294eaca4 | 184 | #define HAS_DEBUG 0x08 |
8d12f138 ILT |
185 | |
186 | /* BFD has symbols. */ | |
294eaca4 | 187 | #define HAS_SYMS 0x10 |
8d12f138 ILT |
188 | |
189 | /* BFD has local symbols (basically used for F_LSYMS in a COFF | |
190 | header). */ | |
294eaca4 | 191 | #define HAS_LOCALS 0x20 |
8d12f138 ILT |
192 | |
193 | /* BFD is a dynamic object. */ | |
294eaca4 | 194 | #define DYNAMIC 0x40 |
8d12f138 ILT |
195 | |
196 | /* Text section is write protected (if D_PAGED is not set, this is | |
197 | like an a.out NMAGIC file) (the linker sets this by default, but | |
198 | clears it for -r or -N). */ | |
294eaca4 | 199 | #define WP_TEXT 0x80 |
8d12f138 ILT |
200 | |
201 | /* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the | |
202 | linker sets this by default, but clears it for -r or -n or -N). */ | |
294eaca4 | 203 | #define D_PAGED 0x100 |
8d12f138 ILT |
204 | |
205 | /* BFD is relaxable (this means that bfd_relax_section may be able to | |
206 | do something). */ | |
294eaca4 | 207 | #define BFD_IS_RELAXABLE 0x200 |
63ffe5ef SC |
208 | \f |
209 | /* symbols and relocation */ | |
210 | ||
211 | typedef unsigned long symindex; | |
212 | ||
213 | #define BFD_NO_MORE_SYMBOLS ((symindex) ~0) | |
214 | ||
215 | typedef enum bfd_symclass { | |
216 | bfd_symclass_unknown = 0, | |
217 | bfd_symclass_fcommon, /* fortran common symbols */ | |
218 | bfd_symclass_global, /* global symbol, what a surprise */ | |
219 | bfd_symclass_debugger, /* some debugger symbol */ | |
220 | bfd_symclass_undefined /* none known */ | |
221 | } symclass; | |
222 | ||
223 | ||
63ffe5ef SC |
224 | /* general purpose part of a symbol; |
225 | target specific parts will be found in libcoff.h, liba.out.h etc */ | |
226 | ||
227 | ||
228 | #define bfd_get_section(x) ((x)->section) | |
229 | #define bfd_get_output_section(x) ((x)->section->output_section) | |
230 | #define bfd_set_section(x,y) ((x)->section) = (y) | |
0c2fae09 | 231 | #define bfd_asymbol_base(x) ((x)->section->vma) |
ec30dfba | 232 | #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value) |
63ffe5ef | 233 | #define bfd_asymbol_name(x) ((x)->name) |
0c2fae09 ILT |
234 | /*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/ |
235 | #define bfd_asymbol_bfd(x) ((x)->the_bfd) | |
236 | #define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour) | |
63ffe5ef SC |
237 | |
238 | /* This is a type pun with struct ranlib on purpose! */ | |
239 | typedef struct carsym { | |
240 | char *name; | |
241 | file_ptr file_offset; /* look here to find the file */ | |
242 | } carsym; /* to make these you call a carsymogen */ | |
243 | ||
244 | ||
245 | /* Used in generating armaps. Perhaps just a forward definition would do? */ | |
246 | struct orl { /* output ranlib */ | |
247 | char **name; /* symbol name */ | |
248 | file_ptr pos; /* bfd* or file position */ | |
249 | int namidx; /* index into string table */ | |
250 | }; | |
251 | ||
252 | \f | |
253 | ||
254 | /* Linenumber stuff */ | |
255 | typedef struct lineno_cache_entry { | |
256 | unsigned int line_number; /* Linenumber from start of function*/ | |
257 | union { | |
258 | struct symbol_cache_entry *sym; /* Function name */ | |
259 | unsigned long offset; /* Offset into section */ | |
260 | } u; | |
261 | } alent; | |
262 | \f | |
263 | /* object and core file sections */ | |
264 | ||
265 | ||
266 | #define align_power(addr, align) \ | |
267 | ( ((addr) + ((1<<(align))-1)) & (-1 << (align))) | |
268 | ||
269 | typedef struct sec *sec_ptr; | |
270 | ||
294eaca4 SC |
271 | #define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0) |
272 | #define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0) | |
273 | #define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0) | |
63ffe5ef | 274 | #define bfd_section_name(bfd, ptr) ((ptr)->name) |
e98e6ec1 | 275 | #define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr)) |
63ffe5ef SC |
276 | #define bfd_section_vma(bfd, ptr) ((ptr)->vma) |
277 | #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power) | |
294eaca4 | 278 | #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0) |
63ffe5ef SC |
279 | #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata) |
280 | ||
ec30dfba JG |
281 | #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0) |
282 | ||
b6090f4d | 283 | #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma= (val)), ((ptr)->user_set_vma = true), true) |
63ffe5ef SC |
284 | #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true) |
285 | #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true) | |
286 | ||
287 | typedef struct stat stat_type; | |
288 | \f | |
4c3721d5 | 289 | /* Error handling */ |
63ffe5ef | 290 | |
4c3721d5 ILT |
291 | typedef enum bfd_error |
292 | { | |
293 | no_error = 0, | |
294 | system_call_error, | |
295 | invalid_target, | |
296 | wrong_format, | |
297 | invalid_operation, | |
298 | no_memory, | |
299 | no_symbols, | |
300 | no_relocation_info, | |
301 | no_more_archived_files, | |
302 | malformed_archive, | |
303 | symbol_not_found, | |
304 | file_not_recognized, | |
305 | file_ambiguously_recognized, | |
306 | no_contents, | |
307 | bfd_error_nonrepresentable_section, | |
308 | no_debug_section, | |
309 | bad_value, | |
310 | file_truncated, | |
311 | invalid_error_code | |
312 | } bfd_ec; | |
e98e6ec1 | 313 | |
4c3721d5 | 314 | extern bfd_ec bfd_error; |
63ffe5ef | 315 | |
1093ee14 JG |
316 | CONST char *bfd_errmsg PARAMS ((bfd_ec error_tag)); |
317 | void bfd_perror PARAMS ((CONST char *message)); | |
63ffe5ef SC |
318 | \f |
319 | ||
320 | typedef enum bfd_print_symbol | |
321 | { | |
cbdc7909 JG |
322 | bfd_print_symbol_name, |
323 | bfd_print_symbol_more, | |
034a8a56 | 324 | bfd_print_symbol_all |
cbdc7909 | 325 | } bfd_print_symbol_type; |
63ffe5ef SC |
326 | |
327 | \f | |
034a8a56 KR |
328 | /* Information about a symbol that nm needs. */ |
329 | ||
330 | typedef struct _symbol_info | |
331 | { | |
332 | symvalue value; | |
333 | char type; /* */ | |
334 | CONST char *name; /* Symbol name. */ | |
335 | char stab_other; /* Unused. */ | |
336 | short stab_desc; /* Info for N_TYPE. */ | |
337 | CONST char *stab_name; | |
338 | } symbol_info; | |
63ffe5ef | 339 | \f |
4c3721d5 ILT |
340 | /* Hash table routines. There is no way to free up a hash table. */ |
341 | ||
342 | /* An element in the hash table. Most uses will actually use a larger | |
343 | structure, and an instance of this will be the first field. */ | |
344 | ||
345 | struct bfd_hash_entry | |
346 | { | |
347 | /* Next entry for this hash code. */ | |
348 | struct bfd_hash_entry *next; | |
349 | /* String being hashed. */ | |
350 | const char *string; | |
351 | /* Hash code. This is the full hash code, not the index into the | |
352 | table. */ | |
353 | unsigned long hash; | |
354 | }; | |
355 | ||
356 | /* A hash table. */ | |
357 | ||
358 | struct bfd_hash_table | |
359 | { | |
360 | /* The hash array. */ | |
361 | struct bfd_hash_entry **table; | |
362 | /* The number of slots in the hash table. */ | |
363 | unsigned int size; | |
364 | /* A function used to create new elements in the hash table. The | |
365 | first entry is itself a pointer to an element. When this | |
366 | function is first invoked, this pointer will be NULL. However, | |
367 | having the pointer permits a hierarchy of method functions to be | |
368 | built each of which calls the function in the superclass. Thus | |
369 | each function should be written to allocate a new block of memory | |
370 | only if the argument is NULL. */ | |
371 | struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *, | |
372 | struct bfd_hash_table *, | |
373 | const char *)); | |
374 | /* An obstack for this hash table. */ | |
375 | struct obstack memory; | |
376 | }; | |
377 | ||
378 | /* Initialize a hash table. */ | |
379 | extern boolean bfd_hash_table_init | |
380 | PARAMS ((struct bfd_hash_table *, | |
381 | struct bfd_hash_entry *(*) (struct bfd_hash_entry *, | |
382 | struct bfd_hash_table *, | |
383 | const char *))); | |
384 | ||
385 | /* Initialize a hash table specifying a size. */ | |
386 | extern boolean bfd_hash_table_init_n | |
387 | PARAMS ((struct bfd_hash_table *, | |
388 | struct bfd_hash_entry *(*) (struct bfd_hash_entry *, | |
389 | struct bfd_hash_table *, | |
390 | const char *), | |
391 | unsigned int size)); | |
392 | ||
393 | /* Free up a hash table. */ | |
394 | extern void bfd_hash_table_free PARAMS ((struct bfd_hash_table *)); | |
395 | ||
396 | /* Look up a string in a hash table. If CREATE is true, a new entry | |
397 | will be created for this string if one does not already exist. The | |
398 | COPY argument must be true if this routine should copy the string | |
399 | into newly allocated memory when adding an entry. */ | |
400 | extern struct bfd_hash_entry *bfd_hash_lookup | |
401 | PARAMS ((struct bfd_hash_table *, const char *, boolean create, | |
402 | boolean copy)); | |
403 | ||
404 | /* Base method for creating a hash table entry. */ | |
405 | extern struct bfd_hash_entry *bfd_hash_newfunc | |
406 | PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, | |
407 | const char *)); | |
408 | ||
409 | /* Grab some space for a hash table entry. */ | |
410 | extern PTR bfd_hash_allocate PARAMS ((struct bfd_hash_table *, size_t)); | |
411 | ||
412 | /* Traverse a hash table in a random order, calling a function on each | |
413 | element. If the function returns false, the traversal stops. The | |
414 | INFO argument is passed to the function. */ | |
415 | extern void bfd_hash_traverse PARAMS ((struct bfd_hash_table *, | |
416 | boolean (*) (struct bfd_hash_entry *, | |
417 | PTR), | |
418 | PTR info)); | |
419 | \f | |
63ffe5ef SC |
420 | /* The code that implements targets can initialize a jump table with this |
421 | macro. It must name all its routines the same way (a prefix plus | |
422 | the standard routine suffix), or it must #define the routines that | |
423 | are not so named, before calling JUMP_TABLE in the initializer. */ | |
424 | ||
1fa5371e KR |
425 | /* Semi-portable string concatenation in cpp. |
426 | The CAT4 hack is to avoid a problem with some strict ANSI C preprocessors. | |
427 | The problem is, "32_" is not a valid preprocessing token, and we don't | |
428 | want extra underscores (e.g., "nlm_32_"). The XCAT2 macro will cause the | |
429 | inner CAT macros to be evaluated first, producing still-valid pp-tokens. | |
430 | Then the final concatenation can be done. (Sigh.) */ | |
63ffe5ef | 431 | #ifndef CAT |
1fa5371e KR |
432 | #ifdef SABER |
433 | #define CAT(a,b) a##b | |
434 | #define CAT3(a,b,c) a##b##c | |
435 | #define CAT4(a,b,c,d) a##b##c##d | |
436 | #else | |
63ffe5ef SC |
437 | #ifdef __STDC__ |
438 | #define CAT(a,b) a##b | |
034a8a56 | 439 | #define CAT3(a,b,c) a##b##c |
1fa5371e KR |
440 | #define XCAT2(a,b) CAT(a,b) |
441 | #define CAT4(a,b,c,d) XCAT2(CAT(a,b),CAT(c,d)) | |
63ffe5ef SC |
442 | #else |
443 | #define CAT(a,b) a/**/b | |
034a8a56 | 444 | #define CAT3(a,b,c) a/**/b/**/c |
1fa5371e KR |
445 | #define CAT4(a,b,c,d) a/**/b/**/c/**/d |
446 | #endif | |
63ffe5ef SC |
447 | #endif |
448 | #endif | |
449 | ||
450 | #define JUMP_TABLE(NAME)\ | |
451 | CAT(NAME,_core_file_failing_command),\ | |
452 | CAT(NAME,_core_file_failing_signal),\ | |
453 | CAT(NAME,_core_file_matches_executable_p),\ | |
454 | CAT(NAME,_slurp_armap),\ | |
455 | CAT(NAME,_slurp_extended_name_table),\ | |
456 | CAT(NAME,_truncate_arname),\ | |
457 | CAT(NAME,_write_armap),\ | |
1fa5371e | 458 | CAT(NAME,_close_and_cleanup),\ |
63ffe5ef SC |
459 | CAT(NAME,_set_section_contents),\ |
460 | CAT(NAME,_get_section_contents),\ | |
461 | CAT(NAME,_new_section_hook),\ | |
462 | CAT(NAME,_get_symtab_upper_bound),\ | |
463 | CAT(NAME,_get_symtab),\ | |
464 | CAT(NAME,_get_reloc_upper_bound),\ | |
465 | CAT(NAME,_canonicalize_reloc),\ | |
466 | CAT(NAME,_make_empty_symbol),\ | |
467 | CAT(NAME,_print_symbol),\ | |
034a8a56 | 468 | CAT(NAME,_get_symbol_info),\ |
63ffe5ef SC |
469 | CAT(NAME,_get_lineno),\ |
470 | CAT(NAME,_set_arch_mach),\ | |
471 | CAT(NAME,_openr_next_archived_file),\ | |
472 | CAT(NAME,_find_nearest_line),\ | |
473 | CAT(NAME,_generic_stat_arch_elt),\ | |
474 | CAT(NAME,_sizeof_headers),\ | |
475 | CAT(NAME,_bfd_debug_info_start),\ | |
476 | CAT(NAME,_bfd_debug_info_end),\ | |
e98e6ec1 | 477 | CAT(NAME,_bfd_debug_info_accumulate),\ |
2cfd0562 | 478 | CAT(NAME,_bfd_get_relocated_section_contents),\ |
0c2fae09 | 479 | CAT(NAME,_bfd_relax_section),\ |
b6090f4d | 480 | CAT(NAME,_bfd_reloc_type_lookup),\ |
4c3721d5 ILT |
481 | CAT(NAME,_bfd_make_debug_symbol),\ |
482 | CAT(NAME,_bfd_link_hash_table_create),\ | |
483 | CAT(NAME,_bfd_link_add_symbols),\ | |
484 | CAT(NAME,_bfd_final_link) | |
cbdc7909 | 485 | |
0c2fae09 | 486 | #define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table |
cbdc7909 | 487 | |
63ffe5ef SC |
488 | \f |
489 | /* User program access to BFD facilities */ | |
490 | ||
63ffe5ef SC |
491 | /* Cast from const char * to char * so that caller can assign to |
492 | a char * without a warning. */ | |
493 | #define bfd_get_filename(abfd) ((char *) (abfd)->filename) | |
8d12f138 | 494 | #define bfd_get_cacheable(abfd) ((abfd)->cacheable) |
63ffe5ef SC |
495 | #define bfd_get_format(abfd) ((abfd)->format) |
496 | #define bfd_get_target(abfd) ((abfd)->xvec->name) | |
8d12f138 | 497 | #define bfd_get_flavour(abfd) ((abfd)->xvec->flavour) |
63ffe5ef SC |
498 | #define bfd_get_file_flags(abfd) ((abfd)->flags) |
499 | #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags) | |
500 | #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags) | |
e98e6ec1 | 501 | #define bfd_my_archive(abfd) ((abfd)->my_archive) |
63ffe5ef | 502 | #define bfd_has_map(abfd) ((abfd)->has_armap) |
63ffe5ef SC |
503 | |
504 | #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types) | |
505 | #define bfd_usrdata(abfd) ((abfd)->usrdata) | |
506 | ||
507 | #define bfd_get_start_address(abfd) ((abfd)->start_address) | |
508 | #define bfd_get_symcount(abfd) ((abfd)->symcount) | |
509 | #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols) | |
510 | #define bfd_count_sections(abfd) ((abfd)->section_count) | |
63ffe5ef | 511 | |
294eaca4 | 512 | #define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char) |
63ffe5ef | 513 | |
8d12f138 ILT |
514 | #define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (bool)), true) |
515 | ||
516 | /* Byte swapping routines. */ | |
517 | ||
1a973af1 ILT |
518 | bfd_vma bfd_getb64 PARAMS ((const unsigned char *)); |
519 | bfd_vma bfd_getl64 PARAMS ((const unsigned char *)); | |
520 | bfd_signed_vma bfd_getb_signed_64 PARAMS ((const unsigned char *)); | |
521 | bfd_signed_vma bfd_getl_signed_64 PARAMS ((const unsigned char *)); | |
522 | bfd_vma bfd_getb32 PARAMS ((const unsigned char *)); | |
523 | bfd_vma bfd_getl32 PARAMS ((const unsigned char *)); | |
524 | bfd_signed_vma bfd_getb_signed_32 PARAMS ((const unsigned char *)); | |
525 | bfd_signed_vma bfd_getl_signed_32 PARAMS ((const unsigned char *)); | |
526 | bfd_vma bfd_getb16 PARAMS ((const unsigned char *)); | |
527 | bfd_vma bfd_getl16 PARAMS ((const unsigned char *)); | |
528 | bfd_signed_vma bfd_getb_signed_16 PARAMS ((const unsigned char *)); | |
529 | bfd_signed_vma bfd_getl_signed_16 PARAMS ((const unsigned char *)); | |
8d12f138 ILT |
530 | void bfd_putb64 PARAMS ((bfd_vma, unsigned char *)); |
531 | void bfd_putl64 PARAMS ((bfd_vma, unsigned char *)); | |
532 | void bfd_putb32 PARAMS ((bfd_vma, unsigned char *)); | |
533 | void bfd_putl32 PARAMS ((bfd_vma, unsigned char *)); | |
534 | void bfd_putb16 PARAMS ((bfd_vma, unsigned char *)); | |
535 | void bfd_putl16 PARAMS ((bfd_vma, unsigned char *)); | |
536 | ||
537 | /* ECOFF linking routines. */ | |
538 | #ifdef __STDC__ | |
539 | struct ecoff_debug_info; | |
540 | struct ecoff_debug_swap; | |
541 | struct ecoff_extr; | |
542 | struct symbol_cache_entry; | |
543 | #endif | |
544 | extern boolean bfd_ecoff_debug_accumulate | |
545 | PARAMS ((bfd *output_bfd, struct ecoff_debug_info *output_debug, | |
546 | const struct ecoff_debug_swap *output_swap, | |
547 | bfd *input_bfd, struct ecoff_debug_info *input_debug, | |
548 | const struct ecoff_debug_swap *input_swap, | |
549 | boolean relocateable)); | |
550 | extern boolean bfd_ecoff_debug_link_other | |
551 | PARAMS ((bfd *output_bfd, struct ecoff_debug_info *output_debug, | |
552 | const struct ecoff_debug_swap *output_swap, bfd *input_bfd)); | |
553 | extern boolean bfd_ecoff_debug_externals | |
554 | PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, | |
555 | const struct ecoff_debug_swap *swap, | |
556 | boolean relocateable, | |
557 | boolean (*get_extr) (struct symbol_cache_entry *, | |
558 | struct ecoff_extr *), | |
559 | void (*set_index) (struct symbol_cache_entry *, | |
560 | bfd_size_type))); | |
561 | extern bfd_size_type bfd_ecoff_debug_size | |
562 | PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, | |
563 | const struct ecoff_debug_swap *swap)); | |
564 | extern boolean bfd_ecoff_write_debug | |
565 | PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, | |
566 | const struct ecoff_debug_swap *swap, file_ptr where)); | |
63ffe5ef | 567 | |
294eaca4 | 568 | /* And more from the source. */ |