1 /* Generic BFD support for file formats.
2 Copyright (C) 1990-2019 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)
145 abfd->tdata.any = NULL;
146 abfd->arch_info = &bfd_default_arch_struct;
147 abfd->flags &= BFD_FLAGS_SAVED;
148 bfd_section_list_clear (abfd);
149 _bfd_section_id = section_id;
152 /* Restores bfd state saved by bfd_preserve_save. */
155 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
157 bfd_hash_table_free (&abfd->section_htab);
159 abfd->tdata.any = preserve->tdata;
160 abfd->arch_info = preserve->arch_info;
161 abfd->flags = preserve->flags;
162 abfd->section_htab = preserve->section_htab;
163 abfd->sections = preserve->sections;
164 abfd->section_last = preserve->section_last;
165 abfd->section_count = preserve->section_count;
166 _bfd_section_id = preserve->section_id;
167 abfd->build_id = preserve->build_id;
169 /* bfd_release frees all memory more recently bfd_alloc'd than
170 its arg, as well as its arg. */
171 bfd_release (abfd, preserve->marker);
172 preserve->marker = NULL;
175 /* Called when the bfd state saved by bfd_preserve_save is no longer
179 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
181 /* It would be nice to be able to free more memory here, eg. old
182 tdata, but that's not possible since these blocks are sitting
183 inside bfd_alloc'd memory. The section hash is on a separate
185 bfd_hash_table_free (&preserve->section_htab);
186 preserve->marker = NULL;
191 bfd_check_format_matches
194 bfd_boolean bfd_check_format_matches
195 (bfd *abfd, bfd_format format, char ***matching);
198 Like <<bfd_check_format>>, except when it returns FALSE with
199 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that
200 case, if @var{matching} is not NULL, it will be filled in with
201 a NULL-terminated list of the names of the formats that matched,
202 allocated with <<malloc>>.
203 Then the user may choose a format and try again.
205 When done with the list that @var{matching} points to, the caller
210 bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
212 extern const bfd_target binary_vec;
213 #if BFD_SUPPORTS_PLUGINS
214 extern const bfd_target plugin_vec;
216 const bfd_target * const *target;
217 const bfd_target **matching_vector = NULL;
218 const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
219 int match_count, best_count, best_match;
221 unsigned int initial_section_id = _bfd_section_id;
222 struct bfd_preserve preserve;
224 if (matching != NULL)
227 if (!bfd_read_p (abfd)
228 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
230 bfd_set_error (bfd_error_invalid_operation);
234 if (abfd->format != bfd_unknown)
235 return abfd->format == format;
237 if (matching != NULL || *bfd_associated_vector != NULL)
241 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
242 matching_vector = (const bfd_target **) bfd_malloc (amt);
243 if (!matching_vector)
247 /* Presume the answer is yes. */
248 abfd->format = format;
249 save_targ = abfd->xvec;
250 preserve.marker = NULL;
252 /* If the target type was explicitly specified, just check that target. */
253 if (!abfd->target_defaulted)
255 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */
258 right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
263 /* For a long time the code has dropped through to check all
264 targets if the specified target was wrong. I don't know why,
265 and I'm reluctant to change it. However, in the case of an
266 archive, it can cause problems. If the specified target does
267 not permit archives (e.g., the binary target), then we should
268 not allow some other target to recognize it as an archive, but
269 should instead allow the specified target to recognize it as an
270 object. When I first made this change, it broke the PE target,
271 because the specified pei-i386 target did not recognize the
272 actual pe-i386 archive. Since there may be other problems of
273 this sort, I changed this test to check only for the binary
275 if (format == bfd_archive && save_targ == &binary_vec)
279 /* Since the target type was defaulted, check them all in the hope
280 that one will be uniquely recognized. */
282 ar_right_targ = NULL;
287 ar_match_index = _bfd_target_vector_entries;
289 for (target = bfd_target_vector; *target != NULL; target++)
291 const bfd_target *temp;
293 /* The binary target matches anything, so don't return it when
294 searching. Don't match the plugin target if we have another
295 alternative since we want to properly set the input format
296 before allowing a plugin to claim the file. Also, don't
297 check the default target twice. */
298 if (*target == &binary_vec
299 #if BFD_SUPPORTS_PLUGINS
300 || (match_count != 0 && *target == &plugin_vec)
302 || (!abfd->target_defaulted && *target == save_targ))
305 /* If we already tried a match, the bfd is modified and may
306 have sections attached, which will confuse the next
307 _bfd_check_format call. */
308 bfd_reinit (abfd, initial_section_id);
310 /* Change BFD's target temporarily. */
311 abfd->xvec = *target;
313 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
316 /* If _bfd_check_format neglects to set bfd_error, assume
317 bfd_error_wrong_format. We didn't used to even pay any
318 attention to bfd_error, so I suspect that some
319 _bfd_check_format might have this problem. */
320 bfd_set_error (bfd_error_wrong_format);
322 temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
325 int match_priority = temp->match_priority;
326 #if BFD_SUPPORTS_PLUGINS
327 /* If this object can be handled by a plugin, give that the
328 lowest priority; objects both handled by a plugin and
329 with an underlying object format will be claimed
330 separately by the plugin. */
331 if (*target == &plugin_vec)
332 match_priority = (*target)->match_priority;
336 if (preserve.marker != NULL)
337 bfd_preserve_finish (abfd, &preserve);
339 if (abfd->format != bfd_archive
340 || (bfd_has_map (abfd)
341 && bfd_get_error () != bfd_error_wrong_object_format))
343 /* If this is the default target, accept it, even if
344 other targets might match. People who want those
345 other targets have to set the GNUTARGET variable. */
346 if (temp == bfd_default_vector[0])
350 matching_vector[match_count] = temp;
353 if (match_priority < best_match)
355 best_match = match_priority;
358 if (match_priority <= best_match)
360 /* This format checks out as ok! */
367 /* An archive with no armap or objects of the wrong
368 type. We want this target to match if we get no
370 if (ar_right_targ != bfd_default_vector[0])
371 ar_right_targ = *target;
373 matching_vector[ar_match_index] = *target;
377 if (!bfd_preserve_save (abfd, &preserve))
380 else if (bfd_get_error () != bfd_error_wrong_format)
387 if (match_count == 0)
389 /* Try partial matches. */
390 right_targ = ar_right_targ;
392 if (right_targ == bfd_default_vector[0])
398 match_count = ar_match_index - _bfd_target_vector_entries;
400 if (matching_vector && match_count > 1)
401 memcpy (matching_vector,
402 matching_vector + _bfd_target_vector_entries,
403 sizeof (*matching_vector) * match_count);
407 /* We have more than one equally good match. If any of the best
408 matches is a target in config.bfd targ_defvec or targ_selvecs,
412 const bfd_target * const *assoc = bfd_associated_vector;
414 while ((right_targ = *assoc++) != NULL)
419 if (matching_vector[i] == right_targ
420 && right_targ->match_priority <= best_match)
431 /* We still have more than one equally good match, and at least some
432 of the targets support match priority. Choose the first of the
434 if (matching_vector && match_count > 1 && best_count != match_count)
438 for (i = 0; i < match_count; i++)
440 right_targ = matching_vector[i];
441 if (right_targ->match_priority <= best_match)
447 /* There is way too much undoing of half-known state here. We
448 really shouldn't iterate on live bfd's. Note that saving the
449 whole bfd and restoring it would be even worse; the first thing
450 you notice is that the cached bfd file position gets out of sync. */
451 if (preserve.marker != NULL)
452 bfd_preserve_restore (abfd, &preserve);
454 if (match_count == 1)
456 abfd->xvec = right_targ;
457 /* If we come out of the loop knowing that the last target that
458 matched is the one we want, then ABFD should still be in a usable
459 state (except possibly for XVEC). */
460 if (match_targ != right_targ)
462 bfd_reinit (abfd, initial_section_id);
463 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
465 match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
466 BFD_ASSERT (match_targ != NULL);
470 /* If the file was opened for update, then `output_has_begun'
471 some time ago when the file was created. Do not recompute
472 sections sizes or alignments in _bfd_set_section_contents.
473 We can not set this flag until after checking the format,
474 because it will interfere with creation of BFD sections. */
475 if (abfd->direction == both_direction)
476 abfd->output_has_begun = TRUE;
479 free (matching_vector);
481 /* File position has moved, BTW. */
485 if (match_count == 0)
488 bfd_set_error (bfd_error_file_not_recognized);
490 abfd->xvec = save_targ;
491 abfd->format = bfd_unknown;
493 free (matching_vector);
494 if (preserve.marker != NULL)
495 bfd_preserve_restore (abfd, &preserve);
499 /* Restore original target type and format. */
500 abfd->xvec = save_targ;
501 abfd->format = bfd_unknown;
502 bfd_set_error (bfd_error_file_ambiguously_recognized);
506 *matching = (char **) matching_vector;
507 matching_vector[match_count] = NULL;
508 /* Return target names. This is a little nasty. Maybe we
509 should do another bfd_malloc? */
510 while (--match_count >= 0)
512 const char *name = matching_vector[match_count]->name;
513 *(const char **) &matching_vector[match_count] = name;
524 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
527 This function sets the file format of the BFD @var{abfd} to the
528 format @var{format}. If the target set in the BFD does not
529 support the format requested, the format is invalid, or the BFD
530 is not open for writing, then an error occurs.
534 bfd_set_format (bfd *abfd, bfd_format format)
536 if (bfd_read_p (abfd)
537 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
539 bfd_set_error (bfd_error_invalid_operation);
543 if (abfd->format != bfd_unknown)
544 return abfd->format == format;
546 /* Presume the answer is yes. */
547 abfd->format = format;
549 if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
551 abfd->format = bfd_unknown;
563 const char *bfd_format_string (bfd_format format);
566 Return a pointer to a const string
567 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
568 depending upon the value of @var{format}.
572 bfd_format_string (bfd_format format)
574 if (((int) format < (int) bfd_unknown)
575 || ((int) format >= (int) bfd_type_end))
581 return "object"; /* Linker/assembler/compiler output. */
583 return "archive"; /* Object archive file. */
585 return "core"; /* Core dump. */