1 /* Generic BFD support for file formats.
2 Copyright (C) 1990-2023 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 bool 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
;
112 /* When testing an object for compatibility with a particular target
113 back-end, the back-end object_p function needs to set up certain
114 fields in the bfd on successfully recognizing the object. This
115 typically happens in a piecemeal fashion, with failures possible at
116 many points. On failure, the bfd is supposed to be restored to its
117 initial state, which is virtually impossible. However, restoring a
118 subset of the bfd state works in practice. This function stores
122 bfd_preserve_save (bfd
*abfd
, struct bfd_preserve
*preserve
,
125 preserve
->tdata
= abfd
->tdata
.any
;
126 preserve
->arch_info
= abfd
->arch_info
;
127 preserve
->flags
= abfd
->flags
;
128 preserve
->sections
= abfd
->sections
;
129 preserve
->section_last
= abfd
->section_last
;
130 preserve
->section_count
= abfd
->section_count
;
131 preserve
->section_id
= _bfd_section_id
;
132 preserve
->section_htab
= abfd
->section_htab
;
133 preserve
->marker
= bfd_alloc (abfd
, 1);
134 preserve
->build_id
= abfd
->build_id
;
135 preserve
->cleanup
= cleanup
;
136 if (preserve
->marker
== NULL
)
139 return bfd_hash_table_init (&abfd
->section_htab
, bfd_section_hash_newfunc
,
140 sizeof (struct section_hash_entry
));
143 /* Clear out a subset of BFD state. */
146 bfd_reinit (bfd
*abfd
, unsigned int section_id
, bfd_cleanup cleanup
)
148 _bfd_section_id
= section_id
;
151 abfd
->tdata
.any
= NULL
;
152 abfd
->arch_info
= &bfd_default_arch_struct
;
153 abfd
->flags
&= BFD_FLAGS_SAVED
;
154 abfd
->build_id
= NULL
;
155 bfd_section_list_clear (abfd
);
158 /* Restores bfd state saved by bfd_preserve_save. */
161 bfd_preserve_restore (bfd
*abfd
, struct bfd_preserve
*preserve
)
163 bfd_hash_table_free (&abfd
->section_htab
);
165 abfd
->tdata
.any
= preserve
->tdata
;
166 abfd
->arch_info
= preserve
->arch_info
;
167 abfd
->flags
= preserve
->flags
;
168 abfd
->section_htab
= preserve
->section_htab
;
169 abfd
->sections
= preserve
->sections
;
170 abfd
->section_last
= preserve
->section_last
;
171 abfd
->section_count
= preserve
->section_count
;
172 _bfd_section_id
= preserve
->section_id
;
173 abfd
->build_id
= preserve
->build_id
;
175 /* bfd_release frees all memory more recently bfd_alloc'd than
176 its arg, as well as its arg. */
177 bfd_release (abfd
, preserve
->marker
);
178 preserve
->marker
= NULL
;
179 return preserve
->cleanup
;
182 /* Called when the bfd state saved by bfd_preserve_save is no longer
186 bfd_preserve_finish (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_preserve
*preserve
)
188 if (preserve
->cleanup
)
190 /* Run the cleanup, assuming that all it will need is the
191 tdata at the time the cleanup was returned. */
192 void *tdata
= abfd
->tdata
.any
;
193 abfd
->tdata
.any
= preserve
->tdata
;
194 preserve
->cleanup (abfd
);
195 abfd
->tdata
.any
= tdata
;
197 /* It would be nice to be able to free more memory here, eg. old
198 tdata, but that's not possible since these blocks are sitting
199 inside bfd_alloc'd memory. The section hash is on a separate
201 bfd_hash_table_free (&preserve
->section_htab
);
202 preserve
->marker
= NULL
;
206 print_warnmsg (struct per_xvec_message
**list
)
209 fprintf (stderr
, "%s: ", _bfd_get_error_program_name ());
211 for (struct per_xvec_message
*warn
= *list
; warn
; warn
= warn
->next
)
213 fputs (warn
->message
, stderr
);
214 fputc ('\n', stderr
);
220 clear_warnmsg (struct per_xvec_message
**list
)
222 struct per_xvec_message
*warn
= *list
;
225 struct per_xvec_message
*next
= warn
->next
;
233 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
234 va_list ap ATTRIBUTE_UNUSED
)
240 bfd_check_format_matches
243 bool bfd_check_format_matches
244 (bfd *abfd, bfd_format format, char ***matching);
247 Like <<bfd_check_format>>, except when it returns FALSE with
248 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that
249 case, if @var{matching} is not NULL, it will be filled in with
250 a NULL-terminated list of the names of the formats that matched,
251 allocated with <<malloc>>.
252 Then the user may choose a format and try again.
254 When done with the list that @var{matching} points to, the caller
259 bfd_check_format_matches (bfd
*abfd
, bfd_format format
, char ***matching
)
261 extern const bfd_target binary_vec
;
262 #if BFD_SUPPORTS_PLUGINS
263 extern const bfd_target plugin_vec
;
265 const bfd_target
* const *target
;
266 const bfd_target
**matching_vector
= NULL
;
267 const bfd_target
*save_targ
, *right_targ
, *ar_right_targ
, *match_targ
;
268 int match_count
, best_count
, best_match
;
270 unsigned int initial_section_id
= _bfd_section_id
;
271 struct bfd_preserve preserve
, preserve_match
;
272 bfd_cleanup cleanup
= NULL
;
273 bfd_error_handler_type orig_error_handler
;
274 static int in_check_format
;
276 if (matching
!= NULL
)
279 if (!bfd_read_p (abfd
)
280 || (unsigned int) abfd
->format
>= (unsigned int) bfd_type_end
)
282 bfd_set_error (bfd_error_invalid_operation
);
286 if (abfd
->format
!= bfd_unknown
)
287 return abfd
->format
== format
;
289 if (matching
!= NULL
|| *bfd_associated_vector
!= NULL
)
293 amt
= sizeof (*matching_vector
) * 2 * _bfd_target_vector_entries
;
294 matching_vector
= (const bfd_target
**) bfd_malloc (amt
);
295 if (!matching_vector
)
299 /* Presume the answer is yes. */
300 abfd
->format
= format
;
301 save_targ
= abfd
->xvec
;
303 /* Don't report errors on recursive calls checking the first element
306 orig_error_handler
= bfd_set_error_handler (null_error_handler
);
308 orig_error_handler
= _bfd_set_error_handler_caching (abfd
);
311 preserve_match
.marker
= NULL
;
312 if (!bfd_preserve_save (abfd
, &preserve
, NULL
))
315 /* If the target type was explicitly specified, just check that target. */
316 if (!abfd
->target_defaulted
)
318 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0) /* rewind! */
321 cleanup
= BFD_SEND_FMT (abfd
, _bfd_check_format
, (abfd
));
326 /* For a long time the code has dropped through to check all
327 targets if the specified target was wrong. I don't know why,
328 and I'm reluctant to change it. However, in the case of an
329 archive, it can cause problems. If the specified target does
330 not permit archives (e.g., the binary target), then we should
331 not allow some other target to recognize it as an archive, but
332 should instead allow the specified target to recognize it as an
333 object. When I first made this change, it broke the PE target,
334 because the specified pei-i386 target did not recognize the
335 actual pe-i386 archive. Since there may be other problems of
336 this sort, I changed this test to check only for the binary
338 if (format
== bfd_archive
&& save_targ
== &binary_vec
)
342 /* Since the target type was defaulted, check them all in the hope
343 that one will be uniquely recognized. */
345 ar_right_targ
= NULL
;
350 ar_match_index
= _bfd_target_vector_entries
;
352 for (target
= bfd_target_vector
; *target
!= NULL
; target
++)
356 /* The binary target matches anything, so don't return it when
357 searching. Don't match the plugin target if we have another
358 alternative since we want to properly set the input format
359 before allowing a plugin to claim the file. Also, don't
360 check the default target twice. */
361 if (*target
== &binary_vec
362 #if BFD_SUPPORTS_PLUGINS
363 || (match_count
!= 0 && *target
== &plugin_vec
)
365 || (!abfd
->target_defaulted
&& *target
== save_targ
))
368 /* If we already tried a match, the bfd is modified and may
369 have sections attached, which will confuse the next
370 _bfd_check_format call. */
371 bfd_reinit (abfd
, initial_section_id
, cleanup
);
372 /* Free bfd_alloc memory too. If we have matched and preserved
373 a target then the high water mark is that much higher. */
374 if (preserve_match
.marker
)
375 high_water
= &preserve_match
.marker
;
377 high_water
= &preserve
.marker
;
378 bfd_release (abfd
, *high_water
);
379 *high_water
= bfd_alloc (abfd
, 1);
381 /* Change BFD's target temporarily. */
382 abfd
->xvec
= *target
;
384 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
387 cleanup
= BFD_SEND_FMT (abfd
, _bfd_check_format
, (abfd
));
390 int match_priority
= abfd
->xvec
->match_priority
;
391 #if BFD_SUPPORTS_PLUGINS
392 /* If this object can be handled by a plugin, give that the
393 lowest priority; objects both handled by a plugin and
394 with an underlying object format will be claimed
395 separately by the plugin. */
396 if (*target
== &plugin_vec
)
397 match_priority
= (*target
)->match_priority
;
400 if (abfd
->format
!= bfd_archive
401 || (bfd_has_map (abfd
)
402 && bfd_get_error () != bfd_error_wrong_object_format
))
404 /* If this is the default target, accept it, even if
405 other targets might match. People who want those
406 other targets have to set the GNUTARGET variable. */
407 if (abfd
->xvec
== bfd_default_vector
[0])
411 matching_vector
[match_count
] = abfd
->xvec
;
414 if (match_priority
< best_match
)
416 best_match
= match_priority
;
419 if (match_priority
<= best_match
)
421 /* This format checks out as ok! */
422 right_targ
= abfd
->xvec
;
428 /* An archive with no armap or objects of the wrong
429 type. We want this target to match if we get no
431 if (ar_right_targ
!= bfd_default_vector
[0])
432 ar_right_targ
= *target
;
434 matching_vector
[ar_match_index
] = *target
;
438 if (preserve_match
.marker
== NULL
)
440 match_targ
= abfd
->xvec
;
441 if (!bfd_preserve_save (abfd
, &preserve_match
, cleanup
))
451 if (match_count
== 0)
453 /* Try partial matches. */
454 right_targ
= ar_right_targ
;
456 if (right_targ
== bfd_default_vector
[0])
462 match_count
= ar_match_index
- _bfd_target_vector_entries
;
464 if (matching_vector
&& match_count
> 1)
465 memcpy (matching_vector
,
466 matching_vector
+ _bfd_target_vector_entries
,
467 sizeof (*matching_vector
) * match_count
);
471 /* We have more than one equally good match. If any of the best
472 matches is a target in config.bfd targ_defvec or targ_selvecs,
476 const bfd_target
* const *assoc
= bfd_associated_vector
;
478 while ((right_targ
= *assoc
++) != NULL
)
483 if (matching_vector
[i
] == right_targ
484 && right_targ
->match_priority
<= best_match
)
495 /* We still have more than one equally good match, and at least some
496 of the targets support match priority. Choose the first of the
498 if (matching_vector
&& match_count
> 1 && best_count
!= match_count
)
502 for (i
= 0; i
< match_count
; i
++)
504 right_targ
= matching_vector
[i
];
505 if (right_targ
->match_priority
<= best_match
)
511 /* There is way too much undoing of half-known state here. We
512 really shouldn't iterate on live bfd's. Note that saving the
513 whole bfd and restoring it would be even worse; the first thing
514 you notice is that the cached bfd file position gets out of sync. */
515 if (preserve_match
.marker
!= NULL
)
516 cleanup
= bfd_preserve_restore (abfd
, &preserve_match
);
518 if (match_count
== 1)
520 abfd
->xvec
= right_targ
;
521 /* If we come out of the loop knowing that the last target that
522 matched is the one we want, then ABFD should still be in a usable
523 state (except possibly for XVEC). This is not just an
524 optimisation. In the case of plugins a match against the
525 plugin target can result in the bfd being changed such that
526 it no longer matches the plugin target, nor will it match
528 if (match_targ
!= right_targ
)
530 bfd_reinit (abfd
, initial_section_id
, cleanup
);
531 bfd_release (abfd
, preserve
.marker
);
532 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
534 cleanup
= BFD_SEND_FMT (abfd
, _bfd_check_format
, (abfd
));
535 BFD_ASSERT (cleanup
!= NULL
);
539 /* If the file was opened for update, then `output_has_begun'
540 some time ago when the file was created. Do not recompute
541 sections sizes or alignments in _bfd_set_section_contents.
542 We can not set this flag until after checking the format,
543 because it will interfere with creation of BFD sections. */
544 if (abfd
->direction
== both_direction
)
545 abfd
->output_has_begun
= true;
547 free (matching_vector
);
548 if (preserve_match
.marker
!= NULL
)
549 bfd_preserve_finish (abfd
, &preserve_match
);
550 bfd_preserve_finish (abfd
, &preserve
);
551 bfd_set_error_handler (orig_error_handler
);
553 struct per_xvec_message
**list
= _bfd_per_xvec_warn (abfd
->xvec
, 0);
555 print_warnmsg (list
);
556 list
= _bfd_per_xvec_warn (NULL
, 0);
557 for (size_t i
= 0; i
< _bfd_target_vector_entries
+ 1; i
++)
558 clear_warnmsg (list
++);
561 /* File position has moved, BTW. */
565 if (match_count
== 0)
568 bfd_set_error (bfd_error_file_not_recognized
);
572 abfd
->xvec
= save_targ
;
573 abfd
->format
= bfd_unknown
;
574 free (matching_vector
);
578 /* Restore original target type and format. */
579 abfd
->xvec
= save_targ
;
580 abfd
->format
= bfd_unknown
;
581 bfd_set_error (bfd_error_file_ambiguously_recognized
);
585 *matching
= (char **) matching_vector
;
586 matching_vector
[match_count
] = NULL
;
587 /* Return target names. This is a little nasty. Maybe we
588 should do another bfd_malloc? */
589 while (--match_count
>= 0)
591 const char *name
= matching_vector
[match_count
]->name
;
592 *(const char **) &matching_vector
[match_count
] = name
;
596 free (matching_vector
);
600 if (preserve_match
.marker
!= NULL
)
601 bfd_preserve_finish (abfd
, &preserve_match
);
602 bfd_preserve_restore (abfd
, &preserve
);
603 bfd_set_error_handler (orig_error_handler
);
604 struct per_xvec_message
**list
= _bfd_per_xvec_warn (NULL
, 0);
605 struct per_xvec_message
**one
= NULL
;
606 for (size_t i
= 0; i
< _bfd_target_vector_entries
+ 1; i
++)
621 for (size_t i
= 0; i
< _bfd_target_vector_entries
+ 1; i
++)
622 clear_warnmsg (list
++);
632 bool bfd_set_format (bfd *abfd, bfd_format format);
635 This function sets the file format of the BFD @var{abfd} to the
636 format @var{format}. If the target set in the BFD does not
637 support the format requested, the format is invalid, or the BFD
638 is not open for writing, then an error occurs.
642 bfd_set_format (bfd
*abfd
, bfd_format format
)
644 if (bfd_read_p (abfd
)
645 || (unsigned int) abfd
->format
>= (unsigned int) bfd_type_end
)
647 bfd_set_error (bfd_error_invalid_operation
);
651 if (abfd
->format
!= bfd_unknown
)
652 return abfd
->format
== format
;
654 /* Presume the answer is yes. */
655 abfd
->format
= format
;
657 if (!BFD_SEND_FMT (abfd
, _bfd_set_format
, (abfd
)))
659 abfd
->format
= bfd_unknown
;
671 const char *bfd_format_string (bfd_format format);
674 Return a pointer to a const string
675 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
676 depending upon the value of @var{format}.
680 bfd_format_string (bfd_format format
)
682 if (((int) format
< (int) bfd_unknown
)
683 || ((int) format
>= (int) bfd_type_end
))
689 return "object"; /* Linker/assembler/compiler output. */
691 return "archive"; /* Object archive file. */
693 return "core"; /* Core dump. */