bfd/format.c

   1 /* Generic BFD support for file formats.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4    Written by Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /*
  23 SECTION
  24         File formats
  25
  26         A format is a BFD concept of high level file contents type. The
  27         formats supported by BFD are:
  28
  29         o <<bfd_object>>
  30
  31         The BFD may contain data, symbols, relocations and debug info.
  32
  33         o <<bfd_archive>>
  34
  35         The BFD contains other BFDs and an optional index.
  36
  37         o <<bfd_core>>
  38
  39         The BFD contains the result of an executable core dump.
  40
  41 */
  42
  43 #include "bfd.h"
  44 #include "sysdep.h"
  45 #include "libbfd.h"
  46
  47 /* IMPORT from targets.c.  */
  48 extern const size_t _bfd_target_vector_entries;
  49
  50 /*
  51 FUNCTION
  52         bfd_check_format
  53
  54 SYNOPSIS
  55         boolean bfd_check_format(bfd *abfd, bfd_format format);
  56
  57 DESCRIPTION
  58         Verify if the file attached to the BFD @var{abfd} is compatible
  59         with the format @var{format} (i.e., one of <<bfd_object>>,
  60         <<bfd_archive>> or <<bfd_core>>).
  61
  62         If the BFD has been set to a specific target before the
  63         call, only the named target and format combination is
  64         checked. If the target has not been set, or has been set to
  65         <<default>>, then all the known target backends is
  66         interrogated to determine a match.  If the default target
  67         matches, it is used.  If not, exactly one target must recognize
  68         the file, or an error results.
  69
  70         The function returns <<true>> on success, otherwise <<false>>
  71         with one of the following error codes:
  72
  73         o <<bfd_error_invalid_operation>> -
  74         if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
  75         <<bfd_core>>.
  76
  77         o <<bfd_error_system_call>> -
  78         if an error occured during a read - even some file mismatches
  79         can cause bfd_error_system_calls.
  80
  81         o <<file_not_recognised>> -
  82         none of the backends recognised the file format.
  83
  84         o <<bfd_error_file_ambiguously_recognized>> -
  85         more than one backend recognised the file format.
  86 */
  87
  88 boolean
  89 bfd_check_format (abfd, format)
  90      bfd *abfd;
  91      bfd_format format;
  92 {
  93   return bfd_check_format_matches (abfd, format, NULL);
  94 }
  95
  96 /*
  97 FUNCTION
  98         bfd_check_format_matches
  99
 100 SYNOPSIS
 101         boolean bfd_check_format_matches(bfd *abfd, bfd_format format, char ***matching);
 102
 103 DESCRIPTION
 104         Like <<bfd_check_format>>, except when it returns false with
 105         <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>.  In that
 106         case, if @var{matching} is not NULL, it will be filled in with
 107         a NULL-terminated list of the names of the formats that matched,
 108         allocated with <<malloc>>.
 109         Then the user may choose a format and try again.
 110
 111         When done with the list that @var{matching} points to, the caller
 112         should free it.
 113 */
 114
 115 boolean
 116 bfd_check_format_matches (abfd, format, matching)
 117      bfd *abfd;
 118      bfd_format format;
 119      char ***matching;
 120 {
 121   extern const bfd_target binary_vec;
 122   const bfd_target * const *target, *save_targ, *right_targ, *ar_right_targ;
 123   char **matching_vector = NULL;
 124   int match_count;
 125   int ar_match_index;
 126
 127   if (!bfd_read_p (abfd)
 128       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 129     {
 130       bfd_set_error (bfd_error_invalid_operation);
 131       return false;
 132     }
 133
 134   if (abfd->format != bfd_unknown)
 135     return abfd->format == format;
 136
 137   /* Since the target type was defaulted, check them
 138      all in the hope that one will be uniquely recognized.  */
 139   save_targ = abfd->xvec;
 140   match_count = 0;
 141   ar_match_index = _bfd_target_vector_entries;
 142
 143   if (matching)
 144     {
 145       *matching = NULL;
 146       matching_vector =
 147         (char **) bfd_malloc (sizeof (char *)
 148                               * 2 * _bfd_target_vector_entries);
 149       if (!matching_vector)
 150         return false;
 151     }
 152
 153   right_targ = 0;
 154   ar_right_targ = 0;
 155
 156   /* Presume the answer is yes.  */
 157   abfd->format = format;
 158
 159   /* If the target type was explicitly specified, just check that target.  */
 160   if (!abfd->target_defaulted)
 161     {
 162       if (bfd_seek (abfd, (file_ptr)0, SEEK_SET) != 0)  /* rewind! */
 163         return false;
 164
 165       right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 166
 167       if (right_targ)
 168         {
 169           abfd->xvec = right_targ;      /* Set the target as returned.  */
 170
 171           if (matching)
 172             free (matching_vector);
 173
 174           return true;                  /* File position has moved, BTW.  */
 175         }
 176
 177       /* For a long time the code has dropped through to check all
 178          targets if the specified target was wrong.  I don't know why,
 179          and I'm reluctant to change it.  However, in the case of an
 180          archive, it can cause problems.  If the specified target does
 181          not permit archives (e.g., the binary target), then we should
 182          not allow some other target to recognize it as an archive, but
 183          should instead allow the specified target to recognize it as an
 184          object.  When I first made this change, it broke the PE target,
 185          because the specified pei-i386 target did not recognize the
 186          actual pe-i386 archive.  Since there may be other problems of
 187          this sort, I changed this test to check only for the binary
 188          target.  */
 189       if (format == bfd_archive && save_targ == &binary_vec)
 190         {
 191           abfd->xvec = save_targ;
 192           abfd->format = bfd_unknown;
 193
 194           if (matching)
 195             free (matching_vector);
 196
 197           bfd_set_error (bfd_error_file_not_recognized);
 198
 199           return false;
 200         }
 201     }
 202
 203   for (target = bfd_target_vector; *target != NULL; target++)
 204     {
 205       const bfd_target *temp;
 206       bfd_error_type err;
 207
 208       if (*target == &binary_vec)
 209         continue;
 210
 211       abfd->xvec = *target;     /* Change BFD's target temporarily */
 212
 213       if (bfd_seek (abfd, (file_ptr)0, SEEK_SET) != 0)
 214         return false;
 215
 216       /* If _bfd_check_format neglects to set bfd_error, assume
 217          bfd_error_wrong_format.  We didn't used to even pay any
 218          attention to bfd_error, so I suspect that some
 219          _bfd_check_format might have this problem.  */
 220       bfd_set_error (bfd_error_wrong_format);
 221
 222       temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 223
 224       if (temp)
 225         {               /* This format checks out as ok!  */
 226           right_targ = temp;
 227
 228           /* If this is the default target, accept it, even if other
 229              targets might match.  People who want those other targets
 230              have to set the GNUTARGET variable.  */
 231           if (temp == bfd_default_vector[0])
 232             {
 233               match_count = 1;
 234               break;
 235             }
 236
 237           if (matching)
 238             matching_vector[match_count] = temp->name;
 239
 240           match_count++;
 241
 242 #ifdef GNU960
 243           /* Big- and little-endian b.out archives look the same, but it
 244              doesn't matter: there is no difference in their headers, and
 245              member file byte orders will (I hope) be handled appropriately
 246              by bfd.  Ditto for big and little coff archives.  And the 4
 247              coff/b.out object formats are unambiguous.  So accept the
 248              first match we find.  */
 249           break;
 250 #endif
 251         }
 252       else if ((err = bfd_get_error ()) == bfd_error_wrong_object_format
 253                || err == bfd_error_file_ambiguously_recognized)
 254         {
 255           /* An archive with objects of the wrong type, or an
 256              ambiguous match.  We want this target to match if we get
 257              no better matches.  */
 258           if (ar_right_targ != bfd_default_vector[0])
 259             ar_right_targ = *target;
 260           if (matching)
 261             matching_vector[ar_match_index] = (*target)->name;
 262           ar_match_index++;
 263         }
 264       else if (err != bfd_error_wrong_format)
 265         {
 266           abfd->xvec = save_targ;
 267           abfd->format = bfd_unknown;
 268
 269           if (matching)
 270             free (matching_vector);
 271
 272           return false;
 273         }
 274     }
 275
 276   if (match_count == 0)
 277     {
 278       /* Try partial matches.  */
 279       right_targ = ar_right_targ;
 280       if (right_targ == bfd_default_vector[0])
 281         {
 282           match_count = 1;
 283         }
 284       else
 285         {
 286           match_count = ar_match_index - _bfd_target_vector_entries;
 287           if (matching && match_count > 1)
 288             {
 289               memcpy (matching_vector,
 290                       matching_vector + _bfd_target_vector_entries,
 291                       sizeof (char *) * match_count);
 292             }
 293         }
 294     }
 295
 296   if (match_count == 1)
 297     {
 298       abfd->xvec = right_targ;          /* Change BFD's target permanently.  */
 299
 300       if (matching)
 301         free (matching_vector);
 302
 303       return true;                      /* File position has moved, BTW.  */
 304     }
 305
 306   abfd->xvec = save_targ;               /* Restore original target type.  */
 307   abfd->format = bfd_unknown;           /* Restore original format.  */
 308
 309   if (match_count == 0)
 310     {
 311       bfd_set_error (bfd_error_file_not_recognized);
 312
 313       if (matching)
 314         free (matching_vector);
 315     }
 316   else
 317     {
 318       bfd_set_error (bfd_error_file_ambiguously_recognized);
 319
 320       if (matching)
 321         {
 322           *matching = matching_vector;
 323           matching_vector[match_count] = NULL;
 324         }
 325     }
 326
 327   return false;
 328 }
 329
 330 /*
 331 FUNCTION
 332         bfd_set_format
 333
 334 SYNOPSIS
 335         boolean bfd_set_format(bfd *abfd, bfd_format format);
 336
 337 DESCRIPTION
 338         This function sets the file format of the BFD @var{abfd} to the
 339         format @var{format}. If the target set in the BFD does not
 340         support the format requested, the format is invalid, or the BFD
 341         is not open for writing, then an error occurs.
 342 */
 343
 344 boolean
 345 bfd_set_format (abfd, format)
 346      bfd *abfd;
 347      bfd_format format;
 348 {
 349   if (bfd_read_p (abfd)
 350       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 351     {
 352       bfd_set_error (bfd_error_invalid_operation);
 353       return false;
 354     }
 355
 356   if (abfd->format != bfd_unknown)
 357     return (abfd->format == format) ? true : false;
 358
 359   /* Presume the answer is yes.  */
 360   abfd->format = format;
 361
 362   if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
 363     {
 364       abfd->format = bfd_unknown;
 365       return false;
 366     }
 367
 368   return true;
 369 }
 370
 371 /*
 372 FUNCTION
 373         bfd_format_string
 374
 375 SYNOPSIS
 376         const char *bfd_format_string(bfd_format format);
 377
 378 DESCRIPTION
 379         Return a pointer to a const string
 380         <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
 381         depending upon the value of @var{format}.
 382 */
 383
 384 const char *
 385 bfd_format_string (format)
 386      bfd_format format;
 387 {
 388   if (((int)format <(int) bfd_unknown)
 389       || ((int)format >=(int) bfd_type_end))
 390     return "invalid";
 391
 392   switch (format)
 393     {
 394     case bfd_object:
 395       return "object";          /* Linker/assember/compiler output.  */
 396     case bfd_archive:
 397       return "archive";         /* Object archive file.  */
 398     case bfd_core:
 399       return "core";            /* Core dump.  */
 400     default:
 401       return "unknown";
 402     }
 403 }