bfd/format.c

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