Commit | Line | Data |
---|---|---|
6724ff46 RP |
1 | /* Generic BFD library interface and support routines. |
2 | Copyright (C) 1990-1991 Free Software Foundation, Inc. | |
3 | Written by Cygnus Support. | |
4a81b561 | 4 | |
6724ff46 | 5 | This file is part of BFD, the Binary File Descriptor library. |
4a81b561 | 6 | |
6724ff46 | 7 | This program is free software; you can redistribute it and/or modify |
4a81b561 | 8 | it under the terms of the GNU General Public License as published by |
6724ff46 RP |
9 | the Free Software Foundation; either version 2 of the License, or |
10 | (at your option) any later version. | |
4a81b561 | 11 | |
6724ff46 | 12 | This program is distributed in the hope that it will be useful, |
4a81b561 DHW |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
6724ff46 RP |
18 | along with this program; if not, write to the Free Software |
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
6f715d66 | 20 | |
4a81b561 | 21 | /* $Id$ */ |
6f715d66 SC |
22 | |
23 | /*proto* | |
b1c86ef1 | 24 | @section @code{typedef bfd} |
6f715d66 | 25 | |
b1c86ef1 SEF |
26 | A BFD is has type @code{bfd}; objects of this type are the cornerstone |
27 | of any application using @code{libbfd}. References though the BFD and | |
28 | to data in the BFD give the entire BFD functionality. | |
6f715d66 | 29 | |
b1c86ef1 SEF |
30 | Here is the struct used to define the type @code{bfd}. This contains |
31 | the major data about the file, and contains pointers to the rest of | |
32 | the data. | |
6f715d66 SC |
33 | |
34 | *+++ | |
35 | ||
36 | $struct _bfd | |
37 | ${ | |
6724ff46 | 38 | The filename the application opened the BFD with. |
6f715d66 SC |
39 | |
40 | $ CONST char *filename; | |
41 | ||
42 | A pointer to the target jump table. | |
43 | ||
44 | $ struct bfd_target *xvec; | |
45 | ||
46 | ||
47 | To avoid dragging too many header files into every file that | |
6724ff46 | 48 | includes @file{bfd.h}, IOSTREAM has been declared as a "char *", and MTIME |
6f715d66 SC |
49 | as a "long". Their correct types, to which they are cast when used, |
50 | are "FILE *" and "time_t". | |
51 | ||
52 | The iostream is the result of an fopen on the filename. | |
53 | ||
54 | $ char *iostream; | |
55 | ||
56 | Is the file being cached @xref{File Caching}. | |
57 | ||
58 | $ boolean cacheable; | |
59 | ||
6724ff46 | 60 | Marks whether there was a default target specified when the BFD was |
6f715d66 SC |
61 | opened. This is used to select what matching algorithm to use to chose |
62 | the back end. | |
63 | ||
64 | $ boolean target_defaulted; | |
65 | ||
188d6d22 RP |
66 | The caching routines use these to maintain a least-recently-used list of |
67 | BFDs (@pxref{File Caching}). | |
6f715d66 SC |
68 | |
69 | $ struct _bfd *lru_prev, *lru_next; | |
70 | ||
188d6d22 RP |
71 | When a file is closed by the caching routines, BFD retains state |
72 | information on the file here: | |
6f715d66 SC |
73 | |
74 | $ file_ptr where; | |
75 | ||
76 | and here: | |
77 | ||
78 | $ boolean opened_once; | |
79 | ||
80 | $ boolean mtime_set; | |
81 | File modified time | |
82 | ||
83 | $ long mtime; | |
84 | ||
b1c86ef1 | 85 | Reserved for an unimplemented file locking extension. |
6f715d66 SC |
86 | |
87 | $int ifd; | |
88 | ||
6724ff46 | 89 | The format which belongs to the BFD. |
6f715d66 SC |
90 | |
91 | $ bfd_format format; | |
92 | ||
6724ff46 | 93 | The direction the BFD was opened with |
6f715d66 SC |
94 | |
95 | $ enum bfd_direction {no_direction = 0, | |
96 | $ read_direction = 1, | |
97 | $ write_direction = 2, | |
98 | $ both_direction = 3} direction; | |
99 | ||
100 | Format_specific flags | |
101 | ||
102 | $ flagword flags; | |
103 | ||
104 | Currently my_archive is tested before adding origin to anything. I | |
105 | believe that this can become always an add of origin, with origin set | |
106 | to 0 for non archive files. | |
107 | ||
108 | $ file_ptr origin; | |
109 | ||
110 | Remember when output has begun, to stop strange things happening. | |
111 | ||
112 | $ boolean output_has_begun; | |
113 | ||
114 | Pointer to linked list of sections | |
115 | ||
116 | $ struct sec *sections; | |
117 | ||
118 | The number of sections | |
119 | ||
120 | $ unsigned int section_count; | |
121 | ||
188d6d22 | 122 | Stuff only useful for object files: |
6f715d66 SC |
123 | The start address. |
124 | ||
125 | $ bfd_vma start_address; | |
126 | Used for input and output | |
127 | ||
128 | $ unsigned int symcount; | |
188d6d22 | 129 | Symbol table for output BFD |
6f715d66 SC |
130 | |
131 | $ struct symbol_cache_entry **outsymbols; | |
132 | ||
bbc8d484 | 133 | Pointer to structure which contains architecture information |
6f715d66 | 134 | |
bbc8d484 | 135 | $ struct bfd_arch_info *arch_info; |
6f715d66 | 136 | |
188d6d22 | 137 | Stuff only useful for archives: |
6f715d66 SC |
138 | |
139 | $ PTR arelt_data; | |
140 | $ struct _bfd *my_archive; | |
141 | $ struct _bfd *next; | |
142 | $ struct _bfd *archive_head; | |
143 | $ boolean has_armap; | |
144 | ||
145 | Used by the back end to hold private data. | |
146 | ||
147 | $ PTR tdata; | |
148 | ||
149 | Used by the application to hold private data | |
150 | ||
151 | $ PTR usrdata; | |
152 | ||
188d6d22 | 153 | Where all the allocated stuff under this BFD goes (@pxref{Memory Usage}). |
6f715d66 SC |
154 | |
155 | $ struct obstack memory; | |
156 | $}; | |
157 | ||
158 | *--- | |
159 | ||
160 | */ | |
4a81b561 | 161 | #include "bfd.h" |
bbc8d484 | 162 | #include "sysdep.h" |
4a81b561 DHW |
163 | #include "libbfd.h" |
164 | ||
cbdc7909 | 165 | #undef strerror |
bbc8d484 JG |
166 | extern char *strerror(); |
167 | ||
6f715d66 | 168 | |
4a81b561 | 169 | short _bfd_host_big_endian = 0x0100; |
6f715d66 SC |
170 | /* Accessing the above as (*(char*)&_bfd_host_big_endian), will |
171 | return 1 if the host is big-endian, 0 otherwise. | |
172 | (assuming that a short is two bytes long!!! FIXME) | |
173 | (See HOST_IS_BIG_ENDIAN_P in bfd.h.) */ | |
4a81b561 DHW |
174 | \f |
175 | /** Error handling | |
176 | o - Most functions return nonzero on success (check doc for | |
6f715d66 | 177 | precise semantics); 0 or NULL on error. |
4a81b561 | 178 | o - Internal errors are documented by the value of bfd_error. |
6f715d66 | 179 | If that is system_call_error then check errno. |
4a81b561 DHW |
180 | o - The easiest way to report this to the user is to use bfd_perror. |
181 | */ | |
182 | ||
183 | bfd_ec bfd_error = no_error; | |
184 | ||
6f715d66 SC |
185 | char *bfd_errmsgs[] = { "No error", |
186 | "System call error", | |
187 | "Invalid target", | |
188 | "File in wrong format", | |
189 | "Invalid operation", | |
190 | "Memory exhausted", | |
191 | "No symbols", | |
192 | "No relocation info", | |
193 | "No more archived files", | |
194 | "Malformed archive", | |
195 | "Symbol not found", | |
196 | "File format not recognized", | |
197 | "File format is ambiguous", | |
198 | "Section has no contents", | |
199 | "Nonrepresentable section on output", | |
cbdc7909 | 200 | "Symbol needs debug section which does not exist", |
6f715d66 SC |
201 | "#<Invalid error code>" |
202 | }; | |
4a81b561 | 203 | |
9846338e SC |
204 | static |
205 | void | |
206 | DEFUN(bfd_nonrepresentable_section,(abfd, name), | |
6f715d66 SC |
207 | CONST bfd * CONST abfd AND |
208 | CONST char * CONST name) | |
9846338e | 209 | { |
1f4d3c79 | 210 | printf("bfd error writing file %s, format %s can't represent section %s\n", |
6f715d66 SC |
211 | abfd->filename, |
212 | abfd->xvec->name, | |
213 | name); | |
9846338e SC |
214 | exit(1); |
215 | } | |
fc723380 | 216 | |
9846338e SC |
217 | bfd_error_vector_type bfd_error_vector = |
218 | { | |
219 | bfd_nonrepresentable_section | |
220 | }; | |
221 | ||
4a81b561 DHW |
222 | char * |
223 | bfd_errmsg (error_tag) | |
224 | bfd_ec error_tag; | |
225 | { | |
7ed4093a SC |
226 | #ifndef errno |
227 | extern int errno; | |
228 | #endif | |
4a81b561 DHW |
229 | if (error_tag == system_call_error) |
230 | return strerror (errno); | |
231 | ||
232 | if ((((int)error_tag <(int) no_error) || | |
233 | ((int)error_tag > (int)invalid_error_code))) | |
234 | error_tag = invalid_error_code;/* sanity check */ | |
235 | ||
236 | return bfd_errmsgs [(int)error_tag]; | |
237 | } | |
238 | ||
9846338e SC |
239 | |
240 | void bfd_default_error_trap(error_tag) | |
241 | bfd_ec error_tag; | |
242 | { | |
243 | printf("bfd assert fail (%s)\n", bfd_errmsg(error_tag)); | |
244 | } | |
245 | ||
246 | void (*bfd_error_trap)() = bfd_default_error_trap; | |
247 | void (*bfd_error_nonrepresentabltrap)() = bfd_default_error_trap; | |
fc723380 | 248 | |
4a81b561 | 249 | void |
1f4d3c79 SC |
250 | DEFUN(bfd_perror,(message), |
251 | CONST char *message) | |
4a81b561 DHW |
252 | { |
253 | if (bfd_error == system_call_error) | |
6f715d66 | 254 | perror((char *)message); /* must be system error then... */ |
4a81b561 DHW |
255 | else { |
256 | if (message == NULL || *message == '\0') | |
257 | fprintf (stderr, "%s\n", bfd_errmsg (bfd_error)); | |
258 | else | |
259 | fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_error)); | |
260 | } | |
261 | } | |
262 | ||
6f715d66 | 263 | \f |
4a81b561 DHW |
264 | /** Symbols */ |
265 | ||
4a81b561 | 266 | /* returns the number of octets of storage required */ |
6f715d66 | 267 | |
4a81b561 DHW |
268 | unsigned int |
269 | get_reloc_upper_bound (abfd, asect) | |
270 | bfd *abfd; | |
271 | sec_ptr asect; | |
272 | { | |
273 | if (abfd->format != bfd_object) { | |
274 | bfd_error = invalid_operation; | |
275 | return 0; | |
276 | } | |
277 | ||
278 | return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect)); | |
279 | } | |
280 | ||
281 | unsigned int | |
282 | bfd_canonicalize_reloc (abfd, asect, location, symbols) | |
283 | bfd *abfd; | |
284 | sec_ptr asect; | |
285 | arelent **location; | |
286 | asymbol **symbols; | |
287 | { | |
288 | if (abfd->format != bfd_object) { | |
289 | bfd_error = invalid_operation; | |
290 | return 0; | |
291 | } | |
292 | ||
293 | return BFD_SEND (abfd, _bfd_canonicalize_reloc, (abfd, asect, location, symbols)); | |
294 | } | |
295 | ||
4a81b561 DHW |
296 | |
297 | boolean | |
298 | bfd_set_file_flags (abfd, flags) | |
299 | bfd *abfd; | |
300 | flagword flags; | |
301 | { | |
302 | if (abfd->format != bfd_object) { | |
303 | bfd_error = wrong_format; | |
304 | return false; | |
305 | } | |
306 | ||
307 | if (bfd_read_p (abfd)) { | |
308 | bfd_error = invalid_operation; | |
309 | return false; | |
310 | } | |
311 | ||
312 | if ((flags & bfd_applicable_file_flags (abfd)) != flags) { | |
313 | bfd_error = invalid_operation; | |
314 | return false; | |
315 | } | |
316 | ||
317 | bfd_get_file_flags (abfd) = flags; | |
318 | return true; | |
319 | } | |
320 | ||
321 | ||
322 | void | |
323 | bfd_set_reloc (ignore_abfd, asect, location, count) | |
324 | bfd *ignore_abfd; | |
325 | sec_ptr asect; | |
326 | arelent **location; | |
327 | unsigned int count; | |
328 | { | |
329 | asect->orelocation = location; | |
330 | asect->reloc_count = count; | |
331 | } | |
4a81b561 DHW |
332 | |
333 | void | |
334 | bfd_assert(file, line) | |
335 | char *file; | |
336 | int line; | |
337 | { | |
338 | printf("bfd assertion fail %s:%d\n",file,line); | |
339 | } | |
340 | ||
341 | ||
6f715d66 SC |
342 | /*proto* bfd_set_start_address |
343 | ||
6724ff46 | 344 | Marks the entry point of an output BFD. Returns @code{true} on |
6f715d66 SC |
345 | success, @code{false} otherwise. |
346 | ||
347 | *; PROTO(boolean, bfd_set_start_address,(bfd *, bfd_vma)); | |
348 | */ | |
349 | ||
4a81b561 DHW |
350 | boolean |
351 | bfd_set_start_address(abfd, vma) | |
352 | bfd *abfd; | |
353 | bfd_vma vma; | |
354 | { | |
355 | abfd->start_address = vma; | |
356 | return true; | |
357 | } | |
358 | ||
359 | ||
6f715d66 SC |
360 | /*proto* bfd_get_mtime |
361 | ||
362 | Return cached file modification time (e.g. as read from archive header | |
363 | for archive members, or from file system if we have been called | |
364 | before); else determine modify time, cache it, and return it. | |
4a81b561 | 365 | |
41f50af0 | 366 | *; PROTO(long, bfd_get_mtime, (bfd *)); |
6f715d66 SC |
367 | |
368 | */ | |
4a81b561 DHW |
369 | |
370 | long | |
371 | bfd_get_mtime (abfd) | |
372 | bfd *abfd; | |
373 | { | |
374 | FILE *fp; | |
375 | struct stat buf; | |
376 | ||
377 | if (abfd->mtime_set) | |
378 | return abfd->mtime; | |
379 | ||
380 | fp = bfd_cache_lookup (abfd); | |
381 | if (0 != fstat (fileno (fp), &buf)) | |
382 | return 0; | |
383 | ||
384 | abfd->mtime_set = true; | |
385 | abfd->mtime = buf.st_mtime; | |
386 | return abfd->mtime; | |
387 | } | |
6f715d66 | 388 | |
6724ff46 RP |
389 | /*proto* stuff |
390 | ||
6f715d66 | 391 | *+ |
6724ff46 | 392 | |
6f715d66 SC |
393 | #define bfd_sizeof_headers(abfd, reloc) \ |
394 | BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) | |
395 | ||
396 | #define bfd_find_nearest_line(abfd, section, symbols, offset, filename_ptr, func, line_ptr) \ | |
397 | BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, section, symbols, offset, filename_ptr, func, line_ptr)) | |
398 | ||
399 | #define bfd_debug_info_start(abfd) \ | |
400 | BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) | |
401 | ||
402 | #define bfd_debug_info_end(abfd) \ | |
403 | BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) | |
404 | ||
405 | #define bfd_debug_info_accumulate(abfd, section) \ | |
406 | BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) | |
407 | ||
408 | #define bfd_stat_arch_elt(abfd, stat) \ | |
409 | BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) | |
8fd6eb08 SC |
410 | |
411 | #define bfd_coff_swap_aux_in(a,e,t,c,i) \ | |
412 | BFD_SEND (a, _bfd_coff_swap_aux_in, (a,e,t,c,i)) | |
413 | ||
414 | #define bfd_coff_swap_sym_in(a,e,i) \ | |
415 | BFD_SEND (a, _bfd_coff_swap_sym_in, (a,e,i)) | |
416 | ||
417 | #define bfd_coff_swap_lineno_in(a,e,i) \ | |
418 | BFD_SEND ( a, _bfd_coff_swap_lineno_in, (a,e,i)) | |
bbc8d484 JG |
419 | |
420 | #define bfd_set_arch_mach(abfd, arch, mach)\ | |
421 | BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) | |
422 | ||
cbdc7909 JG |
423 | #define bfd_coff_swap_reloc_out(abfd, i, o) \ |
424 | BFD_SEND (abfd, _bfd_coff_swap_reloc_out, (abfd, i, o)) | |
425 | ||
426 | #define bfd_coff_swap_lineno_out(abfd, i, o) \ | |
427 | BFD_SEND (abfd, _bfd_coff_swap_lineno_out, (abfd, i, o)) | |
428 | ||
429 | #define bfd_coff_swap_aux_out(abfd, i, t,c,o) \ | |
430 | BFD_SEND (abfd, _bfd_coff_swap_aux_out, (abfd, i,t,c, o)) | |
431 | ||
432 | #define bfd_coff_swap_sym_out(abfd, i,o) \ | |
433 | BFD_SEND (abfd, _bfd_coff_swap_sym_out, (abfd, i, o)) | |
434 | ||
435 | #define bfd_coff_swap_scnhdr_out(abfd, i,o) \ | |
436 | BFD_SEND (abfd, _bfd_coff_swap_scnhdr_out, (abfd, i, o)) | |
437 | ||
438 | #define bfd_coff_swap_filehdr_out(abfd, i,o) \ | |
439 | BFD_SEND (abfd, _bfd_coff_swap_filehdr_out, (abfd, i, o)) | |
440 | ||
441 | #define bfd_coff_swap_aouthdr_out(abfd, i,o) \ | |
442 | BFD_SEND (abfd, _bfd_coff_swap_aouthdr_out, (abfd, i, o)) | |
443 | ||
6f715d66 SC |
444 | *- |
445 | ||
446 | */ | |
447 | ||
448 | ||
449 | ||
450 | ||
451 | ||
452 |