OLD | NEW |
1 /* Generic BFD support for file formats. | 1 /* Generic BFD support for file formats. |
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002, | 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002, |
3 2003, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. | 3 2003, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. |
4 Written by Cygnus Support. | 4 Written by Cygnus Support. |
5 | 5 |
6 This file is part of BFD, the Binary File Descriptor library. | 6 This file is part of BFD, the Binary File Descriptor library. |
7 | 7 |
8 This program is free software; you can redistribute it and/or modify | 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 | 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 | 10 the Free Software Foundation; either version 3 of the License, or |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
88 o <<bfd_error_file_ambiguously_recognized>> - | 88 o <<bfd_error_file_ambiguously_recognized>> - |
89 more than one backend recognised the file format. | 89 more than one backend recognised the file format. |
90 */ | 90 */ |
91 | 91 |
92 bfd_boolean | 92 bfd_boolean |
93 bfd_check_format (bfd *abfd, bfd_format format) | 93 bfd_check_format (bfd *abfd, bfd_format format) |
94 { | 94 { |
95 return bfd_check_format_matches (abfd, format, NULL); | 95 return bfd_check_format_matches (abfd, format, NULL); |
96 } | 96 } |
97 | 97 |
| 98 struct bfd_preserve |
| 99 { |
| 100 void *marker; |
| 101 void *tdata; |
| 102 flagword flags; |
| 103 const struct bfd_arch_info *arch_info; |
| 104 struct bfd_section *sections; |
| 105 struct bfd_section *section_last; |
| 106 unsigned int section_count; |
| 107 struct bfd_hash_table section_htab; |
| 108 }; |
| 109 |
| 110 /* When testing an object for compatibility with a particular target |
| 111 back-end, the back-end object_p function needs to set up certain |
| 112 fields in the bfd on successfully recognizing the object. This |
| 113 typically happens in a piecemeal fashion, with failures possible at |
| 114 many points. On failure, the bfd is supposed to be restored to its |
| 115 initial state, which is virtually impossible. However, restoring a |
| 116 subset of the bfd state works in practice. This function stores |
| 117 the subset. */ |
| 118 |
| 119 static bfd_boolean |
| 120 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve) |
| 121 { |
| 122 preserve->tdata = abfd->tdata.any; |
| 123 preserve->arch_info = abfd->arch_info; |
| 124 preserve->flags = abfd->flags; |
| 125 preserve->sections = abfd->sections; |
| 126 preserve->section_last = abfd->section_last; |
| 127 preserve->section_count = abfd->section_count; |
| 128 preserve->section_htab = abfd->section_htab; |
| 129 preserve->marker = bfd_alloc (abfd, 1); |
| 130 if (preserve->marker == NULL) |
| 131 return FALSE; |
| 132 |
| 133 return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc, |
| 134 sizeof (struct section_hash_entry)); |
| 135 } |
| 136 |
| 137 /* Clear out a subset of BFD state. */ |
| 138 |
| 139 static void |
| 140 bfd_reinit (bfd *abfd) |
| 141 { |
| 142 abfd->tdata.any = NULL; |
| 143 abfd->arch_info = &bfd_default_arch_struct; |
| 144 abfd->flags &= BFD_FLAGS_SAVED; |
| 145 bfd_section_list_clear (abfd); |
| 146 } |
| 147 |
| 148 /* Restores bfd state saved by bfd_preserve_save. */ |
| 149 |
| 150 static void |
| 151 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve) |
| 152 { |
| 153 bfd_hash_table_free (&abfd->section_htab); |
| 154 |
| 155 abfd->tdata.any = preserve->tdata; |
| 156 abfd->arch_info = preserve->arch_info; |
| 157 abfd->flags = preserve->flags; |
| 158 abfd->section_htab = preserve->section_htab; |
| 159 abfd->sections = preserve->sections; |
| 160 abfd->section_last = preserve->section_last; |
| 161 abfd->section_count = preserve->section_count; |
| 162 |
| 163 /* bfd_release frees all memory more recently bfd_alloc'd than |
| 164 its arg, as well as its arg. */ |
| 165 bfd_release (abfd, preserve->marker); |
| 166 preserve->marker = NULL; |
| 167 } |
| 168 |
| 169 /* Called when the bfd state saved by bfd_preserve_save is no longer |
| 170 needed. */ |
| 171 |
| 172 static void |
| 173 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve) |
| 174 { |
| 175 /* It would be nice to be able to free more memory here, eg. old |
| 176 tdata, but that's not possible since these blocks are sitting |
| 177 inside bfd_alloc'd memory. The section hash is on a separate |
| 178 objalloc. */ |
| 179 bfd_hash_table_free (&preserve->section_htab); |
| 180 preserve->marker = NULL; |
| 181 } |
| 182 |
98 /* | 183 /* |
99 FUNCTION | 184 FUNCTION |
100 bfd_check_format_matches | 185 bfd_check_format_matches |
101 | 186 |
102 SYNOPSIS | 187 SYNOPSIS |
103 bfd_boolean bfd_check_format_matches | 188 bfd_boolean bfd_check_format_matches |
104 (bfd *abfd, bfd_format format, char ***matching); | 189 (bfd *abfd, bfd_format format, char ***matching); |
105 | 190 |
106 DESCRIPTION | 191 DESCRIPTION |
107 Like <<bfd_check_format>>, except when it returns FALSE with | 192 Like <<bfd_check_format>>, except when it returns FALSE with |
108 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that | 193 <<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 | 194 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, | 195 a NULL-terminated list of the names of the formats that matched, |
111 allocated with <<malloc>>. | 196 allocated with <<malloc>>. |
112 Then the user may choose a format and try again. | 197 Then the user may choose a format and try again. |
113 | 198 |
114 When done with the list that @var{matching} points to, the caller | 199 When done with the list that @var{matching} points to, the caller |
115 should free it. | 200 should free it. |
116 */ | 201 */ |
117 | 202 |
118 bfd_boolean | 203 bfd_boolean |
119 bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) | 204 bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
120 { | 205 { |
121 extern const bfd_target binary_vec; | 206 extern const bfd_target binary_vec; |
122 const bfd_target * const *target; | 207 const bfd_target * const *target; |
123 const bfd_target **matching_vector = NULL; | 208 const bfd_target **matching_vector = NULL; |
124 const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ; | 209 const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ; |
125 int match_count, best_count, best_match; | 210 int match_count, best_count, best_match; |
126 int ar_match_index; | 211 int ar_match_index; |
| 212 struct bfd_preserve preserve; |
127 | 213 |
128 if (matching != NULL) | 214 if (matching != NULL) |
129 *matching = NULL; | 215 *matching = NULL; |
130 | 216 |
131 if (!bfd_read_p (abfd) | 217 if (!bfd_read_p (abfd) |
132 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end) | 218 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end) |
133 { | 219 { |
134 bfd_set_error (bfd_error_invalid_operation); | 220 bfd_set_error (bfd_error_invalid_operation); |
135 return FALSE; | 221 return FALSE; |
136 } | 222 } |
137 | 223 |
138 if (abfd->format != bfd_unknown) | 224 if (abfd->format != bfd_unknown) |
139 return abfd->format == format; | 225 return abfd->format == format; |
140 | 226 |
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) | 227 if (matching != NULL || *bfd_associated_vector != NULL) |
148 { | 228 { |
149 bfd_size_type amt; | 229 bfd_size_type amt; |
150 | 230 |
151 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries; | 231 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries; |
152 matching_vector = (const bfd_target **) bfd_malloc (amt); | 232 matching_vector = (const bfd_target **) bfd_malloc (amt); |
153 if (!matching_vector) | 233 if (!matching_vector) |
154 return FALSE; | 234 return FALSE; |
155 } | 235 } |
156 | 236 |
157 right_targ = 0; | |
158 ar_right_targ = 0; | |
159 match_targ = 0; | |
160 best_match = 256; | |
161 best_count = 0; | |
162 | |
163 /* Presume the answer is yes. */ | 237 /* Presume the answer is yes. */ |
164 abfd->format = format; | 238 abfd->format = format; |
| 239 save_targ = abfd->xvec; |
| 240 preserve.marker = NULL; |
165 | 241 |
166 /* If the target type was explicitly specified, just check that target. */ | 242 /* If the target type was explicitly specified, just check that target. */ |
167 if (!abfd->target_defaulted) | 243 if (!abfd->target_defaulted) |
168 { | 244 { |
169 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */ | 245 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */ |
170 goto err_ret; | 246 goto err_ret; |
171 | 247 |
172 right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); | 248 right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); |
173 | 249 |
174 if (right_targ) | 250 if (right_targ) |
175 goto ok_ret; | 251 goto ok_ret; |
176 | 252 |
177 /* For a long time the code has dropped through to check all | 253 /* 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, | 254 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 | 255 and I'm reluctant to change it. However, in the case of an |
180 archive, it can cause problems. If the specified target does | 256 archive, it can cause problems. If the specified target does |
181 not permit archives (e.g., the binary target), then we should | 257 not permit archives (e.g., the binary target), then we should |
182 not allow some other target to recognize it as an archive, but | 258 not allow some other target to recognize it as an archive, but |
183 should instead allow the specified target to recognize it as an | 259 should instead allow the specified target to recognize it as an |
184 object. When I first made this change, it broke the PE target, | 260 object. When I first made this change, it broke the PE target, |
185 because the specified pei-i386 target did not recognize the | 261 because the specified pei-i386 target did not recognize the |
186 actual pe-i386 archive. Since there may be other problems of | 262 actual pe-i386 archive. Since there may be other problems of |
187 this sort, I changed this test to check only for the binary | 263 this sort, I changed this test to check only for the binary |
188 target. */ | 264 target. */ |
189 if (format == bfd_archive && save_targ == &binary_vec) | 265 if (format == bfd_archive && save_targ == &binary_vec) |
190 goto err_unrecog; | 266 goto err_unrecog; |
191 } | 267 } |
192 | 268 |
| 269 /* Since the target type was defaulted, check them all in the hope |
| 270 that one will be uniquely recognized. */ |
| 271 right_targ = NULL; |
| 272 ar_right_targ = NULL; |
| 273 match_targ = NULL; |
| 274 best_match = 256; |
| 275 best_count = 0; |
| 276 match_count = 0; |
| 277 ar_match_index = _bfd_target_vector_entries; |
| 278 |
193 for (target = bfd_target_vector; *target != NULL; target++) | 279 for (target = bfd_target_vector; *target != NULL; target++) |
194 { | 280 { |
195 const bfd_target *temp; | 281 const bfd_target *temp; |
196 bfd_error_type err; | |
197 | 282 |
198 /* Don't check the default target twice. */ | 283 /* Don't check the default target twice. */ |
199 if (*target == &binary_vec | 284 if (*target == &binary_vec |
200 || (!abfd->target_defaulted && *target == save_targ) | 285 || (!abfd->target_defaulted && *target == save_targ) |
201 || (*target)->match_priority > best_match) | 286 || (*target)->match_priority > best_match) |
202 continue; | 287 continue; |
203 | 288 |
204 abfd->xvec = *target;» /* Change BFD's target temporarily. */ | 289 /* If we already tried a match, the bfd is modified and may |
| 290 » have sections attached, which will confuse the next |
| 291 » _bfd_check_format call. */ |
| 292 bfd_reinit (abfd); |
| 293 |
| 294 /* Change BFD's target temporarily. */ |
| 295 abfd->xvec = *target; |
205 | 296 |
206 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) | 297 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) |
207 goto err_ret; | 298 goto err_ret; |
208 | 299 |
209 /* If _bfd_check_format neglects to set bfd_error, assume | 300 /* If _bfd_check_format neglects to set bfd_error, assume |
210 bfd_error_wrong_format. We didn't used to even pay any | 301 bfd_error_wrong_format. We didn't used to even pay any |
211 attention to bfd_error, so I suspect that some | 302 attention to bfd_error, so I suspect that some |
212 _bfd_check_format might have this problem. */ | 303 _bfd_check_format might have this problem. */ |
213 bfd_set_error (bfd_error_wrong_format); | 304 bfd_set_error (bfd_error_wrong_format); |
214 | 305 |
215 temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); | 306 temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); |
216 if (temp) | 307 if (temp) |
217 » match_targ = temp; | 308 » { |
| 309 » match_targ = temp; |
| 310 » if (preserve.marker != NULL) |
| 311 » bfd_preserve_finish (abfd, &preserve); |
218 | 312 |
219 if (temp && (abfd->format != bfd_archive || bfd_has_map (abfd))) | 313 » if (abfd->format != bfd_archive |
220 » { | 314 » || (bfd_has_map (abfd) |
221 » /* This format checks out as ok! */ | 315 » » && bfd_get_error () != bfd_error_wrong_object_format)) |
222 » right_targ = temp; | 316 » { |
| 317 » /* This format checks out as ok! */ |
| 318 » right_targ = temp; |
223 | 319 |
224 » /* If this is the default target, accept it, even if other | 320 » /* If this is the default target, accept it, even if |
225 » targets might match. People who want those other targets | 321 » » other targets might match. People who want those |
226 » have to set the GNUTARGET variable. */ | 322 » » other targets have to set the GNUTARGET variable. */ |
227 » if (temp == bfd_default_vector[0]) | 323 » if (temp == bfd_default_vector[0]) |
228 » goto ok_ret; | 324 » » goto ok_ret; |
229 | 325 |
230 » if (matching_vector) | 326 » if (matching_vector) |
231 » matching_vector[match_count] = temp; | 327 » » matching_vector[match_count] = temp; |
232 » match_count++; | 328 » match_count++; |
233 | 329 |
234 » if (temp->match_priority < best_match) | 330 » if (temp->match_priority < best_match) |
| 331 » » { |
| 332 » » best_match = temp->match_priority; |
| 333 » » best_count = 0; |
| 334 » » } |
| 335 » best_count++; |
| 336 » } |
| 337 » else |
235 { | 338 { |
236 » best_match = temp->match_priority; | 339 » /* An archive with no armap or objects of the wrong |
237 » best_count = 0; | 340 » » type. We want this target to match if we get no |
| 341 » » better matches. */ |
| 342 » if (ar_right_targ != bfd_default_vector[0]) |
| 343 » » ar_right_targ = *target; |
| 344 » if (matching_vector) |
| 345 » » matching_vector[ar_match_index] = *target; |
| 346 » ar_match_index++; |
238 } | 347 } |
239 » best_count++; | 348 |
| 349 » if (!bfd_preserve_save (abfd, &preserve)) |
| 350 » goto err_ret; |
240 } | 351 } |
241 else if (temp | 352 else if (bfd_get_error () != bfd_error_wrong_format) |
242 » || (err = bfd_get_error ()) == bfd_error_wrong_object_format | |
243 » || err == bfd_error_file_ambiguously_recognized) | |
244 » { | |
245 » /* An archive with no armap or objects of the wrong type, | |
246 » or an ambiguous match. We want this target to match | |
247 » if we get no better matches. */ | |
248 » if (ar_right_targ != bfd_default_vector[0]) | |
249 » ar_right_targ = *target; | |
250 » if (matching_vector) | |
251 » matching_vector[ar_match_index] = *target; | |
252 » ar_match_index++; | |
253 » } | |
254 else if (err != bfd_error_wrong_format) | |
255 goto err_ret; | 353 goto err_ret; |
256 } | 354 } |
257 | 355 |
258 if (best_count == 1) | 356 if (best_count == 1) |
259 match_count = 1; | 357 match_count = 1; |
260 | 358 |
261 if (match_count == 0) | 359 if (match_count == 0) |
262 { | 360 { |
263 /* Try partial matches. */ | 361 /* Try partial matches. */ |
264 right_targ = ar_right_targ; | 362 right_targ = ar_right_targ; |
265 | 363 |
266 if (right_targ == bfd_default_vector[0]) | 364 if (right_targ == bfd_default_vector[0]) |
267 { | 365 { |
268 match_count = 1; | 366 match_count = 1; |
269 } | 367 } |
270 else | 368 else |
271 { | 369 { |
272 match_count = ar_match_index - _bfd_target_vector_entries; | 370 match_count = ar_match_index - _bfd_target_vector_entries; |
273 | 371 |
274 if (matching_vector && match_count > 1) | 372 if (matching_vector && match_count > 1) |
275 memcpy (matching_vector, | 373 memcpy (matching_vector, |
276 matching_vector + _bfd_target_vector_entries, | 374 matching_vector + _bfd_target_vector_entries, |
277 sizeof (*matching_vector) * match_count); | 375 sizeof (*matching_vector) * match_count); |
278 } | 376 } |
279 } | 377 } |
280 | 378 |
| 379 /* We have more than one equally good match. If any of the best |
| 380 matches is a target in config.bfd targ_defvec or targ_selvecs, |
| 381 choose it. */ |
281 if (match_count > 1) | 382 if (match_count > 1) |
282 { | 383 { |
283 const bfd_target * const *assoc = bfd_associated_vector; | 384 const bfd_target * const *assoc = bfd_associated_vector; |
284 | 385 |
285 while ((right_targ = *assoc++) != NULL) | 386 while ((right_targ = *assoc++) != NULL) |
286 { | 387 { |
287 int i = match_count; | 388 int i = match_count; |
288 | 389 |
289 while (--i >= 0) | 390 while (--i >= 0) |
290 » if (matching_vector[i] == right_targ) | 391 » if (matching_vector[i] == right_targ |
| 392 » » && right_targ->match_priority <= best_match) |
291 break; | 393 break; |
292 | 394 |
293 if (i >= 0) | 395 if (i >= 0) |
294 { | 396 { |
295 match_count = 1; | 397 match_count = 1; |
296 break; | 398 break; |
297 } | 399 } |
298 } | 400 } |
299 } | 401 } |
300 | 402 |
| 403 /* We still have more than one equally good match, and at least some |
| 404 of the targets support match priority. Choose the first of the |
| 405 best matches. */ |
| 406 if (match_count > 1 && best_count != match_count) |
| 407 { |
| 408 int i; |
| 409 |
| 410 for (i = 0; i < match_count; i++) |
| 411 { |
| 412 right_targ = matching_vector[i]; |
| 413 if (right_targ->match_priority <= best_match) |
| 414 break; |
| 415 } |
| 416 match_count = 1; |
| 417 } |
| 418 |
| 419 /* There is way too much undoing of half-known state here. We |
| 420 really shouldn't iterate on live bfd's. Note that saving the |
| 421 whole bfd and restoring it would be even worse; the first thing |
| 422 you notice is that the cached bfd file position gets out of sync. */ |
| 423 if (preserve.marker != NULL) |
| 424 bfd_preserve_restore (abfd, &preserve); |
| 425 |
301 if (match_count == 1) | 426 if (match_count == 1) |
302 { | 427 { |
303 abfd->xvec = right_targ; | 428 abfd->xvec = right_targ; |
304 /* If we come out of the loop knowing that the last target that | 429 /* If we come out of the loop knowing that the last target that |
305 matched is the one we want, then ABFD should still be in a usable | 430 matched is the one we want, then ABFD should still be in a usable |
306 state (except possibly for XVEC). */ | 431 state (except possibly for XVEC). */ |
307 if (match_targ != right_targ) | 432 if (match_targ != right_targ) |
308 { | 433 { |
| 434 bfd_reinit (abfd); |
309 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) | 435 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) |
310 goto err_ret; | 436 goto err_ret; |
311 match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); | 437 match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); |
| 438 BFD_ASSERT (match_targ != NULL); |
312 } | 439 } |
313 | 440 |
314 ok_ret: | 441 ok_ret: |
315 /* If the file was opened for update, then `output_has_begun' | 442 /* If the file was opened for update, then `output_has_begun' |
316 some time ago when the file was created. Do not recompute | 443 some time ago when the file was created. Do not recompute |
317 sections sizes or alignments in _bfd_set_section_contents. | 444 sections sizes or alignments in _bfd_set_section_contents. |
318 We can not set this flag until after checking the format, | 445 We can not set this flag until after checking the format, |
319 because it will interfere with creation of BFD sections. */ | 446 because it will interfere with creation of BFD sections. */ |
320 if (abfd->direction == both_direction) | 447 if (abfd->direction == both_direction) |
321 abfd->output_has_begun = TRUE; | 448 abfd->output_has_begun = TRUE; |
322 | 449 |
323 if (matching_vector) | 450 if (matching_vector) |
324 free (matching_vector); | 451 free (matching_vector); |
325 return TRUE;» » » /* File position has moved, BTW. */ | 452 |
| 453 /* File position has moved, BTW. */ |
| 454 return TRUE; |
326 } | 455 } |
327 | 456 |
328 if (match_count == 0) | 457 if (match_count == 0) |
329 { | 458 { |
330 err_unrecog: | 459 err_unrecog: |
331 bfd_set_error (bfd_error_file_not_recognized); | 460 bfd_set_error (bfd_error_file_not_recognized); |
332 err_ret: | 461 err_ret: |
333 abfd->xvec = save_targ; | 462 abfd->xvec = save_targ; |
334 abfd->format = bfd_unknown; | 463 abfd->format = bfd_unknown; |
335 if (matching_vector) | 464 if (matching_vector) |
336 free (matching_vector); | 465 free (matching_vector); |
| 466 if (preserve.marker != NULL) |
| 467 bfd_preserve_restore (abfd, &preserve); |
337 return FALSE; | 468 return FALSE; |
338 } | 469 } |
339 | 470 |
340 abfd->xvec = save_targ;» » /* Restore original target type. */ | 471 /* Restore original target type and format. */ |
341 abfd->format = bfd_unknown;» » /* Restore original format. */ | 472 abfd->xvec = save_targ; |
| 473 abfd->format = bfd_unknown; |
342 bfd_set_error (bfd_error_file_ambiguously_recognized); | 474 bfd_set_error (bfd_error_file_ambiguously_recognized); |
343 | 475 |
344 if (matching) | 476 if (matching) |
345 { | 477 { |
346 *matching = (char **) matching_vector; | 478 *matching = (char **) matching_vector; |
347 matching_vector[match_count] = NULL; | 479 matching_vector[match_count] = NULL; |
348 /* Return target names. This is a little nasty. Maybe we | 480 /* Return target names. This is a little nasty. Maybe we |
349 should do another bfd_malloc? */ | 481 should do another bfd_malloc? */ |
350 while (--match_count >= 0) | 482 while (--match_count >= 0) |
351 { | 483 { |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
420 case bfd_object: | 552 case bfd_object: |
421 return "object"; /* Linker/assembler/compiler output. */ | 553 return "object"; /* Linker/assembler/compiler output. */ |
422 case bfd_archive: | 554 case bfd_archive: |
423 return "archive"; /* Object archive file. */ | 555 return "archive"; /* Object archive file. */ |
424 case bfd_core: | 556 case bfd_core: |
425 return "core"; /* Core dump. */ | 557 return "core"; /* Core dump. */ |
426 default: | 558 default: |
427 return "unknown"; | 559 return "unknown"; |
428 } | 560 } |
429 } | 561 } |
OLD | NEW |