Update year range in copyright notice of binutils files
[deliverable/binutils-gdb.git] / bfd / format.c
1 /* Generic BFD support for file formats.
2 Copyright (C) 1990-2019 Free Software Foundation, Inc.
3 Written by Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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. */
21
22
23 /*
24 SECTION
25 File formats
26
27 A format is a BFD concept of high level file contents type. The
28 formats supported by BFD are:
29
30 o <<bfd_object>>
31
32 The BFD may contain data, symbols, relocations and debug info.
33
34 o <<bfd_archive>>
35
36 The BFD contains other BFDs and an optional index.
37
38 o <<bfd_core>>
39
40 The BFD contains the result of an executable core dump.
41
42 SUBSECTION
43 File format functions
44 */
45
46 #include "sysdep.h"
47 #include "bfd.h"
48 #include "libbfd.h"
49
50 /* IMPORT from targets.c. */
51 extern const size_t _bfd_target_vector_entries;
52
53 /*
54 FUNCTION
55 bfd_check_format
56
57 SYNOPSIS
58 bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
59
60 DESCRIPTION
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>>).
64
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.
72
73 The function returns <<TRUE>> on success, otherwise <<FALSE>>
74 with one of the following error codes:
75
76 o <<bfd_error_invalid_operation>> -
77 if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
78 <<bfd_core>>.
79
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.
83
84 o <<file_not_recognised>> -
85 none of the backends recognised the file format.
86
87 o <<bfd_error_file_ambiguously_recognized>> -
88 more than one backend recognised the file format.
89 */
90
91 bfd_boolean
92 bfd_check_format (bfd *abfd, bfd_format format)
93 {
94 return bfd_check_format_matches (abfd, format, NULL);
95 }
96
97 struct bfd_preserve
98 {
99 void *marker;
100 void *tdata;
101 flagword flags;
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;
109 };
110
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
118 the subset. */
119
120 static bfd_boolean
121 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
122 {
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)
134 return FALSE;
135
136 return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
137 sizeof (struct section_hash_entry));
138 }
139
140 /* Clear out a subset of BFD state. */
141
142 static void
143 bfd_reinit (bfd *abfd, unsigned int section_id)
144 {
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;
150 }
151
152 /* Restores bfd state saved by bfd_preserve_save. */
153
154 static void
155 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
156 {
157 bfd_hash_table_free (&abfd->section_htab);
158
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;
168
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;
173 }
174
175 /* Called when the bfd state saved by bfd_preserve_save is no longer
176 needed. */
177
178 static void
179 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
180 {
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
184 objalloc. */
185 bfd_hash_table_free (&preserve->section_htab);
186 preserve->marker = NULL;
187 }
188
189 /*
190 FUNCTION
191 bfd_check_format_matches
192
193 SYNOPSIS
194 bfd_boolean bfd_check_format_matches
195 (bfd *abfd, bfd_format format, char ***matching);
196
197 DESCRIPTION
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.
204
205 When done with the list that @var{matching} points to, the caller
206 should free it.
207 */
208
209 bfd_boolean
210 bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
211 {
212 extern const bfd_target binary_vec;
213 #if BFD_SUPPORTS_PLUGINS
214 extern const bfd_target plugin_vec;
215 #endif
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;
220 int ar_match_index;
221 unsigned int initial_section_id = _bfd_section_id;
222 struct bfd_preserve preserve;
223
224 if (matching != NULL)
225 *matching = NULL;
226
227 if (!bfd_read_p (abfd)
228 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
229 {
230 bfd_set_error (bfd_error_invalid_operation);
231 return FALSE;
232 }
233
234 if (abfd->format != bfd_unknown)
235 return abfd->format == format;
236
237 if (matching != NULL || *bfd_associated_vector != NULL)
238 {
239 bfd_size_type amt;
240
241 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
242 matching_vector = (const bfd_target **) bfd_malloc (amt);
243 if (!matching_vector)
244 return FALSE;
245 }
246
247 /* Presume the answer is yes. */
248 abfd->format = format;
249 save_targ = abfd->xvec;
250 preserve.marker = NULL;
251
252 /* If the target type was explicitly specified, just check that target. */
253 if (!abfd->target_defaulted)
254 {
255 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */
256 goto err_ret;
257
258 right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
259
260 if (right_targ)
261 goto ok_ret;
262
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
274 target. */
275 if (format == bfd_archive && save_targ == &binary_vec)
276 goto err_unrecog;
277 }
278
279 /* Since the target type was defaulted, check them all in the hope
280 that one will be uniquely recognized. */
281 right_targ = NULL;
282 ar_right_targ = NULL;
283 match_targ = NULL;
284 best_match = 256;
285 best_count = 0;
286 match_count = 0;
287 ar_match_index = _bfd_target_vector_entries;
288
289 for (target = bfd_target_vector; *target != NULL; target++)
290 {
291 const bfd_target *temp;
292
293 /* Don't check the default target twice. */
294 if (*target == &binary_vec
295 || (!abfd->target_defaulted && *target == save_targ))
296 continue;
297
298 /* If we already tried a match, the bfd is modified and may
299 have sections attached, which will confuse the next
300 _bfd_check_format call. */
301 bfd_reinit (abfd, initial_section_id);
302
303 /* Change BFD's target temporarily. */
304 abfd->xvec = *target;
305
306 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
307 goto err_ret;
308
309 /* If _bfd_check_format neglects to set bfd_error, assume
310 bfd_error_wrong_format. We didn't used to even pay any
311 attention to bfd_error, so I suspect that some
312 _bfd_check_format might have this problem. */
313 bfd_set_error (bfd_error_wrong_format);
314
315 temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
316 if (temp)
317 {
318 int match_priority = temp->match_priority;
319 #if BFD_SUPPORTS_PLUGINS
320 /* If this object can be handled by a plugin, give that the
321 lowest priority; objects both handled by a plugin and
322 with an underlying object format will be claimed
323 separately by the plugin. */
324 if (*target == &plugin_vec)
325 match_priority = (*target)->match_priority;
326 #endif
327
328 match_targ = temp;
329 if (preserve.marker != NULL)
330 bfd_preserve_finish (abfd, &preserve);
331
332 if (abfd->format != bfd_archive
333 || (bfd_has_map (abfd)
334 && bfd_get_error () != bfd_error_wrong_object_format))
335 {
336 /* If this is the default target, accept it, even if
337 other targets might match. People who want those
338 other targets have to set the GNUTARGET variable. */
339 if (temp == bfd_default_vector[0])
340 goto ok_ret;
341
342 if (matching_vector)
343 matching_vector[match_count] = temp;
344 match_count++;
345
346 if (match_priority < best_match)
347 {
348 best_match = match_priority;
349 best_count = 0;
350 }
351 if (match_priority <= best_match)
352 {
353 /* This format checks out as ok! */
354 right_targ = temp;
355 best_count++;
356 }
357 }
358 else
359 {
360 /* An archive with no armap or objects of the wrong
361 type. We want this target to match if we get no
362 better matches. */
363 if (ar_right_targ != bfd_default_vector[0])
364 ar_right_targ = *target;
365 if (matching_vector)
366 matching_vector[ar_match_index] = *target;
367 ar_match_index++;
368 }
369
370 if (!bfd_preserve_save (abfd, &preserve))
371 goto err_ret;
372 }
373 else if (bfd_get_error () != bfd_error_wrong_format)
374 goto err_ret;
375 }
376
377 if (best_count == 1)
378 match_count = 1;
379
380 if (match_count == 0)
381 {
382 /* Try partial matches. */
383 right_targ = ar_right_targ;
384
385 if (right_targ == bfd_default_vector[0])
386 {
387 match_count = 1;
388 }
389 else
390 {
391 match_count = ar_match_index - _bfd_target_vector_entries;
392
393 if (matching_vector && match_count > 1)
394 memcpy (matching_vector,
395 matching_vector + _bfd_target_vector_entries,
396 sizeof (*matching_vector) * match_count);
397 }
398 }
399
400 /* We have more than one equally good match. If any of the best
401 matches is a target in config.bfd targ_defvec or targ_selvecs,
402 choose it. */
403 if (match_count > 1)
404 {
405 const bfd_target * const *assoc = bfd_associated_vector;
406
407 while ((right_targ = *assoc++) != NULL)
408 {
409 int i = match_count;
410
411 while (--i >= 0)
412 if (matching_vector[i] == right_targ
413 && right_targ->match_priority <= best_match)
414 break;
415
416 if (i >= 0)
417 {
418 match_count = 1;
419 break;
420 }
421 }
422 }
423
424 /* We still have more than one equally good match, and at least some
425 of the targets support match priority. Choose the first of the
426 best matches. */
427 if (matching_vector && match_count > 1 && best_count != match_count)
428 {
429 int i;
430
431 for (i = 0; i < match_count; i++)
432 {
433 right_targ = matching_vector[i];
434 if (right_targ->match_priority <= best_match)
435 break;
436 }
437 match_count = 1;
438 }
439
440 /* There is way too much undoing of half-known state here. We
441 really shouldn't iterate on live bfd's. Note that saving the
442 whole bfd and restoring it would be even worse; the first thing
443 you notice is that the cached bfd file position gets out of sync. */
444 if (preserve.marker != NULL)
445 bfd_preserve_restore (abfd, &preserve);
446
447 if (match_count == 1)
448 {
449 abfd->xvec = right_targ;
450 /* If we come out of the loop knowing that the last target that
451 matched is the one we want, then ABFD should still be in a usable
452 state (except possibly for XVEC). */
453 if (match_targ != right_targ)
454 {
455 bfd_reinit (abfd, initial_section_id);
456 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
457 goto err_ret;
458 match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
459 BFD_ASSERT (match_targ != NULL);
460 }
461
462 ok_ret:
463 /* If the file was opened for update, then `output_has_begun'
464 some time ago when the file was created. Do not recompute
465 sections sizes or alignments in _bfd_set_section_contents.
466 We can not set this flag until after checking the format,
467 because it will interfere with creation of BFD sections. */
468 if (abfd->direction == both_direction)
469 abfd->output_has_begun = TRUE;
470
471 if (matching_vector)
472 free (matching_vector);
473
474 /* File position has moved, BTW. */
475 return TRUE;
476 }
477
478 if (match_count == 0)
479 {
480 err_unrecog:
481 bfd_set_error (bfd_error_file_not_recognized);
482 err_ret:
483 abfd->xvec = save_targ;
484 abfd->format = bfd_unknown;
485 if (matching_vector)
486 free (matching_vector);
487 if (preserve.marker != NULL)
488 bfd_preserve_restore (abfd, &preserve);
489 return FALSE;
490 }
491
492 /* Restore original target type and format. */
493 abfd->xvec = save_targ;
494 abfd->format = bfd_unknown;
495 bfd_set_error (bfd_error_file_ambiguously_recognized);
496
497 if (matching)
498 {
499 *matching = (char **) matching_vector;
500 matching_vector[match_count] = NULL;
501 /* Return target names. This is a little nasty. Maybe we
502 should do another bfd_malloc? */
503 while (--match_count >= 0)
504 {
505 const char *name = matching_vector[match_count]->name;
506 *(const char **) &matching_vector[match_count] = name;
507 }
508 }
509 return FALSE;
510 }
511
512 /*
513 FUNCTION
514 bfd_set_format
515
516 SYNOPSIS
517 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
518
519 DESCRIPTION
520 This function sets the file format of the BFD @var{abfd} to the
521 format @var{format}. If the target set in the BFD does not
522 support the format requested, the format is invalid, or the BFD
523 is not open for writing, then an error occurs.
524 */
525
526 bfd_boolean
527 bfd_set_format (bfd *abfd, bfd_format format)
528 {
529 if (bfd_read_p (abfd)
530 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
531 {
532 bfd_set_error (bfd_error_invalid_operation);
533 return FALSE;
534 }
535
536 if (abfd->format != bfd_unknown)
537 return abfd->format == format;
538
539 /* Presume the answer is yes. */
540 abfd->format = format;
541
542 if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
543 {
544 abfd->format = bfd_unknown;
545 return FALSE;
546 }
547
548 return TRUE;
549 }
550
551 /*
552 FUNCTION
553 bfd_format_string
554
555 SYNOPSIS
556 const char *bfd_format_string (bfd_format format);
557
558 DESCRIPTION
559 Return a pointer to a const string
560 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
561 depending upon the value of @var{format}.
562 */
563
564 const char *
565 bfd_format_string (bfd_format format)
566 {
567 if (((int) format < (int) bfd_unknown)
568 || ((int) format >= (int) bfd_type_end))
569 return "invalid";
570
571 switch (format)
572 {
573 case bfd_object:
574 return "object"; /* Linker/assembler/compiler output. */
575 case bfd_archive:
576 return "archive"; /* Object archive file. */
577 case bfd_core:
578 return "core"; /* Core dump. */
579 default:
580 return "unknown";
581 }
582 }
This page took 0.04248 seconds and 5 git commands to generate.