bfd/format.c

   1 /* Generic BFD support for file formats.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002, 2003
   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         bfd_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 bfd_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         bfd_boolean bfd_check_format_matches (bfd *abfd, bfd_format format,
 102                                               char ***matching);
 103
 104 DESCRIPTION
 105         Like <<bfd_check_format>>, except when it returns FALSE with
 106         <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>.  In that
 107         case, if @var{matching} is not NULL, it will be filled in with
 108         a NULL-terminated list of the names of the formats that matched,
 109         allocated with <<malloc>>.
 110         Then the user may choose a format and try again.
 111
 112         When done with the list that @var{matching} points to, the caller
 113         should free it.
 114 */
 115
 116 bfd_boolean
 117 bfd_check_format_matches (abfd, format, matching)
 118      bfd *abfd;
 119      bfd_format format;
 120      char ***matching;
 121 {
 122   extern const bfd_target binary_vec;
 123   const bfd_target * const *target;
 124   const bfd_target **matching_vector = NULL;
 125   const bfd_target *save_targ, *right_targ, *ar_right_targ;
 126   int match_count;
 127   int ar_match_index;
 128
 129   if (!bfd_read_p (abfd)
 130       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 131     {
 132       bfd_set_error (bfd_error_invalid_operation);
 133       return FALSE;
 134     }
 135
 136   if (abfd->format != bfd_unknown)
 137     return abfd->format == format;
 138
 139   /* Since the target type was defaulted, check them
 140      all in the hope that one will be uniquely recognized.  */
 141   save_targ = abfd->xvec;
 142   match_count = 0;
 143   ar_match_index = _bfd_target_vector_entries;
 144
 145   if (matching)
 146     {
 147       bfd_size_type amt;
 148
 149       *matching = NULL;
 150       amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
 151       matching_vector = (const bfd_target **) bfd_malloc (amt);
 152       if (!matching_vector)
 153         return FALSE;
 154     }
 155
 156   right_targ = 0;
 157   ar_right_targ = 0;
 158
 159   /* Presume the answer is yes.  */
 160   abfd->format = format;
 161
 162   /* If the target type was explicitly specified, just check that target.  */
 163   if (!abfd->target_defaulted)
 164     {
 165       if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */
 166         {
 167           if (matching)
 168             free ((PTR) matching_vector);
 169           return FALSE;
 170         }
 171
 172       right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 173
 174       if (right_targ)
 175         {
 176           abfd->xvec = right_targ;      /* Set the target as returned.  */
 177
 178           if (matching)
 179             free ((PTR) matching_vector);
 180
 181           return TRUE;                  /* File position has moved, BTW.  */
 182         }
 183
 184       /* For a long time the code has dropped through to check all
 185          targets if the specified target was wrong.  I don't know why,
 186          and I'm reluctant to change it.  However, in the case of an
 187          archive, it can cause problems.  If the specified target does
 188          not permit archives (e.g., the binary target), then we should
 189          not allow some other target to recognize it as an archive, but
 190          should instead allow the specified target to recognize it as an
 191          object.  When I first made this change, it broke the PE target,
 192          because the specified pei-i386 target did not recognize the
 193          actual pe-i386 archive.  Since there may be other problems of
 194          this sort, I changed this test to check only for the binary
 195          target.  */
 196       if (format == bfd_archive && save_targ == &binary_vec)
 197         {
 198           abfd->xvec = save_targ;
 199           abfd->format = bfd_unknown;
 200
 201           if (matching)
 202             free ((PTR) matching_vector);
 203
 204           bfd_set_error (bfd_error_file_not_recognized);
 205
 206           return FALSE;
 207         }
 208     }
 209
 210   for (target = bfd_target_vector; *target != NULL; target++)
 211     {
 212       const bfd_target *temp;
 213       bfd_error_type err;
 214
 215       if (*target == &binary_vec)
 216         continue;
 217
 218       abfd->xvec = *target;     /* Change BFD's target temporarily.  */
 219
 220       if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 221         {
 222           if (matching)
 223             free ((PTR) matching_vector);
 224           return FALSE;
 225         }
 226
 227       /* If _bfd_check_format neglects to set bfd_error, assume
 228          bfd_error_wrong_format.  We didn't used to even pay any
 229          attention to bfd_error, so I suspect that some
 230          _bfd_check_format might have this problem.  */
 231       bfd_set_error (bfd_error_wrong_format);
 232
 233       temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 234
 235       if (temp)
 236         {
 237           /* This format checks out as ok!  */
 238           right_targ = temp;
 239
 240           /* If this is the default target, accept it, even if other
 241              targets might match.  People who want those other targets
 242              have to set the GNUTARGET variable.  */
 243           if (temp == bfd_default_vector[0])
 244             {
 245               match_count = 1;
 246               break;
 247             }
 248
 249           if (matching)
 250             matching_vector[match_count] = temp;
 251
 252           match_count++;
 253
 254 #ifdef GNU960
 255           /* Big- and little-endian b.out archives look the same, but it
 256              doesn't matter: there is no difference in their headers, and
 257              member file byte orders will (I hope) be handled appropriately
 258              by bfd.  Ditto for big and little coff archives.  And the 4
 259              coff/b.out object formats are unambiguous.  So accept the
 260              first match we find.  */
 261           break;
 262 #endif
 263         }
 264       else if ((err = bfd_get_error ()) == bfd_error_wrong_object_format
 265                || err == bfd_error_file_ambiguously_recognized)
 266         {
 267           /* An archive with objects of the wrong type, or an
 268              ambiguous match.  We want this target to match if we get
 269              no better matches.  */
 270           if (ar_right_targ != bfd_default_vector[0])
 271             ar_right_targ = *target;
 272           if (matching)
 273             matching_vector[ar_match_index] = *target;
 274           ar_match_index++;
 275         }
 276       else if (err != bfd_error_wrong_format)
 277         {
 278           abfd->xvec = save_targ;
 279           abfd->format = bfd_unknown;
 280
 281           if (matching)
 282             free ((PTR) matching_vector);
 283
 284           return FALSE;
 285         }
 286     }
 287
 288   if (match_count == 0)
 289     {
 290       /* Try partial matches.  */
 291       right_targ = ar_right_targ;
 292
 293       if (right_targ == bfd_default_vector[0])
 294         {
 295           match_count = 1;
 296         }
 297       else
 298         {
 299           match_count = ar_match_index - _bfd_target_vector_entries;
 300
 301           if (matching && match_count > 1)
 302             memcpy (matching_vector,
 303                     matching_vector + _bfd_target_vector_entries,
 304                     sizeof (*matching_vector) * match_count);
 305         }
 306     }
 307
 308   if (match_count > 1
 309       && bfd_associated_vector != NULL
 310       && matching)
 311     {
 312       const bfd_target * const *assoc = bfd_associated_vector;
 313
 314       while ((right_targ = *assoc++) != NULL)
 315         {
 316           int i = match_count;
 317
 318           while (--i >= 0)
 319             if (matching_vector[i] == right_targ)
 320               break;
 321
 322           if (i >= 0)
 323             {
 324               match_count = 1;
 325               break;
 326             }
 327         }
 328     }
 329
 330   if (match_count == 1)
 331     {
 332       abfd->xvec = right_targ;          /* Change BFD's target permanently.  */
 333
 334       if (matching)
 335         free ((PTR) matching_vector);
 336
 337       return TRUE;                      /* File position has moved, BTW.  */
 338     }
 339
 340   abfd->xvec = save_targ;               /* Restore original target type.  */
 341   abfd->format = bfd_unknown;           /* Restore original format.  */
 342
 343   if (match_count == 0)
 344     {
 345       bfd_set_error (bfd_error_file_not_recognized);
 346
 347       if (matching)
 348         free ((PTR) matching_vector);
 349     }
 350   else
 351     {
 352       bfd_set_error (bfd_error_file_ambiguously_recognized);
 353
 354       if (matching)
 355         {
 356           *matching = (char **) matching_vector;
 357           matching_vector[match_count] = NULL;
 358           /* Return target names.  This is a little nasty.  Maybe we
 359              should do another bfd_malloc?  */
 360           while (--match_count >= 0)
 361             {
 362               const char *name = matching_vector[match_count]->name;
 363               *(const char **) &matching_vector[match_count] = name;
 364             }
 365         }
 366     }
 367
 368   return FALSE;
 369 }
 370
 371 /*
 372 FUNCTION
 373         bfd_set_format
 374
 375 SYNOPSIS
 376         bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
 377
 378 DESCRIPTION
 379         This function sets the file format of the BFD @var{abfd} to the
 380         format @var{format}. If the target set in the BFD does not
 381         support the format requested, the format is invalid, or the BFD
 382         is not open for writing, then an error occurs.
 383 */
 384
 385 bfd_boolean
 386 bfd_set_format (abfd, format)
 387      bfd *abfd;
 388      bfd_format format;
 389 {
 390   if (bfd_read_p (abfd)
 391       || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
 392     {
 393       bfd_set_error (bfd_error_invalid_operation);
 394       return FALSE;
 395     }
 396
 397   if (abfd->format != bfd_unknown)
 398     return abfd->format == format;
 399
 400   /* Presume the answer is yes.  */
 401   abfd->format = format;
 402
 403   if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
 404     {
 405       abfd->format = bfd_unknown;
 406       return FALSE;
 407     }
 408
 409   return TRUE;
 410 }
 411
 412 /*
 413 FUNCTION
 414         bfd_format_string
 415
 416 SYNOPSIS
 417         const char *bfd_format_string (bfd_format format);
 418
 419 DESCRIPTION
 420         Return a pointer to a const string
 421         <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
 422         depending upon the value of @var{format}.
 423 */
 424
 425 const char *
 426 bfd_format_string (format)
 427      bfd_format format;
 428 {
 429   if (((int)format <(int) bfd_unknown)
 430       || ((int)format >=(int) bfd_type_end))
 431     return "invalid";
 432
 433   switch (format)
 434     {
 435     case bfd_object:
 436       return "object";          /* Linker/assember/compiler output.  */
 437     case bfd_archive:
 438       return "archive";         /* Object archive file.  */
 439     case bfd_core:
 440       return "core";            /* Core dump.  */
 441     default:
 442       return "unknown";
 443     }
 444 }