bfd/format.c

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