bfd/format.c

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