*** empty log message ***
[deliverable/binutils-gdb.git] / bfd / format.c
CommitLineData
252b5132 1/* Generic BFD support for file formats.
9553c638 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002,
aa820537 3 2003, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
252b5132
RH
4 Written by Cygnus Support.
5
ed781d5d 6 This file is part of BFD, the Binary File Descriptor library.
252b5132 7
ed781d5d
NC
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
cd123cb7 10 the Free Software Foundation; either version 3 of the License, or
ed781d5d 11 (at your option) any later version.
252b5132 12
ed781d5d
NC
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.
252b5132 17
ed781d5d
NC
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
cd123cb7
NC
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
252b5132
RH
23
24/*
25SECTION
26 File formats
27
28 A format is a BFD concept of high level file contents type. The
3fde5a36 29 formats supported by BFD are:
252b5132
RH
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
1b74d094
BW
43SUBSECTION
44 File format functions
252b5132
RH
45*/
46
252b5132 47#include "sysdep.h"
3db64b00 48#include "bfd.h"
252b5132
RH
49#include "libbfd.h"
50
51/* IMPORT from targets.c. */
52extern const size_t _bfd_target_vector_entries;
53
54/*
55FUNCTION
56 bfd_check_format
57
58SYNOPSIS
ed781d5d 59 bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
252b5132
RH
60
61DESCRIPTION
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
b34976b6 74 The function returns <<TRUE>> on success, otherwise <<FALSE>>
3fde5a36 75 with one of the following error codes:
252b5132
RH
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
b34976b6 92bfd_boolean
c58b9523 93bfd_check_format (bfd *abfd, bfd_format format)
252b5132
RH
94{
95 return bfd_check_format_matches (abfd, format, NULL);
96}
97
c9ba0c87
AM
98struct 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
119static bfd_boolean
120bfd_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
139static void
140bfd_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
150static void
151bfd_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
172static void
173bfd_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
252b5132
RH
183/*
184FUNCTION
185 bfd_check_format_matches
186
187SYNOPSIS
c58b9523
AM
188 bfd_boolean bfd_check_format_matches
189 (bfd *abfd, bfd_format format, char ***matching);
252b5132
RH
190
191DESCRIPTION
b34976b6 192 Like <<bfd_check_format>>, except when it returns FALSE with
252b5132
RH
193 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that
194 case, if @var{matching} is not NULL, it will be filled in with
195 a NULL-terminated list of the names of the formats that matched,
196 allocated with <<malloc>>.
197 Then the user may choose a format and try again.
198
199 When done with the list that @var{matching} points to, the caller
3fde5a36 200 should free it.
252b5132
RH
201*/
202
b34976b6 203bfd_boolean
c58b9523 204bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
252b5132
RH
205{
206 extern const bfd_target binary_vec;
08f74004
AM
207 const bfd_target * const *target;
208 const bfd_target **matching_vector = NULL;
0aabe54e
AM
209 const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
210 int match_count, best_count, best_match;
3619ad04 211 int ar_match_index;
c9ba0c87 212 struct bfd_preserve preserve;
252b5132 213
5a1dcb7e
AM
214 if (matching != NULL)
215 *matching = NULL;
216
3619ad04 217 if (!bfd_read_p (abfd)
cea4409c 218 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
1d713d9e
NC
219 {
220 bfd_set_error (bfd_error_invalid_operation);
b34976b6 221 return FALSE;
1d713d9e 222 }
252b5132
RH
223
224 if (abfd->format != bfd_unknown)
b34976b6 225 return abfd->format == format;
252b5132 226
5a1dcb7e 227 if (matching != NULL || *bfd_associated_vector != NULL)
252b5132 228 {
dc810e39
AM
229 bfd_size_type amt;
230
08f74004 231 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
a50b1753 232 matching_vector = (const bfd_target **) bfd_malloc (amt);
252b5132 233 if (!matching_vector)
b34976b6 234 return FALSE;
252b5132 235 }
3fde5a36 236
1d713d9e 237 /* Presume the answer is yes. */
252b5132 238 abfd->format = format;
c9ba0c87
AM
239 save_targ = abfd->xvec;
240 preserve.marker = NULL;
252b5132
RH
241
242 /* If the target type was explicitly specified, just check that target. */
1d713d9e
NC
243 if (!abfd->target_defaulted)
244 {
dc810e39 245 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */
5a1dcb7e 246 goto err_ret;
3fde5a36 247
1d713d9e 248 right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
3fde5a36 249
1d713d9e 250 if (right_targ)
5a1dcb7e 251 goto ok_ret;
1d713d9e
NC
252
253 /* For a long time the code has dropped through to check all
254 targets if the specified target was wrong. I don't know why,
255 and I'm reluctant to change it. However, in the case of an
256 archive, it can cause problems. If the specified target does
257 not permit archives (e.g., the binary target), then we should
258 not allow some other target to recognize it as an archive, but
259 should instead allow the specified target to recognize it as an
260 object. When I first made this change, it broke the PE target,
261 because the specified pei-i386 target did not recognize the
262 actual pe-i386 archive. Since there may be other problems of
263 this sort, I changed this test to check only for the binary
264 target. */
265 if (format == bfd_archive && save_targ == &binary_vec)
5a1dcb7e 266 goto err_unrecog;
1d713d9e
NC
267 }
268
c9ba0c87
AM
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
1d713d9e
NC
279 for (target = bfd_target_vector; *target != NULL; target++)
280 {
281 const bfd_target *temp;
3fde5a36 282
25bbc984
L
283 /* Don't check the default target twice. */
284 if (*target == &binary_vec
0aabe54e
AM
285 || (!abfd->target_defaulted && *target == save_targ)
286 || (*target)->match_priority > best_match)
1d713d9e 287 continue;
3fde5a36 288
c9ba0c87
AM
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;
3fde5a36 296
dc810e39 297 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
5a1dcb7e 298 goto err_ret;
3fde5a36 299
1d713d9e
NC
300 /* If _bfd_check_format neglects to set bfd_error, assume
301 bfd_error_wrong_format. We didn't used to even pay any
302 attention to bfd_error, so I suspect that some
303 _bfd_check_format might have this problem. */
304 bfd_set_error (bfd_error_wrong_format);
305
306 temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
0aabe54e 307 if (temp)
c9ba0c87
AM
308 {
309 match_targ = temp;
310 if (preserve.marker != NULL)
311 bfd_preserve_finish (abfd, &preserve);
3fde5a36 312
89d7b8aa
AM
313 if (abfd->format != bfd_archive
314 || (bfd_has_map (abfd)
315 && bfd_get_error () != bfd_error_wrong_object_format))
0aabe54e 316 {
89d7b8aa
AM
317 /* This format checks out as ok! */
318 right_targ = temp;
319
320 /* If this is the default target, accept it, even if
321 other targets might match. People who want those
322 other targets have to set the GNUTARGET variable. */
323 if (temp == bfd_default_vector[0])
324 goto ok_ret;
325
326 if (matching_vector)
327 matching_vector[match_count] = temp;
328 match_count++;
329
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
338 {
339 /* An archive with no armap or objects of the wrong
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++;
0aabe54e 347 }
c9ba0c87 348
89d7b8aa
AM
349 if (!bfd_preserve_save (abfd, &preserve))
350 goto err_ret;
351 }
352 else if (bfd_get_error () != bfd_error_wrong_format)
c9ba0c87 353 goto err_ret;
1d713d9e 354 }
3fde5a36 355
0aabe54e
AM
356 if (best_count == 1)
357 match_count = 1;
358
3619ad04
AM
359 if (match_count == 0)
360 {
361 /* Try partial matches. */
362 right_targ = ar_right_targ;
ed781d5d 363
3619ad04
AM
364 if (right_targ == bfd_default_vector[0])
365 {
366 match_count = 1;
367 }
368 else
369 {
370 match_count = ar_match_index - _bfd_target_vector_entries;
ed781d5d 371
5a1dcb7e 372 if (matching_vector && match_count > 1)
ed781d5d
NC
373 memcpy (matching_vector,
374 matching_vector + _bfd_target_vector_entries,
375 sizeof (*matching_vector) * match_count);
08f74004
AM
376 }
377 }
378
5a1dcb7e 379 if (match_count > 1)
08f74004
AM
380 {
381 const bfd_target * const *assoc = bfd_associated_vector;
382
383 while ((right_targ = *assoc++) != NULL)
384 {
385 int i = match_count;
386
387 while (--i >= 0)
388 if (matching_vector[i] == right_targ)
389 break;
390
391 if (i >= 0)
392 {
393 match_count = 1;
394 break;
3619ad04
AM
395 }
396 }
397 }
398
c9ba0c87
AM
399 /* There is way too much undoing of half-known state here. We
400 really shouldn't iterate on live bfd's. Note that saving the
401 whole bfd and restoring it would be even worse; the first thing
402 you notice is that the cached bfd file position gets out of sync. */
403 if (preserve.marker != NULL)
404 bfd_preserve_restore (abfd, &preserve);
405
1d713d9e
NC
406 if (match_count == 1)
407 {
0aabe54e
AM
408 abfd->xvec = right_targ;
409 /* If we come out of the loop knowing that the last target that
410 matched is the one we want, then ABFD should still be in a usable
411 state (except possibly for XVEC). */
412 if (match_targ != right_targ)
413 {
c9ba0c87 414 bfd_reinit (abfd);
0aabe54e
AM
415 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
416 goto err_ret;
417 match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
c9ba0c87 418 BFD_ASSERT (match_targ != NULL);
0aabe54e 419 }
3fde5a36 420
0aabe54e 421 ok_ret:
26ae6d5e
DJ
422 /* If the file was opened for update, then `output_has_begun'
423 some time ago when the file was created. Do not recompute
424 sections sizes or alignments in _bfd_set_section_contents.
425 We can not set this flag until after checking the format,
426 because it will interfere with creation of BFD sections. */
427 if (abfd->direction == both_direction)
428 abfd->output_has_begun = TRUE;
429
5a1dcb7e
AM
430 if (matching_vector)
431 free (matching_vector);
c9ba0c87
AM
432
433 /* File position has moved, BTW. */
434 return TRUE;
252b5132 435 }
252b5132 436
252b5132
RH
437 if (match_count == 0)
438 {
5a1dcb7e 439 err_unrecog:
252b5132 440 bfd_set_error (bfd_error_file_not_recognized);
5a1dcb7e
AM
441 err_ret:
442 abfd->xvec = save_targ;
443 abfd->format = bfd_unknown;
444 if (matching_vector)
c58b9523 445 free (matching_vector);
c9ba0c87
AM
446 if (preserve.marker != NULL)
447 bfd_preserve_restore (abfd, &preserve);
5a1dcb7e 448 return FALSE;
252b5132 449 }
3619ad04 450
c9ba0c87
AM
451 /* Restore original target type and format. */
452 abfd->xvec = save_targ;
453 abfd->format = bfd_unknown;
5a1dcb7e
AM
454 bfd_set_error (bfd_error_file_ambiguously_recognized);
455
456 if (matching)
457 {
458 *matching = (char **) matching_vector;
459 matching_vector[match_count] = NULL;
460 /* Return target names. This is a little nasty. Maybe we
461 should do another bfd_malloc? */
462 while (--match_count >= 0)
3619ad04 463 {
5a1dcb7e
AM
464 const char *name = matching_vector[match_count]->name;
465 *(const char **) &matching_vector[match_count] = name;
3619ad04
AM
466 }
467 }
b34976b6 468 return FALSE;
252b5132
RH
469}
470
471/*
472FUNCTION
473 bfd_set_format
474
475SYNOPSIS
ed781d5d 476 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
252b5132
RH
477
478DESCRIPTION
479 This function sets the file format of the BFD @var{abfd} to the
480 format @var{format}. If the target set in the BFD does not
481 support the format requested, the format is invalid, or the BFD
482 is not open for writing, then an error occurs.
252b5132
RH
483*/
484
b34976b6 485bfd_boolean
c58b9523 486bfd_set_format (bfd *abfd, bfd_format format)
252b5132 487{
3619ad04 488 if (bfd_read_p (abfd)
cea4409c 489 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
1d713d9e
NC
490 {
491 bfd_set_error (bfd_error_invalid_operation);
b34976b6 492 return FALSE;
1d713d9e 493 }
252b5132
RH
494
495 if (abfd->format != bfd_unknown)
b34976b6 496 return abfd->format == format;
252b5132 497
1d713d9e 498 /* Presume the answer is yes. */
252b5132
RH
499 abfd->format = format;
500
1d713d9e
NC
501 if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
502 {
503 abfd->format = bfd_unknown;
b34976b6 504 return FALSE;
1d713d9e 505 }
252b5132 506
b34976b6 507 return TRUE;
252b5132
RH
508}
509
252b5132
RH
510/*
511FUNCTION
512 bfd_format_string
513
514SYNOPSIS
ed781d5d 515 const char *bfd_format_string (bfd_format format);
252b5132
RH
516
517DESCRIPTION
518 Return a pointer to a const string
519 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
520 depending upon the value of @var{format}.
521*/
522
3619ad04 523const char *
c58b9523 524bfd_format_string (bfd_format format)
252b5132 525{
c58b9523
AM
526 if (((int) format < (int) bfd_unknown)
527 || ((int) format >= (int) bfd_type_end))
252b5132 528 return "invalid";
3fde5a36 529
1d713d9e
NC
530 switch (format)
531 {
532 case bfd_object:
7dee875e 533 return "object"; /* Linker/assembler/compiler output. */
3fde5a36 534 case bfd_archive:
1d713d9e 535 return "archive"; /* Object archive file. */
3fde5a36 536 case bfd_core:
1d713d9e 537 return "core"; /* Core dump. */
3fde5a36 538 default:
1d713d9e
NC
539 return "unknown";
540 }
252b5132 541}
This page took 0.674485 seconds and 4 git commands to generate.