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 /* 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, preserve_match; 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 251 preserve_match.marker = NULL; 252 if (!bfd_preserve_save (abfd, &preserve)) 253 goto err_ret; 254 255 /* If the target type was explicitly specified, just check that target. */ 256 if (!abfd->target_defaulted) 257 { 258 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */ 259 goto err_ret; 260 261 right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); 262 263 if (right_targ) 264 goto ok_ret; 265 266 /* For a long time the code has dropped through to check all 267 targets if the specified target was wrong. I don't know why, 268 and I'm reluctant to change it. However, in the case of an 269 archive, it can cause problems. If the specified target does 270 not permit archives (e.g., the binary target), then we should 271 not allow some other target to recognize it as an archive, but 272 should instead allow the specified target to recognize it as an 273 object. When I first made this change, it broke the PE target, 274 because the specified pei-i386 target did not recognize the 275 actual pe-i386 archive. Since there may be other problems of 276 this sort, I changed this test to check only for the binary 277 target. */ 278 if (format == bfd_archive && save_targ == &binary_vec) 279 goto err_unrecog; 280 } 281 282 /* Since the target type was defaulted, check them all in the hope 283 that one will be uniquely recognized. */ 284 right_targ = NULL; 285 ar_right_targ = NULL; 286 match_targ = NULL; 287 best_match = 256; 288 best_count = 0; 289 match_count = 0; 290 ar_match_index = _bfd_target_vector_entries; 291 292 for (target = bfd_target_vector; *target != NULL; target++) 293 { 294 const bfd_target *temp; 295 void **high_water; 296 297 /* The binary target matches anything, so don't return it when 298 searching. Don't match the plugin target if we have another 299 alternative since we want to properly set the input format 300 before allowing a plugin to claim the file. Also, don't 301 check the default target twice. */ 302 if (*target == &binary_vec 303 #if BFD_SUPPORTS_PLUGINS 304 || (match_count != 0 && *target == &plugin_vec) 305 #endif 306 || (!abfd->target_defaulted && *target == save_targ)) 307 continue; 308 309 /* If we already tried a match, the bfd is modified and may 310 have sections attached, which will confuse the next 311 _bfd_check_format call. */ 312 bfd_reinit (abfd, initial_section_id); 313 /* Free bfd_alloc memory too. If we have matched and preserved 314 a target then the high water mark is that much higher. */ 315 if (preserve_match.marker) 316 high_water = &preserve_match.marker; 317 else 318 high_water = &preserve.marker; 319 bfd_release (abfd, *high_water); 320 *high_water = bfd_alloc (abfd, 1); 321 322 /* Change BFD's target temporarily. */ 323 abfd->xvec = *target; 324 325 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 326 goto err_ret; 327 328 temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); 329 if (temp) 330 { 331 int match_priority = temp->match_priority; 332 #if BFD_SUPPORTS_PLUGINS 333 /* If this object can be handled by a plugin, give that the 334 lowest priority; objects both handled by a plugin and 335 with an underlying object format will be claimed 336 separately by the plugin. */ 337 if (*target == &plugin_vec) 338 match_priority = (*target)->match_priority; 339 #endif 340 341 if (abfd->format != bfd_archive 342 || (bfd_has_map (abfd) 343 && bfd_get_error () != bfd_error_wrong_object_format)) 344 { 345 /* If this is the default target, accept it, even if 346 other targets might match. People who want those 347 other targets have to set the GNUTARGET variable. */ 348 if (temp == bfd_default_vector[0]) 349 goto ok_ret; 350 351 if (matching_vector) 352 matching_vector[match_count] = temp; 353 match_count++; 354 355 if (match_priority < best_match) 356 { 357 best_match = match_priority; 358 best_count = 0; 359 } 360 if (match_priority <= best_match) 361 { 362 /* This format checks out as ok! */ 363 right_targ = temp; 364 best_count++; 365 } 366 } 367 else 368 { 369 /* An archive with no armap or objects of the wrong 370 type. We want this target to match if we get no 371 better matches. */ 372 if (ar_right_targ != bfd_default_vector[0]) 373 ar_right_targ = *target; 374 if (matching_vector) 375 matching_vector[ar_match_index] = *target; 376 ar_match_index++; 377 } 378 379 if (preserve_match.marker == NULL) 380 { 381 match_targ = temp; 382 if (!bfd_preserve_save (abfd, &preserve_match)) 383 goto err_ret; 384 } 385 } 386 } 387 388 if (best_count == 1) 389 match_count = 1; 390 391 if (match_count == 0) 392 { 393 /* Try partial matches. */ 394 right_targ = ar_right_targ; 395 396 if (right_targ == bfd_default_vector[0]) 397 { 398 match_count = 1; 399 } 400 else 401 { 402 match_count = ar_match_index - _bfd_target_vector_entries; 403 404 if (matching_vector && match_count > 1) 405 memcpy (matching_vector, 406 matching_vector + _bfd_target_vector_entries, 407 sizeof (*matching_vector) * match_count); 408 } 409 } 410 411 /* We have more than one equally good match. If any of the best 412 matches is a target in config.bfd targ_defvec or targ_selvecs, 413 choose it. */ 414 if (match_count > 1) 415 { 416 const bfd_target * const *assoc = bfd_associated_vector; 417 418 while ((right_targ = *assoc++) != NULL) 419 { 420 int i = match_count; 421 422 while (--i >= 0) 423 if (matching_vector[i] == right_targ 424 && right_targ->match_priority <= best_match) 425 break; 426 427 if (i >= 0) 428 { 429 match_count = 1; 430 break; 431 } 432 } 433 } 434 435 /* We still have more than one equally good match, and at least some 436 of the targets support match priority. Choose the first of the 437 best matches. */ 438 if (matching_vector && match_count > 1 && best_count != match_count) 439 { 440 int i; 441 442 for (i = 0; i < match_count; i++) 443 { 444 right_targ = matching_vector[i]; 445 if (right_targ->match_priority <= best_match) 446 break; 447 } 448 match_count = 1; 449 } 450 451 /* There is way too much undoing of half-known state here. We 452 really shouldn't iterate on live bfd's. Note that saving the 453 whole bfd and restoring it would be even worse; the first thing 454 you notice is that the cached bfd file position gets out of sync. */ 455 if (preserve_match.marker != NULL) 456 bfd_preserve_restore (abfd, &preserve_match); 457 458 if (match_count == 1) 459 { 460 abfd->xvec = right_targ; 461 /* If we come out of the loop knowing that the last target that 462 matched is the one we want, then ABFD should still be in a usable 463 state (except possibly for XVEC). This is not just an 464 optimisation. In the case of plugins a match against the 465 plugin target can result in the bfd being changed such that 466 it no longer matches the plugin target, nor will it match 467 RIGHT_TARG again. */ 468 if (match_targ != right_targ) 469 { 470 bfd_reinit (abfd, initial_section_id); 471 bfd_release (abfd, preserve.marker); 472 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 473 goto err_ret; 474 match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); 475 BFD_ASSERT (match_targ != NULL); 476 } 477 478 ok_ret: 479 /* If the file was opened for update, then `output_has_begun' 480 some time ago when the file was created. Do not recompute 481 sections sizes or alignments in _bfd_set_section_contents. 482 We can not set this flag until after checking the format, 483 because it will interfere with creation of BFD sections. */ 484 if (abfd->direction == both_direction) 485 abfd->output_has_begun = TRUE; 486 487 if (matching_vector) 488 free (matching_vector); 489 if (preserve_match.marker != NULL) 490 bfd_preserve_finish (abfd, &preserve_match); 491 bfd_preserve_finish (abfd, &preserve); 492 493 /* File position has moved, BTW. */ 494 return TRUE; 495 } 496 497 if (match_count == 0) 498 { 499 err_unrecog: 500 bfd_set_error (bfd_error_file_not_recognized); 501 err_ret: 502 abfd->xvec = save_targ; 503 abfd->format = bfd_unknown; 504 if (matching_vector) 505 free (matching_vector); 506 if (preserve_match.marker != NULL) 507 bfd_preserve_finish (abfd, &preserve_match); 508 bfd_preserve_restore (abfd, &preserve); 509 return FALSE; 510 } 511 512 /* Restore original target type and format. */ 513 abfd->xvec = save_targ; 514 abfd->format = bfd_unknown; 515 bfd_set_error (bfd_error_file_ambiguously_recognized); 516 517 if (matching) 518 { 519 *matching = (char **) matching_vector; 520 matching_vector[match_count] = NULL; 521 /* Return target names. This is a little nasty. Maybe we 522 should do another bfd_malloc? */ 523 while (--match_count >= 0) 524 { 525 const char *name = matching_vector[match_count]->name; 526 *(const char **) &matching_vector[match_count] = name; 527 } 528 } 529 else if (matching_vector) 530 free (matching_vector); 531 if (preserve_match.marker != NULL) 532 bfd_preserve_finish (abfd, &preserve_match); 533 bfd_preserve_restore (abfd, &preserve); 534 return FALSE; 535 } 536 537 /* 538 FUNCTION 539 bfd_set_format 540 541 SYNOPSIS 542 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format); 543 544 DESCRIPTION 545 This function sets the file format of the BFD @var{abfd} to the 546 format @var{format}. If the target set in the BFD does not 547 support the format requested, the format is invalid, or the BFD 548 is not open for writing, then an error occurs. 549 */ 550 551 bfd_boolean 552 bfd_set_format (bfd *abfd, bfd_format format) 553 { 554 if (bfd_read_p (abfd) 555 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end) 556 { 557 bfd_set_error (bfd_error_invalid_operation); 558 return FALSE; 559 } 560 561 if (abfd->format != bfd_unknown) 562 return abfd->format == format; 563 564 /* Presume the answer is yes. */ 565 abfd->format = format; 566 567 if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd))) 568 { 569 abfd->format = bfd_unknown; 570 return FALSE; 571 } 572 573 return TRUE; 574 } 575 576 /* 577 FUNCTION 578 bfd_format_string 579 580 SYNOPSIS 581 const char *bfd_format_string (bfd_format format); 582 583 DESCRIPTION 584 Return a pointer to a const string 585 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>, 586 depending upon the value of @var{format}. 587 */ 588 589 const char * 590 bfd_format_string (bfd_format format) 591 { 592 if (((int) format < (int) bfd_unknown) 593 || ((int) format >= (int) bfd_type_end)) 594 return "invalid"; 595 596 switch (format) 597 { 598 case bfd_object: 599 return "object"; /* Linker/assembler/compiler output. */ 600 case bfd_archive: 601 return "archive"; /* Object archive file. */ 602 case bfd_core: 603 return "core"; /* Core dump. */ 604 default: 605 return "unknown"; 606 } 607 } 608