bfd/format.c

   1 /* Generic BFD support for file formats.
   2    Copyright (C) 1990-2016 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22
  23 /*
  24 SECTION
  25         File formats
  26
  27         A format is a BFD concept of high level file contents type. The
  28         formats supported by BFD are:
  29
  30         o <<bfd_object>>
  31
  32         The BFD may contain data, symbols, relocations and debug info.
  33
  34         o <<bfd_archive>>
  35
  36         The BFD contains other BFDs and an optional index.
  37
  38         o <<bfd_core>>
  39
  40         The BFD contains the result of an executable core dump.
  41
  42 SUBSECTION
  43         File format functions
  44 */
  45
  46 #include "sysdep.h"
  47 #include "bfd.h"
  48 #include "libbfd.h"
  49
  50 /* IMPORT from targets.c.  */
  51 extern const size_t _bfd_target_vector_entries;
  52
  53 /*
  54 FUNCTION
  55         bfd_check_format
  56
  57 SYNOPSIS
  58         bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
  59
  60 DESCRIPTION
  61         Verify if the file attached to the BFD @var{abfd} is compatible
  62         with the format @var{format} (i.e., one of <<bfd_object>>,
  63         <<bfd_archive>> or <<bfd_core>>).
  64
  65         If the BFD has been set to a specific target before the
  66         call, only the named target and format combination is
  67         checked. If the target has not been set, or has been set to
  68         <<default>>, then all the known target backends is
  69         interrogated to determine a match.  If the default target
  70         matches, it is used.  If not, exactly one target must recognize
  71         the file, or an error results.
  72
  73         The function returns <<TRUE>> on success, otherwise <<FALSE>>
  74         with one of the following error codes:
  75
  76         o <<bfd_error_invalid_operation>> -
  77         if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
  78         <<bfd_core>>.
  79
  80         o <<bfd_error_system_call>> -
  81         if an error occured during a read - even some file mismatches
  82         can cause bfd_error_system_calls.
  83
  84         o <<file_not_recognised>> -
  85         none of the backends recognised the file format.
  86
  87         o <<bfd_error_file_ambiguously_recognized>> -
  88         more than one backend recognised the file format.
  89 */
  90
  91 bfd_boolean
  92 bfd_check_format (bfd *abfd, bfd_format format)
  93 {
  94   return bfd_check_format_matches (abfd, format, NULL);
  95 }
  96
  97 struct bfd_preserve
  98 {
  99   void *marker;
 100   void *tdata;
 101   flagword flags;
 102   const struct bfd_arch_info *arch_info;
 103   struct bfd_section *sections;
 104   struct bfd_section *section_last;
 105   unsigned int section_count;
 106   struct bfd_hash_table section_htab;
 107 };
 108
 109 /* When testing an object for compatibility with a particular target
 110    back-end, the back-end object_p function needs to set up certain
 111    fields in the bfd on successfully recognizing the object.  This
 112    typically happens in a piecemeal fashion, with failures possible at
 113    many points.  On failure, the bfd is supposed to be restored to its
 114    initial state, which is virtually impossible.  However, restoring a
 115    subset of the bfd state works in practice.  This function stores
 116    the subset.  */
 117
 118 static bfd_boolean
 119 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
 120 {
 121   preserve->tdata = abfd->tdata.any;
 122   preserve->arch_info = abfd->arch_info;
 123   preserve->flags = abfd->flags;
 124   preserve->sections = abfd->sections;
 125   preserve->section_last = abfd->section_last;
 126   preserve->section_count = abfd->section_count;
 127   preserve->section_htab = abfd->section_htab;
 128   preserve->marker = bfd_alloc (abfd, 1);
 129   if (preserve->marker == NULL)
 130     return FALSE;
 131
 132   return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
 133                               sizeof (struct section_hash_entry));
 134 }
 135
 136 /* Clear out a subset of BFD state.  */
 137
 138 static void
 139 bfd_reinit (bfd *abfd)
 140 {
 141   abfd->tdata.any = NULL;
 142   abfd->arch_info = &bfd_default_arch_struct;
 143   abfd->flags &= BFD_FLAGS_SAVED;
 144   bfd_section_list_clear (abfd);
 145 }
 146
 147 /* Restores bfd state saved by bfd_preserve_save.  */
 148
 149 static void
 150 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
 151 {
 152   bfd_hash_table_free (&abfd->section_htab);
 153
 154   abfd->tdata.any = preserve->tdata;
 155   abfd->arch_info = preserve->arch_info;
 156   abfd->flags = preserve->flags;
 157   abfd->section_htab = preserve->section_htab;
 158   abfd->sections = preserve->sections;
 159   abfd->section_last = preserve->section_last;
 160   abfd->section_count = preserve->section_count;
 161
 162   /* bfd_release frees all memory more recently bfd_alloc'd than
 163      its arg, as well as its arg.  */
 164   bfd_release (abfd, preserve->marker);
 165   preserve->marker = NULL;
 166 }
 167
 168 /* Called when the bfd state saved by bfd_preserve_save is no longer
 169    needed.  */
 170
 171 static void
 172 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
 173 {
 174   /* It would be nice to be able to free more memory here, eg. old
 175      tdata, but that's not possible since these blocks are sitting
 176      inside bfd_alloc'd memory.  The section hash is on a separate
 177      objalloc.  */
 178   bfd_hash_table_free (&preserve->section_htab);
 179   preserve->marker = NULL;
 180 }
 181
 182 /*
 183 FUNCTION
 184         bfd_check_format_matches
 185
 186 SYNOPSIS
 187         bfd_boolean bfd_check_format_matches
 188           (bfd *abfd, bfd_format format, char ***matching);
 189
 190 DESCRIPTION
 191         Like <<bfd_check_format>>, except when it returns FALSE with
 192         <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>.  In that
 193         case, if @var{matching} is not NULL, it will be filled in with
 194         a NULL-terminated list of the names of the formats that matched,
 195         allocated with <<malloc>>.
 196         Then the user may choose a format and try again.
 197
 198         When done with the list that @var{matching} points to, the caller
 199         should free it.
 200 */
 201
 202 bfd_boolean
 203 bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
 204 {
 205   extern const bfd_target binary_vec;
 206 #if BFD_SUPPORTS_PLUGINS
 207   extern const bfd_target plugin_vec;
 208 #endif
 209   const bfd_target * const *target;
 210   const bfd_target **matching_vector = NULL;
 211   const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
 212   int match_count, best_count, best_match;
 213   int ar_match_index;
 214   struct bfd_preserve preserve;
 215
 216   if (matching != NULL)
 217     *matching = NULL;
 218
 219   if (!bfd_read_p (abfd)
 220       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 221     {
 222       bfd_set_error (bfd_error_invalid_operation);
 223       return FALSE;
 224     }
 225
 226   if (abfd->format != bfd_unknown)
 227     return abfd->format == format;
 228
 229   if (matching != NULL || *bfd_associated_vector != NULL)
 230     {
 231       bfd_size_type amt;
 232
 233       amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
 234       matching_vector = (const bfd_target **) bfd_malloc (amt);
 235       if (!matching_vector)
 236         return FALSE;
 237     }
 238
 239   /* Presume the answer is yes.  */
 240   abfd->format = format;
 241   save_targ = abfd->xvec;
 242   preserve.marker = NULL;
 243
 244   /* If the target type was explicitly specified, just check that target.  */
 245   if (!abfd->target_defaulted)
 246     {
 247       if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */
 248         goto err_ret;
 249
 250       right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 251
 252       if (right_targ)
 253         goto ok_ret;
 254
 255       /* For a long time the code has dropped through to check all
 256          targets if the specified target was wrong.  I don't know why,
 257          and I'm reluctant to change it.  However, in the case of an
 258          archive, it can cause problems.  If the specified target does
 259          not permit archives (e.g., the binary target), then we should
 260          not allow some other target to recognize it as an archive, but
 261          should instead allow the specified target to recognize it as an
 262          object.  When I first made this change, it broke the PE target,
 263          because the specified pei-i386 target did not recognize the
 264          actual pe-i386 archive.  Since there may be other problems of
 265          this sort, I changed this test to check only for the binary
 266          target.  */
 267       if (format == bfd_archive && save_targ == &binary_vec)
 268         goto err_unrecog;
 269     }
 270
 271   /* Since the target type was defaulted, check them all in the hope
 272      that one will be uniquely recognized.  */
 273   right_targ = NULL;
 274   ar_right_targ = NULL;
 275   match_targ = NULL;
 276   best_match = 256;
 277   best_count = 0;
 278   match_count = 0;
 279   ar_match_index = _bfd_target_vector_entries;
 280
 281   for (target = bfd_target_vector; *target != NULL; target++)
 282     {
 283       const bfd_target *temp;
 284
 285       /* Don't check the default target twice.  */
 286       if (*target == &binary_vec
 287           || (!abfd->target_defaulted && *target == save_targ)
 288           || (*target)->match_priority > best_match)
 289         continue;
 290
 291       /* If we already tried a match, the bfd is modified and may
 292          have sections attached, which will confuse the next
 293          _bfd_check_format call.  */
 294       bfd_reinit (abfd);
 295
 296       /* Change BFD's target temporarily.  */
 297       abfd->xvec = *target;
 298
 299       if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 300         goto err_ret;
 301
 302       /* If _bfd_check_format neglects to set bfd_error, assume
 303          bfd_error_wrong_format.  We didn't used to even pay any
 304          attention to bfd_error, so I suspect that some
 305          _bfd_check_format might have this problem.  */
 306       bfd_set_error (bfd_error_wrong_format);
 307
 308       temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 309       if (temp)
 310         {
 311           int match_priority = temp->match_priority;
 312 #if BFD_SUPPORTS_PLUGINS
 313           /* If this object can be handled by a plugin, give that the
 314              lowest priority; objects both handled by a plugin and
 315              with an underlying object format will be claimed
 316              separately by the plugin.  */
 317           if (*target == &plugin_vec)
 318             match_priority = (*target)->match_priority;
 319 #endif
 320
 321           match_targ = temp;
 322           if (preserve.marker != NULL)
 323             bfd_preserve_finish (abfd, &preserve);
 324
 325           if (abfd->format != bfd_archive
 326               || (bfd_has_map (abfd)
 327                   && bfd_get_error () != bfd_error_wrong_object_format))
 328             {
 329               /* This format checks out as ok!  */
 330               right_targ = temp;
 331
 332               /* If this is the default target, accept it, even if
 333                  other targets might match.  People who want those
 334                  other targets have to set the GNUTARGET variable.  */
 335               if (temp == bfd_default_vector[0])
 336                 goto ok_ret;
 337
 338               if (matching_vector)
 339                 matching_vector[match_count] = temp;
 340               match_count++;
 341
 342               if (match_priority < best_match)
 343                 {
 344                   best_match = match_priority;
 345                   best_count = 0;
 346                 }
 347               best_count++;
 348             }
 349           else
 350             {
 351               /* An archive with no armap or objects of the wrong
 352                  type.  We want this target to match if we get no
 353                  better matches.  */
 354               if (ar_right_targ != bfd_default_vector[0])
 355                 ar_right_targ = *target;
 356               if (matching_vector)
 357                 matching_vector[ar_match_index] = *target;
 358               ar_match_index++;
 359             }
 360
 361           if (!bfd_preserve_save (abfd, &preserve))
 362             goto err_ret;
 363         }
 364       else if (bfd_get_error () != bfd_error_wrong_format)
 365         goto err_ret;
 366     }
 367
 368   if (best_count == 1)
 369     match_count = 1;
 370
 371   if (match_count == 0)
 372     {
 373       /* Try partial matches.  */
 374       right_targ = ar_right_targ;
 375
 376       if (right_targ == bfd_default_vector[0])
 377         {
 378           match_count = 1;
 379         }
 380       else
 381         {
 382           match_count = ar_match_index - _bfd_target_vector_entries;
 383
 384           if (matching_vector && match_count > 1)
 385             memcpy (matching_vector,
 386                     matching_vector + _bfd_target_vector_entries,
 387                     sizeof (*matching_vector) * match_count);
 388         }
 389     }
 390
 391   /* We have more than one equally good match.  If any of the best
 392      matches is a target in config.bfd targ_defvec or targ_selvecs,
 393      choose it.  */
 394   if (match_count > 1)
 395     {
 396       const bfd_target * const *assoc = bfd_associated_vector;
 397
 398       while ((right_targ = *assoc++) != NULL)
 399         {
 400           int i = match_count;
 401
 402           while (--i >= 0)
 403             if (matching_vector[i] == right_targ
 404                 && right_targ->match_priority <= best_match)
 405               break;
 406
 407           if (i >= 0)
 408             {
 409               match_count = 1;
 410               break;
 411             }
 412         }
 413     }
 414
 415   /* We still have more than one equally good match, and at least some
 416      of the targets support match priority.  Choose the first of the
 417      best matches.  */
 418   if (matching_vector && match_count > 1 && best_count != match_count)
 419     {
 420       int i;
 421
 422       for (i = 0; i < match_count; i++)
 423         {
 424           right_targ = matching_vector[i];
 425           if (right_targ->match_priority <= best_match)
 426             break;
 427         }
 428       match_count = 1;
 429     }
 430
 431   /* There is way too much undoing of half-known state here.  We
 432      really shouldn't iterate on live bfd's.  Note that saving the
 433      whole bfd and restoring it would be even worse; the first thing
 434      you notice is that the cached bfd file position gets out of sync.  */
 435   if (preserve.marker != NULL)
 436     bfd_preserve_restore (abfd, &preserve);
 437
 438   if (match_count == 1)
 439     {
 440       abfd->xvec = right_targ;
 441       /* If we come out of the loop knowing that the last target that
 442          matched is the one we want, then ABFD should still be in a usable
 443          state (except possibly for XVEC).  */
 444       if (match_targ != right_targ)
 445         {
 446           bfd_reinit (abfd);
 447           if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 448             goto err_ret;
 449           match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 450           BFD_ASSERT (match_targ != NULL);
 451         }
 452
 453     ok_ret:
 454       /* If the file was opened for update, then `output_has_begun'
 455          some time ago when the file was created.  Do not recompute
 456          sections sizes or alignments in _bfd_set_section_contents.
 457          We can not set this flag until after checking the format,
 458          because it will interfere with creation of BFD sections.  */
 459       if (abfd->direction == both_direction)
 460         abfd->output_has_begun = TRUE;
 461
 462       if (matching_vector)
 463         free (matching_vector);
 464
 465       /* File position has moved, BTW.  */
 466       return TRUE;
 467     }
 468
 469   if (match_count == 0)
 470     {
 471     err_unrecog:
 472       bfd_set_error (bfd_error_file_not_recognized);
 473     err_ret:
 474       abfd->xvec = save_targ;
 475       abfd->format = bfd_unknown;
 476       if (matching_vector)
 477         free (matching_vector);
 478       if (preserve.marker != NULL)
 479         bfd_preserve_restore (abfd, &preserve);
 480       return FALSE;
 481     }
 482
 483   /* Restore original target type and format.  */
 484   abfd->xvec = save_targ;
 485   abfd->format = bfd_unknown;
 486   bfd_set_error (bfd_error_file_ambiguously_recognized);
 487
 488   if (matching)
 489     {
 490       *matching = (char **) matching_vector;
 491       matching_vector[match_count] = NULL;
 492       /* Return target names.  This is a little nasty.  Maybe we
 493          should do another bfd_malloc?  */
 494       while (--match_count >= 0)
 495         {
 496           const char *name = matching_vector[match_count]->name;
 497           *(const char **) &matching_vector[match_count] = name;
 498         }
 499     }
 500   return FALSE;
 501 }
 502
 503 /*
 504 FUNCTION
 505         bfd_set_format
 506
 507 SYNOPSIS
 508         bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
 509
 510 DESCRIPTION
 511         This function sets the file format of the BFD @var{abfd} to the
 512         format @var{format}. If the target set in the BFD does not
 513         support the format requested, the format is invalid, or the BFD
 514         is not open for writing, then an error occurs.
 515 */
 516
 517 bfd_boolean
 518 bfd_set_format (bfd *abfd, bfd_format format)
 519 {
 520   if (bfd_read_p (abfd)
 521       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 522     {
 523       bfd_set_error (bfd_error_invalid_operation);
 524       return FALSE;
 525     }
 526
 527   if (abfd->format != bfd_unknown)
 528     return abfd->format == format;
 529
 530   /* Presume the answer is yes.  */
 531   abfd->format = format;
 532
 533   if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
 534     {
 535       abfd->format = bfd_unknown;
 536       return FALSE;
 537     }
 538
 539   return TRUE;
 540 }
 541
 542 /*
 543 FUNCTION
 544         bfd_format_string
 545
 546 SYNOPSIS
 547         const char *bfd_format_string (bfd_format format);
 548
 549 DESCRIPTION
 550         Return a pointer to a const string
 551         <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
 552         depending upon the value of @var{format}.
 553 */
 554
 555 const char *
 556 bfd_format_string (bfd_format format)
 557 {
 558   if (((int) format < (int) bfd_unknown)
 559       || ((int) format >= (int) bfd_type_end))
 560     return "invalid";
 561
 562   switch (format)
 563     {
 564     case bfd_object:
 565       return "object";          /* Linker/assembler/compiler output.  */
 566     case bfd_archive:
 567       return "archive";         /* Object archive file.  */
 568     case bfd_core:
 569       return "core";            /* Core dump.  */
 570     default:
 571       return "unknown";
 572     }
 573 }