* emulparams/elf32ppccommon.sh (LIBPATH_SUFFIX): Provide 32-bit
[deliverable/binutils-gdb.git] / bfd / format.c
1 /* Generic BFD support for file formats.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002,
3 2003, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Written by Cygnus Support.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
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
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23
24 /*
25 SECTION
26 File formats
27
28 A format is a BFD concept of high level file contents type. The
29 formats supported by BFD are:
30
31 o <<bfd_object>>
32
33 The BFD may contain data, symbols, relocations and debug info.
34
35 o <<bfd_archive>>
36
37 The BFD contains other BFDs and an optional index.
38
39 o <<bfd_core>>
40
41 The BFD contains the result of an executable core dump.
42
43 SUBSECTION
44 File format functions
45 */
46
47 #include "sysdep.h"
48 #include "bfd.h"
49 #include "libbfd.h"
50
51 /* IMPORT from targets.c. */
52 extern const size_t _bfd_target_vector_entries;
53
54 /*
55 FUNCTION
56 bfd_check_format
57
58 SYNOPSIS
59 bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
60
61 DESCRIPTION
62 Verify if the file attached to the BFD @var{abfd} is compatible
63 with the format @var{format} (i.e., one of <<bfd_object>>,
64 <<bfd_archive>> or <<bfd_core>>).
65
66 If the BFD has been set to a specific target before the
67 call, only the named target and format combination is
68 checked. If the target has not been set, or has been set to
69 <<default>>, then all the known target backends is
70 interrogated to determine a match. If the default target
71 matches, it is used. If not, exactly one target must recognize
72 the file, or an error results.
73
74 The function returns <<TRUE>> on success, otherwise <<FALSE>>
75 with one of the following error codes:
76
77 o <<bfd_error_invalid_operation>> -
78 if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
79 <<bfd_core>>.
80
81 o <<bfd_error_system_call>> -
82 if an error occured during a read - even some file mismatches
83 can cause bfd_error_system_calls.
84
85 o <<file_not_recognised>> -
86 none of the backends recognised the file format.
87
88 o <<bfd_error_file_ambiguously_recognized>> -
89 more than one backend recognised the file format.
90 */
91
92 bfd_boolean
93 bfd_check_format (bfd *abfd, bfd_format format)
94 {
95 return bfd_check_format_matches (abfd, format, NULL);
96 }
97
98 struct bfd_preserve
99 {
100 void *marker;
101 void *tdata;
102 flagword flags;
103 const struct bfd_arch_info *arch_info;
104 struct bfd_section *sections;
105 struct bfd_section *section_last;
106 unsigned int section_count;
107 struct bfd_hash_table section_htab;
108 };
109
110 /* When testing an object for compatibility with a particular target
111 back-end, the back-end object_p function needs to set up certain
112 fields in the bfd on successfully recognizing the object. This
113 typically happens in a piecemeal fashion, with failures possible at
114 many points. On failure, the bfd is supposed to be restored to its
115 initial state, which is virtually impossible. However, restoring a
116 subset of the bfd state works in practice. This function stores
117 the subset. */
118
119 static bfd_boolean
120 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
121 {
122 preserve->tdata = abfd->tdata.any;
123 preserve->arch_info = abfd->arch_info;
124 preserve->flags = abfd->flags;
125 preserve->sections = abfd->sections;
126 preserve->section_last = abfd->section_last;
127 preserve->section_count = abfd->section_count;
128 preserve->section_htab = abfd->section_htab;
129 preserve->marker = bfd_alloc (abfd, 1);
130 if (preserve->marker == NULL)
131 return FALSE;
132
133 return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
134 sizeof (struct section_hash_entry));
135 }
136
137 /* Clear out a subset of BFD state. */
138
139 static void
140 bfd_reinit (bfd *abfd)
141 {
142 abfd->tdata.any = NULL;
143 abfd->arch_info = &bfd_default_arch_struct;
144 abfd->flags &= BFD_FLAGS_SAVED;
145 bfd_section_list_clear (abfd);
146 }
147
148 /* Restores bfd state saved by bfd_preserve_save. */
149
150 static void
151 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
152 {
153 bfd_hash_table_free (&abfd->section_htab);
154
155 abfd->tdata.any = preserve->tdata;
156 abfd->arch_info = preserve->arch_info;
157 abfd->flags = preserve->flags;
158 abfd->section_htab = preserve->section_htab;
159 abfd->sections = preserve->sections;
160 abfd->section_last = preserve->section_last;
161 abfd->section_count = preserve->section_count;
162
163 /* bfd_release frees all memory more recently bfd_alloc'd than
164 its arg, as well as its arg. */
165 bfd_release (abfd, preserve->marker);
166 preserve->marker = NULL;
167 }
168
169 /* Called when the bfd state saved by bfd_preserve_save is no longer
170 needed. */
171
172 static void
173 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
174 {
175 /* It would be nice to be able to free more memory here, eg. old
176 tdata, but that's not possible since these blocks are sitting
177 inside bfd_alloc'd memory. The section hash is on a separate
178 objalloc. */
179 bfd_hash_table_free (&preserve->section_htab);
180 preserve->marker = NULL;
181 }
182
183 /*
184 FUNCTION
185 bfd_check_format_matches
186
187 SYNOPSIS
188 bfd_boolean bfd_check_format_matches
189 (bfd *abfd, bfd_format format, char ***matching);
190
191 DESCRIPTION
192 Like <<bfd_check_format>>, except when it returns FALSE with
193 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that
194 case, if @var{matching} is not NULL, it will be filled in with
195 a NULL-terminated list of the names of the formats that matched,
196 allocated with <<malloc>>.
197 Then the user may choose a format and try again.
198
199 When done with the list that @var{matching} points to, the caller
200 should free it.
201 */
202
203 bfd_boolean
204 bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
205 {
206 extern const bfd_target binary_vec;
207 const bfd_target * const *target;
208 const bfd_target **matching_vector = NULL;
209 const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
210 int match_count, best_count, best_match;
211 int ar_match_index;
212 struct bfd_preserve preserve;
213
214 if (matching != NULL)
215 *matching = NULL;
216
217 if (!bfd_read_p (abfd)
218 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
219 {
220 bfd_set_error (bfd_error_invalid_operation);
221 return FALSE;
222 }
223
224 if (abfd->format != bfd_unknown)
225 return abfd->format == format;
226
227 if (matching != NULL || *bfd_associated_vector != NULL)
228 {
229 bfd_size_type amt;
230
231 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
232 matching_vector = (const bfd_target **) bfd_malloc (amt);
233 if (!matching_vector)
234 return FALSE;
235 }
236
237 /* Presume the answer is yes. */
238 abfd->format = format;
239 save_targ = abfd->xvec;
240 preserve.marker = NULL;
241
242 /* If the target type was explicitly specified, just check that target. */
243 if (!abfd->target_defaulted)
244 {
245 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */
246 goto err_ret;
247
248 right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
249
250 if (right_targ)
251 goto ok_ret;
252
253 /* For a long time the code has dropped through to check all
254 targets if the specified target was wrong. I don't know why,
255 and I'm reluctant to change it. However, in the case of an
256 archive, it can cause problems. If the specified target does
257 not permit archives (e.g., the binary target), then we should
258 not allow some other target to recognize it as an archive, but
259 should instead allow the specified target to recognize it as an
260 object. When I first made this change, it broke the PE target,
261 because the specified pei-i386 target did not recognize the
262 actual pe-i386 archive. Since there may be other problems of
263 this sort, I changed this test to check only for the binary
264 target. */
265 if (format == bfd_archive && save_targ == &binary_vec)
266 goto err_unrecog;
267 }
268
269 /* Since the target type was defaulted, check them all in the hope
270 that one will be uniquely recognized. */
271 right_targ = NULL;
272 ar_right_targ = NULL;
273 match_targ = NULL;
274 best_match = 256;
275 best_count = 0;
276 match_count = 0;
277 ar_match_index = _bfd_target_vector_entries;
278
279 for (target = bfd_target_vector; *target != NULL; target++)
280 {
281 const bfd_target *temp;
282
283 /* Don't check the default target twice. */
284 if (*target == &binary_vec
285 || (!abfd->target_defaulted && *target == save_targ)
286 || (*target)->match_priority > best_match)
287 continue;
288
289 /* If we already tried a match, the bfd is modified and may
290 have sections attached, which will confuse the next
291 _bfd_check_format call. */
292 bfd_reinit (abfd);
293
294 /* Change BFD's target temporarily. */
295 abfd->xvec = *target;
296
297 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
298 goto err_ret;
299
300 /* If _bfd_check_format neglects to set bfd_error, assume
301 bfd_error_wrong_format. We didn't used to even pay any
302 attention to bfd_error, so I suspect that some
303 _bfd_check_format might have this problem. */
304 bfd_set_error (bfd_error_wrong_format);
305
306 temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
307 if (temp)
308 {
309 match_targ = temp;
310 if (preserve.marker != NULL)
311 bfd_preserve_finish (abfd, &preserve);
312
313 if (abfd->format != bfd_archive
314 || (bfd_has_map (abfd)
315 && bfd_get_error () != bfd_error_wrong_object_format))
316 {
317 /* This format checks out as ok! */
318 right_targ = temp;
319
320 /* If this is the default target, accept it, even if
321 other targets might match. People who want those
322 other targets have to set the GNUTARGET variable. */
323 if (temp == bfd_default_vector[0])
324 goto ok_ret;
325
326 if (matching_vector)
327 matching_vector[match_count] = temp;
328 match_count++;
329
330 if (temp->match_priority < best_match)
331 {
332 best_match = temp->match_priority;
333 best_count = 0;
334 }
335 best_count++;
336 }
337 else
338 {
339 /* An archive with no armap or objects of the wrong
340 type. We want this target to match if we get no
341 better matches. */
342 if (ar_right_targ != bfd_default_vector[0])
343 ar_right_targ = *target;
344 if (matching_vector)
345 matching_vector[ar_match_index] = *target;
346 ar_match_index++;
347 }
348
349 if (!bfd_preserve_save (abfd, &preserve))
350 goto err_ret;
351 }
352 else if (bfd_get_error () != bfd_error_wrong_format)
353 goto err_ret;
354 }
355
356 if (best_count == 1)
357 match_count = 1;
358
359 if (match_count == 0)
360 {
361 /* Try partial matches. */
362 right_targ = ar_right_targ;
363
364 if (right_targ == bfd_default_vector[0])
365 {
366 match_count = 1;
367 }
368 else
369 {
370 match_count = ar_match_index - _bfd_target_vector_entries;
371
372 if (matching_vector && match_count > 1)
373 memcpy (matching_vector,
374 matching_vector + _bfd_target_vector_entries,
375 sizeof (*matching_vector) * match_count);
376 }
377 }
378
379 /* We have more than one equally good match. If any of the best
380 matches is a target in config.bfd targ_defvec or targ_selvecs,
381 choose it. */
382 if (match_count > 1)
383 {
384 const bfd_target * const *assoc = bfd_associated_vector;
385
386 while ((right_targ = *assoc++) != NULL)
387 {
388 int i = match_count;
389
390 while (--i >= 0)
391 if (matching_vector[i] == right_targ
392 && right_targ->match_priority <= best_match)
393 break;
394
395 if (i >= 0)
396 {
397 match_count = 1;
398 break;
399 }
400 }
401 }
402
403 /* We still have more than one equally good match, and at least some
404 of the targets support match priority. Choose the first of the
405 best matches. */
406 if (match_count > 1 && best_count != match_count)
407 {
408 int i;
409
410 for (i = 0; i < match_count; i++)
411 {
412 right_targ = matching_vector[i];
413 if (right_targ->match_priority <= best_match)
414 break;
415 }
416 match_count = 1;
417 }
418
419 /* There is way too much undoing of half-known state here. We
420 really shouldn't iterate on live bfd's. Note that saving the
421 whole bfd and restoring it would be even worse; the first thing
422 you notice is that the cached bfd file position gets out of sync. */
423 if (preserve.marker != NULL)
424 bfd_preserve_restore (abfd, &preserve);
425
426 if (match_count == 1)
427 {
428 abfd->xvec = right_targ;
429 /* If we come out of the loop knowing that the last target that
430 matched is the one we want, then ABFD should still be in a usable
431 state (except possibly for XVEC). */
432 if (match_targ != right_targ)
433 {
434 bfd_reinit (abfd);
435 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
436 goto err_ret;
437 match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
438 BFD_ASSERT (match_targ != NULL);
439 }
440
441 ok_ret:
442 /* If the file was opened for update, then `output_has_begun'
443 some time ago when the file was created. Do not recompute
444 sections sizes or alignments in _bfd_set_section_contents.
445 We can not set this flag until after checking the format,
446 because it will interfere with creation of BFD sections. */
447 if (abfd->direction == both_direction)
448 abfd->output_has_begun = TRUE;
449
450 if (matching_vector)
451 free (matching_vector);
452
453 /* File position has moved, BTW. */
454 return TRUE;
455 }
456
457 if (match_count == 0)
458 {
459 err_unrecog:
460 bfd_set_error (bfd_error_file_not_recognized);
461 err_ret:
462 abfd->xvec = save_targ;
463 abfd->format = bfd_unknown;
464 if (matching_vector)
465 free (matching_vector);
466 if (preserve.marker != NULL)
467 bfd_preserve_restore (abfd, &preserve);
468 return FALSE;
469 }
470
471 /* Restore original target type and format. */
472 abfd->xvec = save_targ;
473 abfd->format = bfd_unknown;
474 bfd_set_error (bfd_error_file_ambiguously_recognized);
475
476 if (matching)
477 {
478 *matching = (char **) matching_vector;
479 matching_vector[match_count] = NULL;
480 /* Return target names. This is a little nasty. Maybe we
481 should do another bfd_malloc? */
482 while (--match_count >= 0)
483 {
484 const char *name = matching_vector[match_count]->name;
485 *(const char **) &matching_vector[match_count] = name;
486 }
487 }
488 return FALSE;
489 }
490
491 /*
492 FUNCTION
493 bfd_set_format
494
495 SYNOPSIS
496 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
497
498 DESCRIPTION
499 This function sets the file format of the BFD @var{abfd} to the
500 format @var{format}. If the target set in the BFD does not
501 support the format requested, the format is invalid, or the BFD
502 is not open for writing, then an error occurs.
503 */
504
505 bfd_boolean
506 bfd_set_format (bfd *abfd, bfd_format format)
507 {
508 if (bfd_read_p (abfd)
509 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
510 {
511 bfd_set_error (bfd_error_invalid_operation);
512 return FALSE;
513 }
514
515 if (abfd->format != bfd_unknown)
516 return abfd->format == format;
517
518 /* Presume the answer is yes. */
519 abfd->format = format;
520
521 if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
522 {
523 abfd->format = bfd_unknown;
524 return FALSE;
525 }
526
527 return TRUE;
528 }
529
530 /*
531 FUNCTION
532 bfd_format_string
533
534 SYNOPSIS
535 const char *bfd_format_string (bfd_format format);
536
537 DESCRIPTION
538 Return a pointer to a const string
539 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
540 depending upon the value of @var{format}.
541 */
542
543 const char *
544 bfd_format_string (bfd_format format)
545 {
546 if (((int) format < (int) bfd_unknown)
547 || ((int) format >= (int) bfd_type_end))
548 return "invalid";
549
550 switch (format)
551 {
552 case bfd_object:
553 return "object"; /* Linker/assembler/compiler output. */
554 case bfd_archive:
555 return "archive"; /* Object archive file. */
556 case bfd_core:
557 return "core"; /* Core dump. */
558 default:
559 return "unknown";
560 }
561 }
This page took 0.146497 seconds and 4 git commands to generate.