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