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