bfd/format.c

   1 /* Generic BFD support for file formats.
   2    Copyright (C) 1990-2014 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   const bfd_target * const *target;
 207   const bfd_target **matching_vector = NULL;
 208   const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
 209   int match_count, best_count, best_match;
 210   int ar_match_index;
 211   struct bfd_preserve preserve;
 212
 213   if (matching != NULL)
 214     *matching = NULL;
 215
 216   if (!bfd_read_p (abfd)
 217       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 218     {
 219       bfd_set_error (bfd_error_invalid_operation);
 220       return FALSE;
 221     }
 222
 223   if (abfd->format != bfd_unknown)
 224     return abfd->format == format;
 225
 226   if (matching != NULL || *bfd_associated_vector != NULL)
 227     {
 228       bfd_size_type amt;
 229
 230       amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
 231       matching_vector = (const bfd_target **) bfd_malloc (amt);
 232       if (!matching_vector)
 233         return FALSE;
 234     }
 235
 236   /* Presume the answer is yes.  */
 237   abfd->format = format;
 238   save_targ = abfd->xvec;
 239   preserve.marker = NULL;
 240
 241   /* If the target type was explicitly specified, just check that target.  */
 242   if (!abfd->target_defaulted)
 243     {
 244       if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */
 245         goto err_ret;
 246
 247       right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 248
 249       if (right_targ)
 250         goto ok_ret;
 251
 252       /* For a long time the code has dropped through to check all
 253          targets if the specified target was wrong.  I don't know why,
 254          and I'm reluctant to change it.  However, in the case of an
 255          archive, it can cause problems.  If the specified target does
 256          not permit archives (e.g., the binary target), then we should
 257          not allow some other target to recognize it as an archive, but
 258          should instead allow the specified target to recognize it as an
 259          object.  When I first made this change, it broke the PE target,
 260          because the specified pei-i386 target did not recognize the
 261          actual pe-i386 archive.  Since there may be other problems of
 262          this sort, I changed this test to check only for the binary
 263          target.  */
 264       if (format == bfd_archive && save_targ == &binary_vec)
 265         goto err_unrecog;
 266     }
 267
 268   /* Since the target type was defaulted, check them all in the hope
 269      that one will be uniquely recognized.  */
 270   right_targ = NULL;
 271   ar_right_targ = NULL;
 272   match_targ = NULL;
 273   best_match = 256;
 274   best_count = 0;
 275   match_count = 0;
 276   ar_match_index = _bfd_target_vector_entries;
 277
 278   for (target = bfd_target_vector; *target != NULL; target++)
 279     {
 280       const bfd_target *temp;
 281
 282       /* Don't check the default target twice.  */
 283       if (*target == &binary_vec
 284           || (!abfd->target_defaulted && *target == save_targ)
 285           || (*target)->match_priority > best_match)
 286         continue;
 287
 288       /* If we already tried a match, the bfd is modified and may
 289          have sections attached, which will confuse the next
 290          _bfd_check_format call.  */
 291       bfd_reinit (abfd);
 292
 293       /* Change BFD's target temporarily.  */
 294       abfd->xvec = *target;
 295
 296       if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 297         goto err_ret;
 298
 299       /* If _bfd_check_format neglects to set bfd_error, assume
 300          bfd_error_wrong_format.  We didn't used to even pay any
 301          attention to bfd_error, so I suspect that some
 302          _bfd_check_format might have this problem.  */
 303       bfd_set_error (bfd_error_wrong_format);
 304
 305       temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 306       if (temp)
 307         {
 308           match_targ = temp;
 309           if (preserve.marker != NULL)
 310             bfd_preserve_finish (abfd, &preserve);
 311
 312           if (abfd->format != bfd_archive
 313               || (bfd_has_map (abfd)
 314                   && bfd_get_error () != bfd_error_wrong_object_format))
 315             {
 316               /* This format checks out as ok!  */
 317               right_targ = temp;
 318
 319               /* If this is the default target, accept it, even if
 320                  other targets might match.  People who want those
 321                  other targets have to set the GNUTARGET variable.  */
 322               if (temp == bfd_default_vector[0])
 323                 goto ok_ret;
 324
 325               if (matching_vector)
 326                 matching_vector[match_count] = temp;
 327               match_count++;
 328
 329               if (temp->match_priority < best_match)
 330                 {
 331                   best_match = temp->match_priority;
 332                   best_count = 0;
 333                 }
 334               best_count++;
 335             }
 336           else
 337             {
 338               /* An archive with no armap or objects of the wrong
 339                  type.  We want this target to match if we get no
 340                  better matches.  */
 341               if (ar_right_targ != bfd_default_vector[0])
 342                 ar_right_targ = *target;
 343               if (matching_vector)
 344                 matching_vector[ar_match_index] = *target;
 345               ar_match_index++;
 346             }
 347
 348           if (!bfd_preserve_save (abfd, &preserve))
 349             goto err_ret;
 350         }
 351       else if (bfd_get_error () != bfd_error_wrong_format)
 352         goto err_ret;
 353     }
 354
 355   if (best_count == 1)
 356     match_count = 1;
 357
 358   if (match_count == 0)
 359     {
 360       /* Try partial matches.  */
 361       right_targ = ar_right_targ;
 362
 363       if (right_targ == bfd_default_vector[0])
 364         {
 365           match_count = 1;
 366         }
 367       else
 368         {
 369           match_count = ar_match_index - _bfd_target_vector_entries;
 370
 371           if (matching_vector && match_count > 1)
 372             memcpy (matching_vector,
 373                     matching_vector + _bfd_target_vector_entries,
 374                     sizeof (*matching_vector) * match_count);
 375         }
 376     }
 377
 378   /* We have more than one equally good match.  If any of the best
 379      matches is a target in config.bfd targ_defvec or targ_selvecs,
 380      choose it.  */
 381   if (match_count > 1)
 382     {
 383       const bfd_target * const *assoc = bfd_associated_vector;
 384
 385       while ((right_targ = *assoc++) != NULL)
 386         {
 387           int i = match_count;
 388
 389           while (--i >= 0)
 390             if (matching_vector[i] == right_targ
 391                 && right_targ->match_priority <= best_match)
 392               break;
 393
 394           if (i >= 0)
 395             {
 396               match_count = 1;
 397               break;
 398             }
 399         }
 400     }
 401
 402   /* We still have more than one equally good match, and at least some
 403      of the targets support match priority.  Choose the first of the
 404      best matches.  */
 405   if (matching_vector && match_count > 1 && best_count != match_count)
 406     {
 407       int i;
 408
 409       for (i = 0; i < match_count; i++)
 410         {
 411           right_targ = matching_vector[i];
 412           if (right_targ->match_priority <= best_match)
 413             break;
 414         }
 415       match_count = 1;
 416     }
 417
 418   /* There is way too much undoing of half-known state here.  We
 419      really shouldn't iterate on live bfd's.  Note that saving the
 420      whole bfd and restoring it would be even worse; the first thing
 421      you notice is that the cached bfd file position gets out of sync.  */
 422   if (preserve.marker != NULL)
 423     bfd_preserve_restore (abfd, &preserve);
 424
 425   if (match_count == 1)
 426     {
 427       abfd->xvec = right_targ;
 428       /* If we come out of the loop knowing that the last target that
 429          matched is the one we want, then ABFD should still be in a usable
 430          state (except possibly for XVEC).  */
 431       if (match_targ != right_targ)
 432         {
 433           bfd_reinit (abfd);
 434           if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 435             goto err_ret;
 436           match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 437           BFD_ASSERT (match_targ != NULL);
 438         }
 439
 440     ok_ret:
 441       /* If the file was opened for update, then `output_has_begun'
 442          some time ago when the file was created.  Do not recompute
 443          sections sizes or alignments in _bfd_set_section_contents.
 444          We can not set this flag until after checking the format,
 445          because it will interfere with creation of BFD sections.  */
 446       if (abfd->direction == both_direction)
 447         abfd->output_has_begun = TRUE;
 448
 449       if (matching_vector)
 450         free (matching_vector);
 451
 452       /* File position has moved, BTW.  */
 453       return TRUE;
 454     }
 455
 456   if (match_count == 0)
 457     {
 458     err_unrecog:
 459       bfd_set_error (bfd_error_file_not_recognized);
 460     err_ret:
 461       abfd->xvec = save_targ;
 462       abfd->format = bfd_unknown;
 463       if (matching_vector)
 464         free (matching_vector);
 465       if (preserve.marker != NULL)
 466         bfd_preserve_restore (abfd, &preserve);
 467       return FALSE;
 468     }
 469
 470   /* Restore original target type and format.  */
 471   abfd->xvec = save_targ;
 472   abfd->format = bfd_unknown;
 473   bfd_set_error (bfd_error_file_ambiguously_recognized);
 474
 475   if (matching)
 476     {
 477       *matching = (char **) matching_vector;
 478       matching_vector[match_count] = NULL;
 479       /* Return target names.  This is a little nasty.  Maybe we
 480          should do another bfd_malloc?  */
 481       while (--match_count >= 0)
 482         {
 483           const char *name = matching_vector[match_count]->name;
 484           *(const char **) &matching_vector[match_count] = name;
 485         }
 486     }
 487   return FALSE;
 488 }
 489
 490 /*
 491 FUNCTION
 492         bfd_set_format
 493
 494 SYNOPSIS
 495         bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
 496
 497 DESCRIPTION
 498         This function sets the file format of the BFD @var{abfd} to the
 499         format @var{format}. If the target set in the BFD does not
 500         support the format requested, the format is invalid, or the BFD
 501         is not open for writing, then an error occurs.
 502 */
 503
 504 bfd_boolean
 505 bfd_set_format (bfd *abfd, bfd_format format)
 506 {
 507   if (bfd_read_p (abfd)
 508       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 509     {
 510       bfd_set_error (bfd_error_invalid_operation);
 511       return FALSE;
 512     }
 513
 514   if (abfd->format != bfd_unknown)
 515     return abfd->format == format;
 516
 517   /* Presume the answer is yes.  */
 518   abfd->format = format;
 519
 520   if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
 521     {
 522       abfd->format = bfd_unknown;
 523       return FALSE;
 524     }
 525
 526   return TRUE;
 527 }
 528
 529 /*
 530 FUNCTION
 531         bfd_format_string
 532
 533 SYNOPSIS
 534         const char *bfd_format_string (bfd_format format);
 535
 536 DESCRIPTION
 537         Return a pointer to a const string
 538         <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
 539         depending upon the value of @var{format}.
 540 */
 541
 542 const char *
 543 bfd_format_string (bfd_format format)
 544 {
 545   if (((int) format < (int) bfd_unknown)
 546       || ((int) format >= (int) bfd_type_end))
 547     return "invalid";
 548
 549   switch (format)
 550     {
 551     case bfd_object:
 552       return "object";          /* Linker/assembler/compiler output.  */
 553     case bfd_archive:
 554       return "archive";         /* Object archive file.  */
 555     case bfd_core:
 556       return "core";            /* Core dump.  */
 557     default:
 558       return "unknown";
 559     }
 560 }