bfd/format.c

   1 /* Generic BFD support for file formats.
   2    Copyright (C) 1990-2024 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         bool 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         When calling bfd_check_format (or bfd_check_format_matches),
  91         any underlying file descriptor will be kept open for the
  92         duration of the call.  This is done to avoid races when
  93         another thread calls bfd_cache_close_all.  In this scenario,
  94         the thread calling bfd_check_format must call bfd_cache_close
  95         itself.
  96 */
  97
  98 bool
  99 bfd_check_format (bfd *abfd, bfd_format format)
 100 {
 101   return bfd_check_format_matches (abfd, format, NULL);
 102 }
 103
 104 struct bfd_preserve
 105 {
 106   void *marker;
 107   void *tdata;
 108   flagword flags;
 109   const struct bfd_iovec *iovec;
 110   void *iostream;
 111   const struct bfd_arch_info *arch_info;
 112   const struct bfd_build_id *build_id;
 113   bfd_cleanup cleanup;
 114   struct bfd_section *sections;
 115   struct bfd_section *section_last;
 116   unsigned int section_count;
 117   unsigned int section_id;
 118   unsigned int symcount;
 119   bool read_only;
 120   bfd_vma start_address;
 121   struct bfd_hash_table section_htab;
 122 };
 123
 124 /* When testing an object for compatibility with a particular target
 125    back-end, the back-end object_p function needs to set up certain
 126    fields in the bfd on successfully recognizing the object.  This
 127    typically happens in a piecemeal fashion, with failures possible at
 128    many points.  On failure, the bfd is supposed to be restored to its
 129    initial state, which is virtually impossible.  However, restoring a
 130    subset of the bfd state works in practice.  This function stores
 131    the subset.  */
 132
 133 static bool
 134 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve,
 135                    bfd_cleanup cleanup)
 136 {
 137   preserve->tdata = abfd->tdata.any;
 138   preserve->arch_info = abfd->arch_info;
 139   preserve->flags = abfd->flags;
 140   preserve->iovec = abfd->iovec;
 141   preserve->iostream = abfd->iostream;
 142   preserve->sections = abfd->sections;
 143   preserve->section_last = abfd->section_last;
 144   preserve->section_count = abfd->section_count;
 145   preserve->section_id = _bfd_section_id;
 146   preserve->symcount = abfd->symcount;
 147   preserve->read_only = abfd->read_only;
 148   preserve->start_address = abfd->start_address;
 149   preserve->section_htab = abfd->section_htab;
 150   preserve->marker = bfd_alloc (abfd, 1);
 151   preserve->build_id = abfd->build_id;
 152   preserve->cleanup = cleanup;
 153   if (preserve->marker == NULL)
 154     return false;
 155
 156   return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
 157                               sizeof (struct section_hash_entry));
 158 }
 159
 160 /* A back-end object_p function may flip a bfd from file backed to
 161    in-memory, eg. pe_ILF_object_p.  In that case to restore the
 162    original IO state we need to reopen the file.  Conversely, if we
 163    are restoring a previously matched pe ILF format and have been
 164    checking further target matches using file IO then we need to close
 165    the file and detach the bfd from the cache lru list.  */
 166
 167 static void
 168 io_reinit (bfd *abfd, struct bfd_preserve *preserve)
 169 {
 170   if (abfd->iovec != preserve->iovec)
 171     {
 172       /* Handle file backed to in-memory transition.  bfd_cache_close
 173          won't do anything unless abfd->iovec is the cache_iovec.
 174          Don't be tempted to call iovec->bclose here.  We don't want
 175          to call memory_bclose, which would free the bim.  The bim
 176          must be kept if bfd_check_format_matches is going to decide
 177          later that the PE format needing it is in fact the correct
 178          target match.  */
 179       bfd_cache_close (abfd);
 180       abfd->iovec = preserve->iovec;
 181       abfd->iostream = preserve->iostream;
 182
 183       /* Handle in-memory to file backed transition.  */
 184       if ((abfd->flags & BFD_CLOSED_BY_CACHE) != 0
 185           && (abfd->flags & BFD_IN_MEMORY) != 0
 186           && (preserve->flags & BFD_CLOSED_BY_CACHE) == 0
 187           && (preserve->flags & BFD_IN_MEMORY) == 0)
 188         bfd_open_file (abfd);
 189     }
 190   abfd->flags = preserve->flags;
 191 }
 192
 193 /* Clear out a subset of BFD state.  */
 194
 195 static void
 196 bfd_reinit (bfd *abfd, unsigned int section_id,
 197             struct bfd_preserve *preserve, bfd_cleanup cleanup)
 198 {
 199   _bfd_section_id = section_id;
 200   if (cleanup)
 201     cleanup (abfd);
 202   abfd->tdata.any = NULL;
 203   abfd->arch_info = &bfd_default_arch_struct;
 204   io_reinit (abfd, preserve);
 205   abfd->symcount = 0;
 206   abfd->read_only = 0;
 207   abfd->start_address = 0;
 208   abfd->build_id = NULL;
 209   bfd_section_list_clear (abfd);
 210 }
 211
 212 /* Restores bfd state saved by bfd_preserve_save.  */
 213
 214 static bfd_cleanup
 215 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
 216 {
 217   bfd_hash_table_free (&abfd->section_htab);
 218
 219   abfd->tdata.any = preserve->tdata;
 220   abfd->arch_info = preserve->arch_info;
 221   io_reinit (abfd, preserve);
 222   abfd->section_htab = preserve->section_htab;
 223   abfd->sections = preserve->sections;
 224   abfd->section_last = preserve->section_last;
 225   abfd->section_count = preserve->section_count;
 226   _bfd_section_id = preserve->section_id;
 227   abfd->symcount = preserve->symcount;
 228   abfd->read_only = preserve->read_only;
 229   abfd->start_address = preserve->start_address;
 230   abfd->build_id = preserve->build_id;
 231
 232   /* bfd_release frees all memory more recently bfd_alloc'd than
 233      its arg, as well as its arg.  */
 234   bfd_release (abfd, preserve->marker);
 235   preserve->marker = NULL;
 236   return preserve->cleanup;
 237 }
 238
 239 /* Called when the bfd state saved by bfd_preserve_save is no longer
 240    needed.  */
 241
 242 static void
 243 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
 244 {
 245   if (preserve->cleanup)
 246     {
 247       /* Run the cleanup, assuming that all it will need is the
 248          tdata at the time the cleanup was returned.  */
 249       void *tdata = abfd->tdata.any;
 250       abfd->tdata.any = preserve->tdata;
 251       preserve->cleanup (abfd);
 252       abfd->tdata.any = tdata;
 253     }
 254   /* It would be nice to be able to free more memory here, eg. old
 255      tdata, but that's not possible since these blocks are sitting
 256      inside bfd_alloc'd memory.  The section hash is on a separate
 257      objalloc.  */
 258   bfd_hash_table_free (&preserve->section_htab);
 259   preserve->marker = NULL;
 260 }
 261
 262 static void
 263 print_warnmsg (struct per_xvec_message **list)
 264 {
 265   for (struct per_xvec_message *warn = *list; warn; warn = warn->next)
 266     _bfd_error_handler ("%s", warn->message);
 267 }
 268
 269 static void
 270 clear_warnmsg (struct per_xvec_message **list)
 271 {
 272   struct per_xvec_message *warn = *list;
 273   while (warn)
 274     {
 275       struct per_xvec_message *next = warn->next;
 276       free (warn);
 277       warn = next;
 278     }
 279   *list = NULL;
 280 }
 281
 282 /* Free all the storage in LIST.  Note that the first element of LIST
 283    is special and is assumed to be stack-allocated.  TARG is used for
 284    re-issuing warning messages.  If TARG is PER_XVEC_NO_TARGET, then
 285    it acts like a sort of wildcard -- messages are only reissued if
 286    they are all associated with a single BFD target, regardless of
 287    which one it is.  If TARG is anything else, then only messages
 288    associated with TARG are emitted.  */
 289
 290 static void
 291 print_and_clear_messages (struct per_xvec_messages *list,
 292                           const bfd_target *targ)
 293 {
 294   struct per_xvec_messages *iter = list;
 295
 296   if (targ == PER_XVEC_NO_TARGET && list->next == NULL)
 297     print_warnmsg (&list->messages);
 298
 299   while (iter != NULL)
 300     {
 301       struct per_xvec_messages *next = iter->next;
 302
 303       if (iter->targ == targ)
 304         print_warnmsg (&iter->messages);
 305       clear_warnmsg (&iter->messages);
 306       if (iter != list)
 307         free (iter);
 308       iter = next;
 309     }
 310 }
 311
 312 /* This a copy of lto_section defined in GCC (lto-streamer.h).  */
 313
 314 struct lto_section
 315 {
 316   int16_t major_version;
 317   int16_t minor_version;
 318   unsigned char slim_object;
 319
 320   /* Flags is a private field that is not defined publicly.  */
 321   uint16_t flags;
 322 };
 323
 324 /* Set lto_type in ABFD.  */
 325
 326 static void
 327 bfd_set_lto_type (bfd *abfd ATTRIBUTE_UNUSED)
 328 {
 329 #if BFD_SUPPORTS_PLUGINS
 330   if (abfd->format == bfd_object
 331       && abfd->lto_type == lto_non_object
 332       && (abfd->flags & (DYNAMIC | EXEC_P)) == 0)
 333     {
 334       asection *sec;
 335       enum bfd_lto_object_type type = lto_non_ir_object;
 336       struct lto_section lsection;
 337       /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
 338          section.  */
 339       for (sec = abfd->sections; sec != NULL; sec = sec->next)
 340         if (startswith (sec->name, ".gnu.lto_.lto.")
 341             && bfd_get_section_contents (abfd, sec, &lsection, 0,
 342                                          sizeof (struct lto_section)))
 343           {
 344             if (lsection.slim_object)
 345               type = lto_slim_ir_object;
 346             else
 347               type = lto_fat_ir_object;
 348             break;
 349           }
 350
 351       abfd->lto_type = type;
 352     }
 353 #endif
 354 }
 355
 356 /*
 357 FUNCTION
 358         bfd_check_format_matches
 359
 360 SYNOPSIS
 361         bool bfd_check_format_matches
 362           (bfd *abfd, bfd_format format, char ***matching);
 363
 364 DESCRIPTION
 365         Like <<bfd_check_format>>, except when it returns FALSE with
 366         <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>.  In that
 367         case, if @var{matching} is not NULL, it will be filled in with
 368         a NULL-terminated list of the names of the formats that matched,
 369         allocated with <<malloc>>.
 370         Then the user may choose a format and try again.
 371
 372         When done with the list that @var{matching} points to, the caller
 373         should free it.
 374 */
 375
 376 bool
 377 bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 378 {
 379   extern const bfd_target binary_vec;
 380 #if BFD_SUPPORTS_PLUGINS
 381   extern const bfd_target plugin_vec;
 382 #endif
 383   const bfd_target * const *target;
 384   const bfd_target **matching_vector = NULL;
 385   const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
 386   int match_count, best_count, best_match;
 387   int ar_match_index;
 388   unsigned int initial_section_id = _bfd_section_id;
 389   struct bfd_preserve preserve, preserve_match;
 390   bfd_cleanup cleanup = NULL;
 391   struct per_xvec_messages messages = { abfd, PER_XVEC_NO_TARGET, NULL, NULL };
 392   struct per_xvec_messages *orig_messages;
 393   bool old_in_format_matches;
 394
 395   if (matching != NULL)
 396     *matching = NULL;
 397
 398   if (!bfd_read_p (abfd)
 399       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 400     {
 401       bfd_set_error (bfd_error_invalid_operation);
 402       return false;
 403     }
 404
 405   if (abfd->format != bfd_unknown)
 406     {
 407       bfd_set_lto_type (abfd);
 408       return abfd->format == format;
 409     }
 410
 411   if (matching != NULL || *bfd_associated_vector != NULL)
 412     {
 413       size_t amt;
 414
 415       amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
 416       matching_vector = (const bfd_target **) bfd_malloc (amt);
 417       if (!matching_vector)
 418         return false;
 419     }
 420
 421   /* Avoid clashes with bfd_cache_close_all running in another
 422      thread.  */
 423   if (!bfd_cache_set_uncloseable (abfd, true, &old_in_format_matches))
 424     return false;
 425
 426   /* Presume the answer is yes.  */
 427   abfd->format = format;
 428   save_targ = abfd->xvec;
 429
 430   /* Don't report errors on recursive calls checking the first element
 431      of an archive.  */
 432   orig_messages = _bfd_set_error_handler_caching (&messages);
 433
 434   preserve_match.marker = NULL;
 435   if (!bfd_preserve_save (abfd, &preserve, NULL))
 436     goto err_ret;
 437
 438   /* If the target type was explicitly specified, just check that target.  */
 439   if (!abfd->target_defaulted)
 440     {
 441       if (bfd_seek (abfd, 0, SEEK_SET) != 0)    /* rewind! */
 442         goto err_ret;
 443
 444       cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 445
 446       if (cleanup)
 447         goto ok_ret;
 448
 449       /* For a long time the code has dropped through to check all
 450          targets if the specified target was wrong.  I don't know why,
 451          and I'm reluctant to change it.  However, in the case of an
 452          archive, it can cause problems.  If the specified target does
 453          not permit archives (e.g., the binary target), then we should
 454          not allow some other target to recognize it as an archive, but
 455          should instead allow the specified target to recognize it as an
 456          object.  When I first made this change, it broke the PE target,
 457          because the specified pei-i386 target did not recognize the
 458          actual pe-i386 archive.  Since there may be other problems of
 459          this sort, I changed this test to check only for the binary
 460          target.  */
 461       if (format == bfd_archive && save_targ == &binary_vec)
 462         goto err_unrecog;
 463     }
 464
 465   /* Since the target type was defaulted, check them all in the hope
 466      that one will be uniquely recognized.  */
 467   right_targ = NULL;
 468   ar_right_targ = NULL;
 469   match_targ = NULL;
 470   best_match = 256;
 471   best_count = 0;
 472   match_count = 0;
 473   ar_match_index = _bfd_target_vector_entries;
 474
 475   for (target = bfd_target_vector; *target != NULL; target++)
 476     {
 477       void **high_water;
 478
 479       /* The binary target matches anything, so don't return it when
 480          searching.  Don't match the plugin target if we have another
 481          alternative since we want to properly set the input format
 482          before allowing a plugin to claim the file.  Also, don't
 483          check the default target twice.  */
 484       if (*target == &binary_vec
 485 #if BFD_SUPPORTS_PLUGINS
 486           || (match_count != 0 && *target == &plugin_vec)
 487 #endif
 488           || (!abfd->target_defaulted && *target == save_targ))
 489         continue;
 490
 491       /* If we already tried a match, the bfd is modified and may
 492          have sections attached, which will confuse the next
 493          _bfd_check_format call.  */
 494       bfd_reinit (abfd, initial_section_id, &preserve, cleanup);
 495       /* Free bfd_alloc memory too.  If we have matched and preserved
 496          a target then the high water mark is that much higher.  */
 497       if (preserve_match.marker)
 498         high_water = &preserve_match.marker;
 499       else
 500         high_water = &preserve.marker;
 501       bfd_release (abfd, *high_water);
 502       *high_water = bfd_alloc (abfd, 1);
 503
 504       /* Change BFD's target temporarily.  */
 505       abfd->xvec = *target;
 506
 507       if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 508         goto err_ret;
 509
 510       cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 511       if (cleanup)
 512         {
 513           int match_priority = abfd->xvec->match_priority;
 514 #if BFD_SUPPORTS_PLUGINS
 515           /* If this object can be handled by a plugin, give that the
 516              lowest priority; objects both handled by a plugin and
 517              with an underlying object format will be claimed
 518              separately by the plugin.  */
 519           if (*target == &plugin_vec)
 520             match_priority = (*target)->match_priority;
 521 #endif
 522
 523           if (abfd->format != bfd_archive
 524               || (bfd_has_map (abfd)
 525                   && bfd_get_error () != bfd_error_wrong_object_format))
 526             {
 527               /* If this is the default target, accept it, even if
 528                  other targets might match.  People who want those
 529                  other targets have to set the GNUTARGET variable.  */
 530               if (abfd->xvec == bfd_default_vector[0])
 531                 goto ok_ret;
 532
 533               if (matching_vector)
 534                 matching_vector[match_count] = abfd->xvec;
 535               match_count++;
 536
 537               if (match_priority < best_match)
 538                 {
 539                   best_match = match_priority;
 540                   best_count = 0;
 541                 }
 542               if (match_priority <= best_match)
 543                 {
 544                   /* This format checks out as ok!  */
 545                   right_targ = abfd->xvec;
 546                   best_count++;
 547                 }
 548             }
 549           else
 550             {
 551               /* An archive with no armap or objects of the wrong
 552                  type.  We want this target to match if we get no
 553                  better matches.  */
 554               if (ar_right_targ != bfd_default_vector[0])
 555                 ar_right_targ = *target;
 556               if (matching_vector)
 557                 matching_vector[ar_match_index] = *target;
 558               ar_match_index++;
 559             }
 560
 561           if (preserve_match.marker == NULL)
 562             {
 563               match_targ = abfd->xvec;
 564               if (!bfd_preserve_save (abfd, &preserve_match, cleanup))
 565                 goto err_ret;
 566               cleanup = NULL;
 567             }
 568         }
 569     }
 570
 571   if (best_count == 1)
 572     match_count = 1;
 573
 574   if (match_count == 0)
 575     {
 576       /* Try partial matches.  */
 577       right_targ = ar_right_targ;
 578
 579       if (right_targ == bfd_default_vector[0])
 580         {
 581           match_count = 1;
 582         }
 583       else
 584         {
 585           match_count = ar_match_index - _bfd_target_vector_entries;
 586
 587           if (matching_vector && match_count > 1)
 588             memcpy (matching_vector,
 589                     matching_vector + _bfd_target_vector_entries,
 590                     sizeof (*matching_vector) * match_count);
 591         }
 592     }
 593
 594   /* We have more than one equally good match.  If any of the best
 595      matches is a target in config.bfd targ_defvec or targ_selvecs,
 596      choose it.  */
 597   if (match_count > 1)
 598     {
 599       const bfd_target * const *assoc = bfd_associated_vector;
 600
 601       while ((right_targ = *assoc++) != NULL)
 602         {
 603           int i = match_count;
 604
 605           while (--i >= 0)
 606             if (matching_vector[i] == right_targ
 607                 && right_targ->match_priority <= best_match)
 608               break;
 609
 610           if (i >= 0)
 611             {
 612               match_count = 1;
 613               break;
 614             }
 615         }
 616     }
 617
 618   /* We still have more than one equally good match, and at least some
 619      of the targets support match priority.  Choose the first of the
 620      best matches.  */
 621   if (matching_vector && match_count > 1 && best_count != match_count)
 622     {
 623       int i;
 624
 625       for (i = 0; i < match_count; i++)
 626         {
 627           right_targ = matching_vector[i];
 628           if (right_targ->match_priority <= best_match)
 629             break;
 630         }
 631       match_count = 1;
 632     }
 633
 634   /* There is way too much undoing of half-known state here.  We
 635      really shouldn't iterate on live bfd's.  Note that saving the
 636      whole bfd and restoring it would be even worse; the first thing
 637      you notice is that the cached bfd file position gets out of sync.  */
 638   if (preserve_match.marker != NULL)
 639     cleanup = bfd_preserve_restore (abfd, &preserve_match);
 640
 641   if (match_count == 1)
 642     {
 643       abfd->xvec = right_targ;
 644       /* If we come out of the loop knowing that the last target that
 645          matched is the one we want, then ABFD should still be in a usable
 646          state (except possibly for XVEC).  This is not just an
 647          optimisation.  In the case of plugins a match against the
 648          plugin target can result in the bfd being changed such that
 649          it no longer matches the plugin target, nor will it match
 650          RIGHT_TARG again.  */
 651       if (match_targ != right_targ)
 652         {
 653           bfd_reinit (abfd, initial_section_id, &preserve, cleanup);
 654           bfd_release (abfd, preserve.marker);
 655           if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 656             goto err_ret;
 657           cleanup = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 658           BFD_ASSERT (cleanup != NULL);
 659         }
 660
 661     ok_ret:
 662       /* If the file was opened for update, then `output_has_begun'
 663          some time ago when the file was created.  Do not recompute
 664          sections sizes or alignments in _bfd_set_section_contents.
 665          We can not set this flag until after checking the format,
 666          because it will interfere with creation of BFD sections.  */
 667       if (abfd->direction == both_direction)
 668         abfd->output_has_begun = true;
 669
 670       free (matching_vector);
 671       if (preserve_match.marker != NULL)
 672         bfd_preserve_finish (abfd, &preserve_match);
 673       bfd_preserve_finish (abfd, &preserve);
 674       _bfd_restore_error_handler_caching (orig_messages);
 675
 676       print_and_clear_messages (&messages, abfd->xvec);
 677
 678       bfd_set_lto_type (abfd);
 679
 680       /* File position has moved, BTW.  */
 681       return bfd_cache_set_uncloseable (abfd, old_in_format_matches, NULL);
 682     }
 683
 684   if (match_count == 0)
 685     {
 686     err_unrecog:
 687       bfd_set_error (bfd_error_file_not_recognized);
 688     err_ret:
 689       if (cleanup)
 690         cleanup (abfd);
 691       abfd->xvec = save_targ;
 692       abfd->format = bfd_unknown;
 693       free (matching_vector);
 694       goto out;
 695     }
 696
 697   /* Restore original target type and format.  */
 698   abfd->xvec = save_targ;
 699   abfd->format = bfd_unknown;
 700   bfd_set_error (bfd_error_file_ambiguously_recognized);
 701
 702   if (matching)
 703     {
 704       *matching = (char **) matching_vector;
 705       matching_vector[match_count] = NULL;
 706       /* Return target names.  This is a little nasty.  Maybe we
 707          should do another bfd_malloc?  */
 708       while (--match_count >= 0)
 709         {
 710           const char *name = matching_vector[match_count]->name;
 711           *(const char **) &matching_vector[match_count] = name;
 712         }
 713     }
 714   else
 715     free (matching_vector);
 716   if (cleanup)
 717     cleanup (abfd);
 718  out:
 719   if (preserve_match.marker != NULL)
 720     bfd_preserve_finish (abfd, &preserve_match);
 721   bfd_preserve_restore (abfd, &preserve);
 722   _bfd_restore_error_handler_caching (orig_messages);
 723   print_and_clear_messages (&messages, PER_XVEC_NO_TARGET);
 724   bfd_cache_set_uncloseable (abfd, old_in_format_matches, NULL);
 725   return false;
 726 }
 727
 728 /*
 729 FUNCTION
 730         bfd_set_format
 731
 732 SYNOPSIS
 733         bool bfd_set_format (bfd *abfd, bfd_format format);
 734
 735 DESCRIPTION
 736         This function sets the file format of the BFD @var{abfd} to the
 737         format @var{format}. If the target set in the BFD does not
 738         support the format requested, the format is invalid, or the BFD
 739         is not open for writing, then an error occurs.
 740 */
 741
 742 bool
 743 bfd_set_format (bfd *abfd, bfd_format format)
 744 {
 745   if (bfd_read_p (abfd)
 746       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 747     {
 748       bfd_set_error (bfd_error_invalid_operation);
 749       return false;
 750     }
 751
 752   if (abfd->format != bfd_unknown)
 753     return abfd->format == format;
 754
 755   /* Presume the answer is yes.  */
 756   abfd->format = format;
 757
 758   if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
 759     {
 760       abfd->format = bfd_unknown;
 761       return false;
 762     }
 763
 764   return true;
 765 }
 766
 767 /*
 768 FUNCTION
 769         bfd_format_string
 770
 771 SYNOPSIS
 772         const char *bfd_format_string (bfd_format format);
 773
 774 DESCRIPTION
 775         Return a pointer to a const string
 776         <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
 777         depending upon the value of @var{format}.
 778 */
 779
 780 const char *
 781 bfd_format_string (bfd_format format)
 782 {
 783   if (((int) format < (int) bfd_unknown)
 784       || ((int) format >= (int) bfd_type_end))
 785     return "invalid";
 786
 787   switch (format)
 788     {
 789     case bfd_object:
 790       return "object";          /* Linker/assembler/compiler output.  */
 791     case bfd_archive:
 792       return "archive";         /* Object archive file.  */
 793     case bfd_core:
 794       return "core";            /* Core dump.  */
 795     default:
 796       return "unknown";
 797     }
 798 }