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