Commit | Line | Data |
---|---|---|
c618de01 SC |
1 | /* libbfd.h -- Declarations used by bfd library *implementation*. |
2 | (This include file is not for users of the library.) | |
de0da6ce | 3 | Copyright 1990, 1991 Free Software Foundation, Inc. |
c618de01 | 4 | Written by Cygnus Support. |
fc723380 | 5 | |
c618de01 | 6 | This file is part of BFD, the Binary File Descriptor library. |
4a81b561 | 7 | |
c618de01 | 8 | This program is free software; you can redistribute it and/or modify |
4a81b561 | 9 | it under the terms of the GNU General Public License as published by |
c618de01 SC |
10 | the Free Software Foundation; either version 2 of the License, or |
11 | (at your option) any later version. | |
4a81b561 | 12 | |
c618de01 | 13 | This program is distributed in the hope that it will be useful, |
4a81b561 DHW |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
c618de01 SC |
19 | along with this program; if not, write to the Free Software |
20 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
4a81b561 | 21 | |
4a81b561 | 22 | |
01dd1b2b SC |
23 | /* Align an address upward to a boundary, expressed as a number of bytes. |
24 | E.g. align to an 8-byte boundary with argument of 8. */ | |
de0da6ce | 25 | #define BFD_ALIGN(this, boundary) \ |
01dd1b2b SC |
26 | ((( (this) + ((boundary) -1)) & (~((boundary)-1)))) |
27 | ||
4a81b561 DHW |
28 | /* If you want to read and write large blocks, you might want to do it |
29 | in quanta of this amount */ | |
30 | #define DEFAULT_BUFFERSIZE 8192 | |
31 | ||
fc723380 JG |
32 | /* Set a tdata field. Can't use the other macros for this, since they |
33 | do casts, and casting to the left of assignment isn't portable. */ | |
34 | #define set_tdata(bfd, v) ((bfd)->tdata = (PTR) (v)) | |
35 | ||
36 | /* tdata for an archive. For an input archive, cache | |
37 | needs to be free()'d. For an output archive, symdefs do. */ | |
4a81b561 DHW |
38 | |
39 | struct artdata { | |
40 | file_ptr first_file_filepos; | |
41 | /* Speed up searching the armap */ | |
42 | struct ar_cache *cache; | |
43 | bfd *archive_head; /* Only interesting in output routines */ | |
44 | carsym *symdefs; /* the symdef entries */ | |
45 | symindex symdef_count; /* how many there are */ | |
46 | char *extended_names; /* clever intel extension */ | |
47 | }; | |
48 | ||
49 | #define bfd_ardata(bfd) ((struct artdata *) ((bfd)->tdata)) | |
4a81b561 DHW |
50 | |
51 | /* Goes in bfd's arelt_data slot */ | |
52 | struct areltdata { | |
53 | char * arch_header; /* it's actually a string */ | |
54 | unsigned int parsed_size; /* octets of filesize not including ar_hdr */ | |
55 | char *filename; /* null-terminated */ | |
56 | }; | |
57 | ||
58 | #define arelt_size(bfd) (((struct areltdata *)((bfd)->arelt_data))->parsed_size) | |
59 | ||
60 | /* FIXME -- a lot of my code allocates a large block and subdivides it. | |
61 | This can't always work, because of alignment restrictions. We should change | |
62 | it before it becomes a problem -- Gumby */ | |
63 | ||
fc723380 | 64 | PROTO (char *, zalloc, (bfd_size_type size)); |
9846338e | 65 | |
fc723380 JG |
66 | /* These routines allocate and free things on the BFD's obstack. Note |
67 | that realloc can never occur in place. */ | |
4a81b561 | 68 | |
fc723380 JG |
69 | PROTO(PTR, bfd_alloc, (bfd *abfd, bfd_size_type size)); |
70 | PROTO(PTR, bfd_zalloc,(bfd *abfd, bfd_size_type size)); | |
71 | PROTO(PTR, bfd_realloc,(bfd *abfd, PTR orig, bfd_size_type new)); | |
6f715d66 SC |
72 | PROTO(void, bfd_alloc_grow,(bfd *abfd, PTR thing, bfd_size_type size)); |
73 | PROTO(PTR, bfd_alloc_finish,(bfd *abfd)); | |
74 | ||
fc723380 | 75 | #define bfd_release(x,y) (void) obstack_free(&(x->memory),y) |
4a81b561 | 76 | |
6f715d66 | 77 | |
fc723380 | 78 | PROTO (bfd_size_type, bfd_read, (PTR ptr, bfd_size_type size, bfd_size_type nitems, bfd *abfd)); |
63ffe5ef | 79 | PROTO (bfd_size_type, bfd_write, (CONST PTR ptr, bfd_size_type size, bfd_size_type nitems, bfd *abfd)); |
4a81b561 | 80 | |
6f715d66 SC |
81 | |
82 | ||
9846338e | 83 | PROTO (int, bfd_seek,(bfd* abfd, file_ptr fp , int direction)); |
4a81b561 DHW |
84 | PROTO (long, bfd_tell, (bfd *abfd)); |
85 | PROTO (bfd *, _bfd_create_empty_archive_element_shell, (bfd *obfd)); | |
86 | PROTO (bfd *, look_for_bfd_in_cache, (bfd *arch_bfd, file_ptr index)); | |
87 | PROTO (boolean, _bfd_generic_mkarchive, (bfd *abfd)); | |
88 | PROTO (struct areltdata *, snarf_ar_hdr, (bfd *abfd)); | |
89 | PROTO (bfd_target *, bfd_generic_archive_p, (bfd *abfd)); | |
90 | PROTO (boolean, bfd_slurp_bsd_armap, (bfd *abfd)); | |
91 | PROTO (boolean, bfd_slurp_coff_armap, (bfd *abfd)); | |
92 | PROTO (boolean, _bfd_slurp_extended_name_table, (bfd *abfd)); | |
93 | PROTO (boolean, _bfd_write_archive_contents, (bfd *abfd)); | |
94 | PROTO (bfd *, new_bfd, ()); | |
95 | ||
96 | #define DEFAULT_STRING_SPACE_SIZE 0x2000 | |
97 | PROTO (boolean, bfd_add_to_string_table, (char **table, char *new_string, | |
98 | unsigned int *table_length, | |
99 | char **free_ptr)); | |
c618de01 SC |
100 | PROTO (bfd_vma, _do_getb64, (unsigned char *addr)); |
101 | PROTO (bfd_vma, _do_getl64, (unsigned char *addr)); | |
102 | PROTO (bfd_vma, _do_getb32, (unsigned char *addr)); | |
103 | PROTO (bfd_vma, _do_getl32, (unsigned char *addr)); | |
104 | PROTO (bfd_vma, _do_getb16, (unsigned char *addr)); | |
105 | PROTO (bfd_vma, _do_getl16, (unsigned char *addr)); | |
106 | PROTO (void, _do_putb64, (bfd_vma data, unsigned char *addr)); | |
107 | PROTO (void, _do_putl64, (bfd_vma data, unsigned char *addr)); | |
108 | PROTO (void, _do_putb32, (bfd_vma data, unsigned char *addr)); | |
109 | PROTO (void, _do_putl32, (bfd_vma data, unsigned char *addr)); | |
110 | PROTO (void, _do_putb16, (bfd_vma data, unsigned char *addr)); | |
111 | PROTO (void, _do_putl16, (bfd_vma data, unsigned char *addr)); | |
4a81b561 DHW |
112 | |
113 | PROTO (boolean, bfd_false, (bfd *ignore)); | |
114 | PROTO (boolean, bfd_true, (bfd *ignore)); | |
a0ad3035 | 115 | PROTO (PTR, bfd_nullvoidptr, (bfd *ignore)); |
4a81b561 DHW |
116 | PROTO (int, bfd_0, (bfd *ignore)); |
117 | PROTO (unsigned int, bfd_0u, (bfd *ignore)); | |
118 | PROTO (void, bfd_void, (bfd *ignore)); | |
119 | ||
4a81b561 DHW |
120 | PROTO (bfd *,new_bfd_contained_in,(bfd *)); |
121 | PROTO (boolean, _bfd_dummy_new_section_hook, (bfd *ignore, asection *newsect)); | |
122 | PROTO (char *, _bfd_dummy_core_file_failing_command, (bfd *abfd)); | |
123 | PROTO (int, _bfd_dummy_core_file_failing_signal, (bfd *abfd)); | |
124 | PROTO (boolean, _bfd_dummy_core_file_matches_executable_p, (bfd *core_bfd, | |
125 | bfd *exec_bfd)); | |
126 | PROTO (bfd_target *, _bfd_dummy_target, (bfd *abfd)); | |
127 | ||
69ebee86 JG |
128 | PROTO (void, bfd_dont_truncate_arname, (bfd *abfd, CONST char *filename, |
129 | char *hdr)); | |
130 | PROTO (void, bfd_bsd_truncate_arname, (bfd *abfd, CONST char *filename, | |
131 | char *hdr)); | |
132 | PROTO (void, bfd_gnu_truncate_arname, (bfd *abfd, CONST char *filename, | |
133 | char *hdr)); | |
4a81b561 DHW |
134 | |
135 | PROTO (boolean, bsd_write_armap, (bfd *arch, unsigned int elength, | |
01dd1b2b | 136 | struct orl *map, unsigned int orl_count, int stridx)); |
4a81b561 DHW |
137 | |
138 | PROTO (boolean, coff_write_armap, (bfd *arch, unsigned int elength, | |
01dd1b2b | 139 | struct orl *map, unsigned int orl_count, int stridx)); |
4a81b561 | 140 | |
2203f786 JG |
141 | PROTO (bfd *, bfd_generic_openr_next_archived_file, (bfd *archive, |
142 | bfd *last_file)); | |
4a81b561 DHW |
143 | |
144 | PROTO(int, bfd_generic_stat_arch_elt, (bfd *, struct stat *)); | |
fc723380 | 145 | |
2203f786 | 146 | PROTO(boolean, bfd_generic_get_section_contents, |
01dd1b2b SC |
147 | (bfd *abfd, sec_ptr section, PTR location, file_ptr offset, |
148 | bfd_size_type count)); | |
149 | ||
150 | PROTO(boolean, bfd_generic_set_section_contents, | |
151 | (bfd *abfd, sec_ptr section, PTR location, file_ptr offset, | |
152 | bfd_size_type count)); | |
2203f786 | 153 | |
4a81b561 DHW |
154 | /* Macros to tell if bfds are read or write enabled. |
155 | ||
156 | Note that bfds open for read may be scribbled into if the fd passed | |
157 | to bfd_fdopenr is actually open both for read and write | |
158 | simultaneously. However an output bfd will never be open for | |
159 | read. Therefore sometimes you want to check bfd_read_p or | |
160 | !bfd_read_p, and only sometimes bfd_write_p. | |
161 | */ | |
162 | ||
163 | #define bfd_read_p(abfd) ((abfd)->direction == read_direction || (abfd)->direction == both_direction) | |
164 | #define bfd_write_p(abfd) ((abfd)->direction == write_direction || (abfd)->direction == both_direction) | |
165 | ||
166 | PROTO (void, bfd_assert,(char*,int)); | |
167 | #define BFD_ASSERT(x) \ | |
168 | { if (!(x)) bfd_assert(__FILE__,__LINE__); } | |
169 | ||
170 | #define BFD_FAIL() \ | |
171 | { bfd_assert(__FILE__,__LINE__); } | |
172 | ||
173 | PROTO (FILE *, bfd_cache_lookup_worker, (bfd *)); | |
174 | ||
175 | extern bfd *bfd_last_cache; | |
4a81b561 DHW |
176 | |
177 | /* Now Steve, what's the story here? */ | |
178 | #ifdef lint | |
179 | #define itos(x) "l" | |
180 | #define stoi(x) 1 | |
181 | #else | |
182 | #define itos(x) ((char*)(x)) | |
183 | #define stoi(x) ((int)(x)) | |
184 | #endif | |
69ebee86 JG |
185 | |
186 | /* Generic routine for close_and_cleanup is really just bfd_true. */ | |
187 | #define bfd_generic_close_and_cleanup bfd_true | |
6f715d66 SC |
188 | |
189 | /* THE FOLLOWING IS EXTRACTED FROM THE SOURCE*/ | |
190 | ||
63ffe5ef SC |
191 | /*:init.c*/ |
192 | /* bfd_check_init | |
193 | ||
194 | This routine is called before any other bfd function using initialized | |
195 | data is used to ensure that the structures have been initialized. | |
196 | Soon this function will go away, and the bfd library will assume that | |
197 | bfd_init has been called. | |
198 | */ | |
199 | ||
200 | void EXFUN(bfd_check_init,(void)); | |
201 | ||
202 | /* | |
203 | */ | |
c618de01 | 204 | |
63ffe5ef | 205 | /*:libbfd.c*/ |
de0da6ce JG |
206 | /* bfd_xmalloc |
207 | bfd_xmalloc -- Like malloc, but exit if no more memory. | |
208 | */ | |
209 | PROTO(PTR, bfd_xmalloc,( bfd_size_type size)); | |
210 | ||
211 | /* | |
212 | ||
213 | bfd_write_bigendian_4byte_int | |
01dd1b2b SC |
214 | */ |
215 | ||
216 | PROTO(void, bfd_write_bigendian_4byte_int,( bfd *abfd, int i)); | |
217 | ||
218 | /* | |
219 | ||
220 | *i bfd_log2 | |
c618de01 | 221 | Return the log base 2 of the value supplied, rounded up. eg an arg |
6f715d66 SC |
222 | of 1025 would return 11. |
223 | */ | |
c618de01 SC |
224 | PROTO(bfd_vma, bfd_log2,(bfd_vma x)); |
225 | ||
226 | /* | |
63ffe5ef | 227 | */ |
c618de01 | 228 | |
63ffe5ef SC |
229 | /*:cache.c*/ |
230 | /* BFD_CACHE_MAX_OPEN | |
c618de01 | 231 | The maxiumum number of files which the cache will keep open at one |
6f715d66 SC |
232 | time. |
233 | */ | |
234 | #define BFD_CACHE_MAX_OPEN 10 | |
235 | ||
c618de01 SC |
236 | /* |
237 | ||
238 | bfd_last_cache | |
6724ff46 RP |
239 | Zero, or a pointer to the topmost BFD on the chain. This is used by |
240 | the @code{bfd_cache_lookup} macro in @file{libbfd.h} to determine when | |
241 | it can avoid a function call. | |
6f715d66 SC |
242 | */ |
243 | extern bfd *bfd_last_cache; | |
244 | ||
c618de01 SC |
245 | /* |
246 | ||
247 | bfd_cache_lookup | |
6724ff46 RP |
248 | Checks to see if the required BFD is the same as the last one looked |
249 | up. If so then it can use the iostream in the BFD with impunity, since | |
6f715d66 SC |
250 | it can't have changed since the last lookup, otherwise it has to |
251 | perform the complicated lookup function | |
252 | */ | |
253 | #define bfd_cache_lookup(x) \ | |
254 | ((x)==bfd_last_cache? \ | |
255 | (FILE*)(bfd_last_cache->iostream): \ | |
256 | bfd_cache_lookup_worker(x)) | |
257 | ||
c618de01 | 258 | /* |
6f715d66 | 259 | |
c618de01 SC |
260 | *i bfd_cache_init |
261 | Initialize a BFD by putting it on the cache LRU. | |
6f715d66 | 262 | */ |
c618de01 SC |
263 | PROTO(void, bfd_cache_init, (bfd *)); |
264 | ||
265 | /* | |
266 | ||
267 | *i bfd_cache_close | |
188d6d22 | 268 | Remove the BFD from the cache. If the attached file is open, then close it too. |
6f715d66 | 269 | */ |
c618de01 SC |
270 | PROTO(void, bfd_cache_close, (bfd *)); |
271 | ||
272 | /* | |
273 | ||
274 | *i bfd_open_file | |
275 | Call the OS to open a file for this BFD. Returns the FILE * | |
6f715d66 SC |
276 | (possibly null) that results from this operation. Sets up the |
277 | BFD so that future accesses know the file is open. If the FILE * | |
278 | returned is null, then there is won't have been put in the cache, so | |
279 | it won't have to be removed from it. | |
280 | */ | |
c618de01 SC |
281 | PROTO(FILE *, bfd_open_file, (bfd *)); |
282 | ||
283 | /* | |
284 | ||
285 | *i bfd_cache_lookup_worker | |
286 | Called when the macro @code{bfd_cache_lookup} fails to find a quick | |
6f715d66 SC |
287 | answer. Finds a file descriptor for this BFD. If necessary, it open it. |
288 | If there are already more than BFD_CACHE_MAX_OPEN files open, it trys to close | |
289 | one first, to avoid running out of file descriptors. | |
290 | */ | |
c618de01 SC |
291 | PROTO(FILE *, bfd_cache_lookup_worker, (bfd *)); |
292 | ||
293 | /* | |
63ffe5ef SC |
294 | */ |
295 | ||
296 | ||
de0da6ce JG |
297 | /*:ctor.c*/ |
298 | /* bfd_constructor_entry | |
299 | ||
300 | This function is called with an a symbol describing the | |
301 | function to be called, an string which descibes the xtor type, eg | |
302 | something like "CTOR" or "DTOR" would be fine. And the bfd which owns | |
303 | the function. | |
304 | ||
305 | It's duty is to create a section called "CTOR" or "DTOR" or whatever | |
306 | if the bfd doesn't already have one, and grow a relocation table for | |
307 | the entry points as they accumulate. | |
308 | */ | |
309 | ||
310 | PROTO(void, bfd_constructor_entry, | |
311 | (bfd *abfd, | |
312 | asymbol **symbol_ptr_ptr, | |
313 | CONST char*type)); | |
314 | ||
315 | /* | |
316 | */ | |
317 | ||
318 | ||
63ffe5ef | 319 | /*:reloc.c*/ |
de0da6ce JG |
320 | /* bfd_default_reloc_type_lookup |
321 | ||
322 | Provides a default relocation lookuperer for any architectue | |
323 | */ | |
324 | ||
325 | CONST struct reloc_howto_struct *EXFUN(bfd_default_reloc_type_lookup, | |
326 | (CONST struct bfd_arch_info *, | |
327 | bfd_reloc_code_type code)); | |
328 | ||
329 | /* | |
330 | */ | |
331 | ||
63ffe5ef SC |
332 | |
333 | /*:cpu-h8300.c*/ | |
334 | ||
335 | /*:cpu-i960.c*/ | |
336 | ||
337 | /*:cpu-empty.c*/ | |
338 | ||
63ffe5ef SC |
339 | /*:archures.c*/ |
340 | /* bfd_default_arch_struct | |
341 | ||
342 | What bfds are seeded with | |
343 | */ | |
344 | ||
01dd1b2b | 345 | extern bfd_arch_info_type bfd_default_arch_struct; |
63ffe5ef SC |
346 | |
347 | /* | |
348 | bfd_default_set_arch_mach | |
349 | ||
350 | Set the architecture and machine type in a bfd. This finds the correct | |
351 | pointer to structure and inserts it into the arch_info pointer. | |
352 | */ | |
353 | ||
354 | boolean EXFUN(bfd_default_set_arch_mach,(bfd *abfd, | |
355 | enum bfd_architecture arch, | |
356 | unsigned long mach)); | |
c618de01 | 357 | |
63ffe5ef SC |
358 | /* |
359 | ||
360 | This routine initializes the architecture dispatch table by calling | |
361 | all installed architecture packages and getting them to poke around. | |
362 | */ | |
363 | ||
364 | PROTO(void, bfd_arch_init,(void)); | |
365 | ||
366 | /* | |
367 | ||
368 | bfd_arch_linkin | |
369 | ||
370 | Link the provided arch info structure into the list | |
371 | */ | |
372 | ||
01dd1b2b | 373 | void EXFUN(bfd_arch_linkin,(bfd_arch_info_type *)); |
63ffe5ef SC |
374 | |
375 | /* | |
376 | ||
377 | bfd_default_compatible | |
378 | ||
379 | The default function for testing for compatibility | |
380 | */ | |
381 | ||
01dd1b2b SC |
382 | CONST bfd_arch_info_type *EXFUN(bfd_default_compatible, |
383 | (CONST bfd_arch_info_type *a, | |
384 | CONST bfd_arch_info_type *b)); | |
63ffe5ef SC |
385 | |
386 | /* | |
387 | ||
388 | bfd_default_scan | |
389 | The default function for working out whether this is an architecture | |
390 | hit and a machine hit | |
391 | */ | |
392 | ||
01dd1b2b | 393 | boolean EXFUN(bfd_default_scan,(CONST struct bfd_arch_info *, CONST char *)); |
63ffe5ef SC |
394 | |
395 | /* | |
396 | */ | |
c618de01 | 397 | |
c618de01 | 398 |