1 /* Generic BFD support for file formats.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 A format is a BFD concept of high level file contents type. The
28 formats supported by BFD are:
32 The BFD may contain data, symbols, relocations and debug info.
36 The BFD contains other BFDs and an optional index.
40 The BFD contains the result of an executable core dump.
50 /* IMPORT from targets.c. */
51 extern const size_t _bfd_target_vector_entries
;
58 bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
61 Verify if the file attached to the BFD @var{abfd} is compatible
62 with the format @var{format} (i.e., one of <<bfd_object>>,
63 <<bfd_archive>> or <<bfd_core>>).
65 If the BFD has been set to a specific target before the
66 call, only the named target and format combination is
67 checked. If the target has not been set, or has been set to
68 <<default>>, then all the known target backends is
69 interrogated to determine a match. If the default target
70 matches, it is used. If not, exactly one target must recognize
71 the file, or an error results.
73 The function returns <<TRUE>> on success, otherwise <<FALSE>>
74 with one of the following error codes:
76 o <<bfd_error_invalid_operation>> -
77 if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
80 o <<bfd_error_system_call>> -
81 if an error occured during a read - even some file mismatches
82 can cause bfd_error_system_calls.
84 o <<file_not_recognised>> -
85 none of the backends recognised the file format.
87 o <<bfd_error_file_ambiguously_recognized>> -
88 more than one backend recognised the file format.
92 bfd_check_format (bfd
*abfd
, bfd_format format
)
94 return bfd_check_format_matches (abfd
, format
, NULL
);
102 const struct bfd_arch_info
*arch_info
;
103 struct bfd_section
*sections
;
104 struct bfd_section
*section_last
;
105 unsigned int section_count
;
106 unsigned int section_id
;
107 struct bfd_hash_table section_htab
;
108 const struct bfd_build_id
*build_id
;
111 /* When testing an object for compatibility with a particular target
112 back-end, the back-end object_p function needs to set up certain
113 fields in the bfd on successfully recognizing the object. This
114 typically happens in a piecemeal fashion, with failures possible at
115 many points. On failure, the bfd is supposed to be restored to its
116 initial state, which is virtually impossible. However, restoring a
117 subset of the bfd state works in practice. This function stores
121 bfd_preserve_save (bfd
*abfd
, struct bfd_preserve
*preserve
)
123 preserve
->tdata
= abfd
->tdata
.any
;
124 preserve
->arch_info
= abfd
->arch_info
;
125 preserve
->flags
= abfd
->flags
;
126 preserve
->sections
= abfd
->sections
;
127 preserve
->section_last
= abfd
->section_last
;
128 preserve
->section_count
= abfd
->section_count
;
129 preserve
->section_id
= _bfd_section_id
;
130 preserve
->section_htab
= abfd
->section_htab
;
131 preserve
->marker
= bfd_alloc (abfd
, 1);
132 preserve
->build_id
= abfd
->build_id
;
133 if (preserve
->marker
== NULL
)
136 return bfd_hash_table_init (&abfd
->section_htab
, bfd_section_hash_newfunc
,
137 sizeof (struct section_hash_entry
));
140 /* Clear out a subset of BFD state. */
143 bfd_reinit (bfd
*abfd
, unsigned int section_id
, bfd_cleanup cleanup
)
145 _bfd_section_id
= section_id
;
148 abfd
->tdata
.any
= NULL
;
149 abfd
->arch_info
= &bfd_default_arch_struct
;
150 abfd
->flags
&= BFD_FLAGS_SAVED
;
151 bfd_section_list_clear (abfd
);
154 /* Restores bfd state saved by bfd_preserve_save. */
157 bfd_preserve_restore (bfd
*abfd
, struct bfd_preserve
*preserve
)
159 bfd_hash_table_free (&abfd
->section_htab
);
161 abfd
->tdata
.any
= preserve
->tdata
;
162 abfd
->arch_info
= preserve
->arch_info
;
163 abfd
->flags
= preserve
->flags
;
164 abfd
->section_htab
= preserve
->section_htab
;
165 abfd
->sections
= preserve
->sections
;
166 abfd
->section_last
= preserve
->section_last
;
167 abfd
->section_count
= preserve
->section_count
;
168 _bfd_section_id
= preserve
->section_id
;
169 abfd
->build_id
= preserve
->build_id
;
171 /* bfd_release frees all memory more recently bfd_alloc'd than
172 its arg, as well as its arg. */
173 bfd_release (abfd
, preserve
->marker
);
174 preserve
->marker
= NULL
;
177 /* Called when the bfd state saved by bfd_preserve_save is no longer
181 bfd_preserve_finish (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_preserve
*preserve
)
183 /* It would be nice to be able to free more memory here, eg. old
184 tdata, but that's not possible since these blocks are sitting
185 inside bfd_alloc'd memory. The section hash is on a separate
187 bfd_hash_table_free (&preserve
->section_htab
);
188 preserve
->marker
= NULL
;
193 bfd_check_format_matches
196 bfd_boolean bfd_check_format_matches
197 (bfd *abfd, bfd_format format, char ***matching);
200 Like <<bfd_check_format>>, except when it returns FALSE with
201 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that
202 case, if @var{matching} is not NULL, it will be filled in with
203 a NULL-terminated list of the names of the formats that matched,
204 allocated with <<malloc>>.
205 Then the user may choose a format and try again.
207 When done with the list that @var{matching} points to, the caller
212 bfd_check_format_matches (bfd
*abfd
, bfd_format format
, char ***matching
)
214 extern const bfd_target binary_vec
;
215 #if BFD_SUPPORTS_PLUGINS
216 extern const bfd_target plugin_vec
;
218 const bfd_target
* const *target
;
219 const bfd_target
**matching_vector
= NULL
;
220 const bfd_target
*save_targ
, *right_targ
, *ar_right_targ
, *match_targ
;
221 int match_count
, best_count
, best_match
;
223 unsigned int initial_section_id
= _bfd_section_id
;
224 struct bfd_preserve preserve
, preserve_match
;
225 bfd_cleanup cleanup
= NULL
;
227 if (matching
!= NULL
)
230 if (!bfd_read_p (abfd
)
231 || (unsigned int) abfd
->format
>= (unsigned int) bfd_type_end
)
233 bfd_set_error (bfd_error_invalid_operation
);
237 if (abfd
->format
!= bfd_unknown
)
238 return abfd
->format
== format
;
240 if (matching
!= NULL
|| *bfd_associated_vector
!= NULL
)
244 amt
= sizeof (*matching_vector
) * 2 * _bfd_target_vector_entries
;
245 matching_vector
= (const bfd_target
**) bfd_malloc (amt
);
246 if (!matching_vector
)
250 /* Presume the answer is yes. */
251 abfd
->format
= format
;
252 save_targ
= abfd
->xvec
;
254 preserve_match
.marker
= NULL
;
255 if (!bfd_preserve_save (abfd
, &preserve
))
258 /* If the target type was explicitly specified, just check that target. */
259 if (!abfd
->target_defaulted
)
261 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0) /* rewind! */
264 cleanup
= BFD_SEND_FMT (abfd
, _bfd_check_format
, (abfd
));
269 /* For a long time the code has dropped through to check all
270 targets if the specified target was wrong. I don't know why,
271 and I'm reluctant to change it. However, in the case of an
272 archive, it can cause problems. If the specified target does
273 not permit archives (e.g., the binary target), then we should
274 not allow some other target to recognize it as an archive, but
275 should instead allow the specified target to recognize it as an
276 object. When I first made this change, it broke the PE target,
277 because the specified pei-i386 target did not recognize the
278 actual pe-i386 archive. Since there may be other problems of
279 this sort, I changed this test to check only for the binary
281 if (format
== bfd_archive
&& save_targ
== &binary_vec
)
285 /* Since the target type was defaulted, check them all in the hope
286 that one will be uniquely recognized. */
288 ar_right_targ
= NULL
;
293 ar_match_index
= _bfd_target_vector_entries
;
295 for (target
= bfd_target_vector
; *target
!= NULL
; target
++)
299 /* The binary target matches anything, so don't return it when
300 searching. Don't match the plugin target if we have another
301 alternative since we want to properly set the input format
302 before allowing a plugin to claim the file. Also, don't
303 check the default target twice. */
304 if (*target
== &binary_vec
305 #if BFD_SUPPORTS_PLUGINS
306 || (match_count
!= 0 && *target
== &plugin_vec
)
308 || (!abfd
->target_defaulted
&& *target
== save_targ
))
311 /* If we already tried a match, the bfd is modified and may
312 have sections attached, which will confuse the next
313 _bfd_check_format call. */
314 bfd_reinit (abfd
, initial_section_id
, cleanup
);
315 /* Free bfd_alloc memory too. If we have matched and preserved
316 a target then the high water mark is that much higher. */
317 if (preserve_match
.marker
)
318 high_water
= &preserve_match
.marker
;
320 high_water
= &preserve
.marker
;
321 bfd_release (abfd
, *high_water
);
322 *high_water
= bfd_alloc (abfd
, 1);
324 /* Change BFD's target temporarily. */
325 abfd
->xvec
= *target
;
327 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
330 cleanup
= BFD_SEND_FMT (abfd
, _bfd_check_format
, (abfd
));
333 int match_priority
= abfd
->xvec
->match_priority
;
334 #if BFD_SUPPORTS_PLUGINS
335 /* If this object can be handled by a plugin, give that the
336 lowest priority; objects both handled by a plugin and
337 with an underlying object format will be claimed
338 separately by the plugin. */
339 if (*target
== &plugin_vec
)
340 match_priority
= (*target
)->match_priority
;
343 if (abfd
->format
!= bfd_archive
344 || (bfd_has_map (abfd
)
345 && bfd_get_error () != bfd_error_wrong_object_format
))
347 /* If this is the default target, accept it, even if
348 other targets might match. People who want those
349 other targets have to set the GNUTARGET variable. */
350 if (abfd
->xvec
== bfd_default_vector
[0])
354 matching_vector
[match_count
] = abfd
->xvec
;
357 if (match_priority
< best_match
)
359 best_match
= match_priority
;
362 if (match_priority
<= best_match
)
364 /* This format checks out as ok! */
365 right_targ
= abfd
->xvec
;
371 /* An archive with no armap or objects of the wrong
372 type. We want this target to match if we get no
374 if (ar_right_targ
!= bfd_default_vector
[0])
375 ar_right_targ
= *target
;
377 matching_vector
[ar_match_index
] = *target
;
381 if (preserve_match
.marker
== NULL
)
383 match_targ
= abfd
->xvec
;
384 if (!bfd_preserve_save (abfd
, &preserve_match
))
393 if (match_count
== 0)
395 /* Try partial matches. */
396 right_targ
= ar_right_targ
;
398 if (right_targ
== bfd_default_vector
[0])
404 match_count
= ar_match_index
- _bfd_target_vector_entries
;
406 if (matching_vector
&& match_count
> 1)
407 memcpy (matching_vector
,
408 matching_vector
+ _bfd_target_vector_entries
,
409 sizeof (*matching_vector
) * match_count
);
413 /* We have more than one equally good match. If any of the best
414 matches is a target in config.bfd targ_defvec or targ_selvecs,
418 const bfd_target
* const *assoc
= bfd_associated_vector
;
420 while ((right_targ
= *assoc
++) != NULL
)
425 if (matching_vector
[i
] == right_targ
426 && right_targ
->match_priority
<= best_match
)
437 /* We still have more than one equally good match, and at least some
438 of the targets support match priority. Choose the first of the
440 if (matching_vector
&& match_count
> 1 && best_count
!= match_count
)
444 for (i
= 0; i
< match_count
; i
++)
446 right_targ
= matching_vector
[i
];
447 if (right_targ
->match_priority
<= best_match
)
453 /* There is way too much undoing of half-known state here. We
454 really shouldn't iterate on live bfd's. Note that saving the
455 whole bfd and restoring it would be even worse; the first thing
456 you notice is that the cached bfd file position gets out of sync. */
457 if (preserve_match
.marker
!= NULL
)
458 bfd_preserve_restore (abfd
, &preserve_match
);
460 if (match_count
== 1)
462 abfd
->xvec
= right_targ
;
463 /* If we come out of the loop knowing that the last target that
464 matched is the one we want, then ABFD should still be in a usable
465 state (except possibly for XVEC). This is not just an
466 optimisation. In the case of plugins a match against the
467 plugin target can result in the bfd being changed such that
468 it no longer matches the plugin target, nor will it match
470 if (match_targ
!= right_targ
)
472 bfd_reinit (abfd
, initial_section_id
, cleanup
);
473 bfd_release (abfd
, preserve
.marker
);
474 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
476 cleanup
= BFD_SEND_FMT (abfd
, _bfd_check_format
, (abfd
));
477 BFD_ASSERT (cleanup
!= NULL
);
481 /* If the file was opened for update, then `output_has_begun'
482 some time ago when the file was created. Do not recompute
483 sections sizes or alignments in _bfd_set_section_contents.
484 We can not set this flag until after checking the format,
485 because it will interfere with creation of BFD sections. */
486 if (abfd
->direction
== both_direction
)
487 abfd
->output_has_begun
= TRUE
;
490 free (matching_vector
);
491 if (preserve_match
.marker
!= NULL
)
492 bfd_preserve_finish (abfd
, &preserve_match
);
493 bfd_preserve_finish (abfd
, &preserve
);
495 /* File position has moved, BTW. */
499 if (match_count
== 0)
502 bfd_set_error (bfd_error_file_not_recognized
);
504 abfd
->xvec
= save_targ
;
505 abfd
->format
= bfd_unknown
;
507 free (matching_vector
);
508 if (preserve_match
.marker
!= NULL
)
509 bfd_preserve_finish (abfd
, &preserve_match
);
510 bfd_preserve_restore (abfd
, &preserve
);
514 /* Restore original target type and format. */
515 abfd
->xvec
= save_targ
;
516 abfd
->format
= bfd_unknown
;
517 bfd_set_error (bfd_error_file_ambiguously_recognized
);
521 *matching
= (char **) matching_vector
;
522 matching_vector
[match_count
] = NULL
;
523 /* Return target names. This is a little nasty. Maybe we
524 should do another bfd_malloc? */
525 while (--match_count
>= 0)
527 const char *name
= matching_vector
[match_count
]->name
;
528 *(const char **) &matching_vector
[match_count
] = name
;
531 else if (matching_vector
)
532 free (matching_vector
);
533 if (preserve_match
.marker
!= NULL
)
534 bfd_preserve_finish (abfd
, &preserve_match
);
535 bfd_preserve_restore (abfd
, &preserve
);
544 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
547 This function sets the file format of the BFD @var{abfd} to the
548 format @var{format}. If the target set in the BFD does not
549 support the format requested, the format is invalid, or the BFD
550 is not open for writing, then an error occurs.
554 bfd_set_format (bfd
*abfd
, bfd_format format
)
556 if (bfd_read_p (abfd
)
557 || (unsigned int) abfd
->format
>= (unsigned int) bfd_type_end
)
559 bfd_set_error (bfd_error_invalid_operation
);
563 if (abfd
->format
!= bfd_unknown
)
564 return abfd
->format
== format
;
566 /* Presume the answer is yes. */
567 abfd
->format
= format
;
569 if (!BFD_SEND_FMT (abfd
, _bfd_set_format
, (abfd
)))
571 abfd
->format
= bfd_unknown
;
583 const char *bfd_format_string (bfd_format format);
586 Return a pointer to a const string
587 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
588 depending upon the value of @var{format}.
592 bfd_format_string (bfd_format format
)
594 if (((int) format
< (int) bfd_unknown
)
595 || ((int) format
>= (int) bfd_type_end
))
601 return "object"; /* Linker/assembler/compiler output. */
603 return "archive"; /* Object archive file. */
605 return "core"; /* Core dump. */