1/* Generic BFD support for file formats. 2 Copyright (C) 1990-2020 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/* 24SECTION 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 42SUBSECTION 43 File format functions 44*/ 45 46#include "sysdep.h" 47#include "bfd.h" 48#include "libbfd.h" 49 50/* IMPORT from targets.c. */ 51extern const size_t _bfd_target_vector_entries; 52 53/* 54FUNCTION 55 bfd_check_format 56 57SYNOPSIS 58 bfd_boolean bfd_check_format (bfd *abfd, bfd_format format); 59 60DESCRIPTION 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 91bfd_boolean 92bfd_check_format (bfd *abfd, bfd_format format) 93{ 94 return bfd_check_format_matches (abfd, format, NULL); 95} 96 97struct 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 bfd_cleanup cleanup; 110}; 111 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 119 the subset. */ 120 121static bfd_boolean 122bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve, 123 bfd_cleanup cleanup) 124{ 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) 137 return FALSE; 138 139 return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc, 140 sizeof (struct section_hash_entry)); 141} 142 143/* Clear out a subset of BFD state. */ 144 145static void 146bfd_reinit (bfd *abfd, unsigned int section_id, bfd_cleanup cleanup) 147{ 148 _bfd_section_id = section_id; 149 if (cleanup) 150 cleanup (abfd); 151 abfd->tdata.any = NULL; 152 abfd->arch_info = &bfd_default_arch_struct; 153 abfd->flags &= BFD_FLAGS_SAVED; 154 bfd_section_list_clear (abfd); 155} 156 157/* Restores bfd state saved by bfd_preserve_save. */ 158 159static bfd_cleanup 160bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve) 161{ 162 bfd_hash_table_free (&abfd->section_htab); 163 164 abfd->tdata.any = preserve->tdata; 165 abfd->arch_info = preserve->arch_info; 166 abfd->flags = preserve->flags; 167 abfd->section_htab = preserve->section_htab; 168 abfd->sections = preserve->sections; 169 abfd->section_last = preserve->section_last; 170 abfd->section_count = preserve->section_count; 171 _bfd_section_id = preserve->section_id; 172 abfd->build_id = preserve->build_id; 173 174 /* bfd_release frees all memory more recently bfd_alloc'd than 175 its arg, as well as its arg. */ 176 bfd_release (abfd, preserve->marker); 177 preserve->marker = NULL; 178 return preserve->cleanup; 179} 180 181/* Called when the bfd state saved by bfd_preserve_save is no longer 182 needed. */ 183 184static void 185bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve) 186{ 187 if (preserve->cleanup) 188 { 189 /* Run the cleanup, assuming that all it will need is the 190 tdata at the time the cleanup was returned. */ 191 void *tdata = abfd->tdata.any; 192 abfd->tdata.any = preserve->tdata; 193 preserve->cleanup (abfd); 194 abfd->tdata.any = tdata; 195 } 196 /* It would be nice to be able to free more memory here, eg. old 197 tdata, but that's not possible since these blocks are sitting 198 inside bfd_alloc'd memory. The section hash is on a separate 199 objalloc. */ 200 bfd_hash_table_free (&preserve->section_htab); 201 preserve->marker = NULL; 202} 203 204/* 205FUNCTION 206 bfd_check_format_matches 207 208SYNOPSIS 209 bfd_boolean bfd_check_format_matches 210 (bfd *abfd, bfd_format format, char ***matching); 211 212DESCRIPTION 213 Like <<bfd_check_format>>, except when it returns FALSE with 214 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that 215 case, if @var{matching} is not NULL, it will be filled in with 216 a NULL-terminated list of the names of the formats that matched, 217 allocated with <<malloc>>. 218 Then the user may choose a format and try again. 219 220 When done with the list that @var{matching} points to, the caller 221 should free it. 222*/ 223 224bfd_boolean 225bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) 226{ 227 extern const bfd_target binary_vec; 228#if BFD_SUPPORTS_PLUGINS 229 extern const bfd_target plugin_vec; 230#endif 231 const bfd_target * const *target; 232 const bfd_target **matching_vector = NULL; 233 const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ; 234 int match_count, best_count, best_match; 235 int ar_match_index; 236 unsigned int initial_section_id = _bfd_section_id; 237 struct bfd_preserve preserve, preserve_match; 238 bfd_cleanup cleanup = NULL; 239 240 if (matching != NULL) 241 *matching = NULL; 242 243 if (!bfd_read_p (abfd) 244 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end) 245 { 246 bfd_set_error (bfd_error_invalid_operation); 247 return FALSE; 248 } 249 250 if (abfd->format != bfd_unknown) 251 return abfd->format == format; 252 253 if (matching != NULL || *bfd_associated_vector != NULL) 254 { 255 size_t amt; 256 257 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries; 258 matching_vector = (const bfd_target **) bfd_malloc (amt); 259 if (!matching_vector) 260 return FALSE; 261 } 262 263 /* Presume the answer is yes. */ 264 abfd->format = format; 265 save_targ = abfd->xvec; 266 267 preserve_match.marker = NULL; 268 if (!bfd_preserve_save (abfd, &preserve, NULL)) 269 goto err_ret; 270 271 /* If the target type was explicitly specified, just check that target. */ 272 if (!abfd->target_defaulted) 273 { 274 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */ 275 goto err_ret; 276 277 cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); 278 279 if (cleanup) 280 goto ok_ret; 281 282 /* For a long time the code has dropped through to check all 283 targets if the specified target was wrong. I don't know why, 284 and I'm reluctant to change it. However, in the case of an 285 archive, it can cause problems. If the specified target does 286 not permit archives (e.g., the binary target), then we should 287 not allow some other target to recognize it as an archive, but 288 should instead allow the specified target to recognize it as an 289 object. When I first made this change, it broke the PE target, 290 because the specified pei-i386 target did not recognize the 291 actual pe-i386 archive. Since there may be other problems of 292 this sort, I changed this test to check only for the binary 293 target. */ 294 if (format == bfd_archive && save_targ == &binary_vec) 295 goto err_unrecog; 296 } 297 298 /* Since the target type was defaulted, check them all in the hope 299 that one will be uniquely recognized. */ 300 right_targ = NULL; 301 ar_right_targ = NULL; 302 match_targ = NULL; 303 best_match = 256; 304 best_count = 0; 305 match_count = 0; 306 ar_match_index = _bfd_target_vector_entries; 307 308 for (target = bfd_target_vector; *target != NULL; target++) 309 { 310 void **high_water; 311 312 /* The binary target matches anything, so don't return it when 313 searching. Don't match the plugin target if we have another 314 alternative since we want to properly set the input format 315 before allowing a plugin to claim the file. Also, don't 316 check the default target twice. */ 317 if (*target == &binary_vec 318#if BFD_SUPPORTS_PLUGINS 319 || (match_count != 0 && *target == &plugin_vec) 320#endif 321 || (!abfd->target_defaulted && *target == save_targ)) 322 continue; 323 324 /* If we already tried a match, the bfd is modified and may 325 have sections attached, which will confuse the next 326 _bfd_check_format call. */ 327 bfd_reinit (abfd, initial_section_id, cleanup); 328 /* Free bfd_alloc memory too. If we have matched and preserved 329 a target then the high water mark is that much higher. */ 330 if (preserve_match.marker) 331 high_water = &preserve_match.marker; 332 else 333 high_water = &preserve.marker; 334 bfd_release (abfd, *high_water); 335 *high_water = bfd_alloc (abfd, 1); 336 337 /* Change BFD's target temporarily. */ 338 abfd->xvec = *target; 339 340 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 341 goto err_ret; 342 343 cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); 344 if (cleanup) 345 { 346 int match_priority = abfd->xvec->match_priority; 347#if BFD_SUPPORTS_PLUGINS 348 /* If this object can be handled by a plugin, give that the 349 lowest priority; objects both handled by a plugin and 350 with an underlying object format will be claimed 351 separately by the plugin. */ 352 if (*target == &plugin_vec) 353 match_priority = (*target)->match_priority; 354#endif 355 356 if (abfd->format != bfd_archive 357 || (bfd_has_map (abfd) 358 && bfd_get_error () != bfd_error_wrong_object_format)) 359 { 360 /* If this is the default target, accept it, even if 361 other targets might match. People who want those 362 other targets have to set the GNUTARGET variable. */ 363 if (abfd->xvec == bfd_default_vector[0]) 364 goto ok_ret; 365 366 if (matching_vector) 367 matching_vector[match_count] = abfd->xvec; 368 match_count++; 369 370 if (match_priority < best_match) 371 { 372 best_match = match_priority; 373 best_count = 0; 374 } 375 if (match_priority <= best_match) 376 { 377 /* This format checks out as ok! */ 378 right_targ = abfd->xvec; 379 best_count++; 380 } 381 } 382 else 383 { 384 /* An archive with no armap or objects of the wrong 385 type. We want this target to match if we get no 386 better matches. */ 387 if (ar_right_targ != bfd_default_vector[0]) 388 ar_right_targ = *target; 389 if (matching_vector) 390 matching_vector[ar_match_index] = *target; 391 ar_match_index++; 392 } 393 394 if (preserve_match.marker == NULL) 395 { 396 match_targ = abfd->xvec; 397 if (!bfd_preserve_save (abfd, &preserve_match, cleanup)) 398 goto err_ret; 399 cleanup = NULL; 400 } 401 } 402 } 403 404 if (best_count == 1) 405 match_count = 1; 406 407 if (match_count == 0) 408 { 409 /* Try partial matches. */ 410 right_targ = ar_right_targ; 411 412 if (right_targ == bfd_default_vector[0]) 413 { 414 match_count = 1; 415 } 416 else 417 { 418 match_count = ar_match_index - _bfd_target_vector_entries; 419 420 if (matching_vector && match_count > 1) 421 memcpy (matching_vector, 422 matching_vector + _bfd_target_vector_entries, 423 sizeof (*matching_vector) * match_count); 424 } 425 } 426 427 /* We have more than one equally good match. If any of the best 428 matches is a target in config.bfd targ_defvec or targ_selvecs, 429 choose it. */ 430 if (match_count > 1) 431 { 432 const bfd_target * const *assoc = bfd_associated_vector; 433 434 while ((right_targ = *assoc++) != NULL) 435 { 436 int i = match_count; 437 438 while (--i >= 0) 439 if (matching_vector[i] == right_targ 440 && right_targ->match_priority <= best_match) 441 break; 442 443 if (i >= 0) 444 { 445 match_count = 1; 446 break; 447 } 448 } 449 } 450 451 /* We still have more than one equally good match, and at least some 452 of the targets support match priority. Choose the first of the 453 best matches. */ 454 if (matching_vector && match_count > 1 && best_count != match_count) 455 { 456 int i; 457 458 for (i = 0; i < match_count; i++) 459 { 460 right_targ = matching_vector[i]; 461 if (right_targ->match_priority <= best_match) 462 break; 463 } 464 match_count = 1; 465 } 466 467 /* There is way too much undoing of half-known state here. We 468 really shouldn't iterate on live bfd's. Note that saving the 469 whole bfd and restoring it would be even worse; the first thing 470 you notice is that the cached bfd file position gets out of sync. */ 471 if (preserve_match.marker != NULL) 472 cleanup = bfd_preserve_restore (abfd, &preserve_match); 473 474 if (match_count == 1) 475 { 476 abfd->xvec = right_targ; 477 /* If we come out of the loop knowing that the last target that 478 matched is the one we want, then ABFD should still be in a usable 479 state (except possibly for XVEC). This is not just an 480 optimisation. In the case of plugins a match against the 481 plugin target can result in the bfd being changed such that 482 it no longer matches the plugin target, nor will it match 483 RIGHT_TARG again. */ 484 if (match_targ != right_targ) 485 { 486 bfd_reinit (abfd, initial_section_id, cleanup); 487 bfd_release (abfd, preserve.marker); 488 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 489 goto err_ret; 490 cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); 491 BFD_ASSERT (cleanup != NULL); 492 } 493 494 ok_ret: 495 /* If the file was opened for update, then `output_has_begun' 496 some time ago when the file was created. Do not recompute 497 sections sizes or alignments in _bfd_set_section_contents. 498 We can not set this flag until after checking the format, 499 because it will interfere with creation of BFD sections. */ 500 if (abfd->direction == both_direction) 501 abfd->output_has_begun = TRUE; 502 503 free (matching_vector); 504 if (preserve_match.marker != NULL) 505 bfd_preserve_finish (abfd, &preserve_match); 506 bfd_preserve_finish (abfd, &preserve); 507 508 /* File position has moved, BTW. */ 509 return TRUE; 510 } 511 512 if (match_count == 0) 513 { 514 err_unrecog: 515 bfd_set_error (bfd_error_file_not_recognized); 516 err_ret: 517 if (cleanup) 518 cleanup (abfd); 519 abfd->xvec = save_targ; 520 abfd->format = bfd_unknown; 521 free (matching_vector); 522 if (preserve_match.marker != NULL) 523 bfd_preserve_finish (abfd, &preserve_match); 524 bfd_preserve_restore (abfd, &preserve); 525 return FALSE; 526 } 527 528 /* Restore original target type and format. */ 529 abfd->xvec = save_targ; 530 abfd->format = bfd_unknown; 531 bfd_set_error (bfd_error_file_ambiguously_recognized); 532 533 if (matching) 534 { 535 *matching = (char **) matching_vector; 536 matching_vector[match_count] = NULL; 537 /* Return target names. This is a little nasty. Maybe we 538 should do another bfd_malloc? */ 539 while (--match_count >= 0) 540 { 541 const char *name = matching_vector[match_count]->name; 542 *(const char **) &matching_vector[match_count] = name; 543 } 544 } 545 else 546 free (matching_vector); 547 if (cleanup) 548 cleanup (abfd); 549 if (preserve_match.marker != NULL) 550 bfd_preserve_finish (abfd, &preserve_match); 551 bfd_preserve_restore (abfd, &preserve); 552 return FALSE; 553} 554 555/* 556FUNCTION 557 bfd_set_format 558 559SYNOPSIS 560 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format); 561 562DESCRIPTION 563 This function sets the file format of the BFD @var{abfd} to the 564 format @var{format}. If the target set in the BFD does not 565 support the format requested, the format is invalid, or the BFD 566 is not open for writing, then an error occurs. 567*/ 568 569bfd_boolean 570bfd_set_format (bfd *abfd, bfd_format format) 571{ 572 if (bfd_read_p (abfd) 573 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end) 574 { 575 bfd_set_error (bfd_error_invalid_operation); 576 return FALSE; 577 } 578 579 if (abfd->format != bfd_unknown) 580 return abfd->format == format; 581 582 /* Presume the answer is yes. */ 583 abfd->format = format; 584 585 if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd))) 586 { 587 abfd->format = bfd_unknown; 588 return FALSE; 589 } 590 591 return TRUE; 592} 593 594/* 595FUNCTION 596 bfd_format_string 597 598SYNOPSIS 599 const char *bfd_format_string (bfd_format format); 600 601DESCRIPTION 602 Return a pointer to a const string 603 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>, 604 depending upon the value of @var{format}. 605*/ 606 607const char * 608bfd_format_string (bfd_format format) 609{ 610 if (((int) format < (int) bfd_unknown) 611 || ((int) format >= (int) bfd_type_end)) 612 return "invalid"; 613 614 switch (format) 615 { 616 case bfd_object: 617 return "object"; /* Linker/assembler/compiler output. */ 618 case bfd_archive: 619 return "archive"; /* Object archive file. */ 620 case bfd_core: 621 return "core"; /* Core dump. */ 622 default: 623 return "unknown"; 624 } 625} 626