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