|
|
|
@ -95,6 +95,91 @@ bfd_check_format (bfd *abfd, bfd_format format) |
|
|
|
return bfd_check_format_matches (abfd, format, NULL); |
|
|
|
} |
|
|
|
|
|
|
|
struct bfd_preserve |
|
|
|
{ |
|
|
|
void *marker; |
|
|
|
void *tdata; |
|
|
|
flagword flags; |
|
|
|
const struct bfd_arch_info *arch_info; |
|
|
|
struct bfd_section *sections; |
|
|
|
struct bfd_section *section_last; |
|
|
|
unsigned int section_count; |
|
|
|
struct bfd_hash_table section_htab; |
|
|
|
}; |
|
|
|
|
|
|
|
/* When testing an object for compatibility with a particular target
|
|
|
|
back-end, the back-end object_p function needs to set up certain |
|
|
|
fields in the bfd on successfully recognizing the object. This |
|
|
|
typically happens in a piecemeal fashion, with failures possible at |
|
|
|
many points. On failure, the bfd is supposed to be restored to its |
|
|
|
initial state, which is virtually impossible. However, restoring a |
|
|
|
subset of the bfd state works in practice. This function stores |
|
|
|
the subset. */ |
|
|
|
|
|
|
|
static bfd_boolean |
|
|
|
bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve) |
|
|
|
{ |
|
|
|
preserve->tdata = abfd->tdata.any; |
|
|
|
preserve->arch_info = abfd->arch_info; |
|
|
|
preserve->flags = abfd->flags; |
|
|
|
preserve->sections = abfd->sections; |
|
|
|
preserve->section_last = abfd->section_last; |
|
|
|
preserve->section_count = abfd->section_count; |
|
|
|
preserve->section_htab = abfd->section_htab; |
|
|
|
preserve->marker = bfd_alloc (abfd, 1); |
|
|
|
if (preserve->marker == NULL) |
|
|
|
return FALSE; |
|
|
|
|
|
|
|
return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc, |
|
|
|
sizeof (struct section_hash_entry)); |
|
|
|
} |
|
|
|
|
|
|
|
/* Clear out a subset of BFD state. */ |
|
|
|
|
|
|
|
static void |
|
|
|
bfd_reinit (bfd *abfd) |
|
|
|
{ |
|
|
|
abfd->tdata.any = NULL; |
|
|
|
abfd->arch_info = &bfd_default_arch_struct; |
|
|
|
abfd->flags &= BFD_FLAGS_SAVED; |
|
|
|
bfd_section_list_clear (abfd); |
|
|
|
} |
|
|
|
|
|
|
|
/* Restores bfd state saved by bfd_preserve_save. */ |
|
|
|
|
|
|
|
static void |
|
|
|
bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve) |
|
|
|
{ |
|
|
|
bfd_hash_table_free (&abfd->section_htab); |
|
|
|
|
|
|
|
abfd->tdata.any = preserve->tdata; |
|
|
|
abfd->arch_info = preserve->arch_info; |
|
|
|
abfd->flags = preserve->flags; |
|
|
|
abfd->section_htab = preserve->section_htab; |
|
|
|
abfd->sections = preserve->sections; |
|
|
|
abfd->section_last = preserve->section_last; |
|
|
|
abfd->section_count = preserve->section_count; |
|
|
|
|
|
|
|
/* bfd_release frees all memory more recently bfd_alloc'd than
|
|
|
|
its arg, as well as its arg. */ |
|
|
|
bfd_release (abfd, preserve->marker); |
|
|
|
preserve->marker = NULL; |
|
|
|
} |
|
|
|
|
|
|
|
/* Called when the bfd state saved by bfd_preserve_save is no longer
|
|
|
|
needed. */ |
|
|
|
|
|
|
|
static void |
|
|
|
bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve) |
|
|
|
{ |
|
|
|
/* It would be nice to be able to free more memory here, eg. old
|
|
|
|
tdata, but that's not possible since these blocks are sitting |
|
|
|
inside bfd_alloc'd memory. The section hash is on a separate |
|
|
|
objalloc. */ |
|
|
|
bfd_hash_table_free (&preserve->section_htab); |
|
|
|
preserve->marker = NULL; |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
FUNCTION |
|
|
|
bfd_check_format_matches |
|
|
|
@ -124,6 +209,7 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ; |
|
|
|
int match_count, best_count, best_match; |
|
|
|
int ar_match_index; |
|
|
|
struct bfd_preserve preserve; |
|
|
|
|
|
|
|
if (matching != NULL) |
|
|
|
*matching = NULL; |
|
|
|
@ -138,12 +224,6 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
if (abfd->format != bfd_unknown) |
|
|
|
return abfd->format == format; |
|
|
|
|
|
|
|
/* Since the target type was defaulted, check them
|
|
|
|
all in the hope that one will be uniquely recognized. */ |
|
|
|
save_targ = abfd->xvec; |
|
|
|
match_count = 0; |
|
|
|
ar_match_index = _bfd_target_vector_entries; |
|
|
|
|
|
|
|
if (matching != NULL || *bfd_associated_vector != NULL) |
|
|
|
{ |
|
|
|
bfd_size_type amt; |
|
|
|
@ -154,14 +234,10 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
return FALSE; |
|
|
|
} |
|
|
|
|
|
|
|
right_targ = 0; |
|
|
|
ar_right_targ = 0; |
|
|
|
match_targ = 0; |
|
|
|
best_match = 256; |
|
|
|
best_count = 0; |
|
|
|
|
|
|
|
/* Presume the answer is yes. */ |
|
|
|
abfd->format = format; |
|
|
|
save_targ = abfd->xvec; |
|
|
|
preserve.marker = NULL; |
|
|
|
|
|
|
|
/* If the target type was explicitly specified, just check that target. */ |
|
|
|
if (!abfd->target_defaulted) |
|
|
|
@ -190,6 +266,16 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
goto err_unrecog; |
|
|
|
} |
|
|
|
|
|
|
|
/* Since the target type was defaulted, check them all in the hope
|
|
|
|
that one will be uniquely recognized. */ |
|
|
|
right_targ = NULL; |
|
|
|
ar_right_targ = NULL; |
|
|
|
match_targ = NULL; |
|
|
|
best_match = 256; |
|
|
|
best_count = 0; |
|
|
|
match_count = 0; |
|
|
|
ar_match_index = _bfd_target_vector_entries; |
|
|
|
|
|
|
|
for (target = bfd_target_vector; *target != NULL; target++) |
|
|
|
{ |
|
|
|
const bfd_target *temp; |
|
|
|
@ -201,7 +287,13 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
|| (*target)->match_priority > best_match) |
|
|
|
continue; |
|
|
|
|
|
|
|
abfd->xvec = *target; /* Change BFD's target temporarily. */ |
|
|
|
/* If we already tried a match, the bfd is modified and may
|
|
|
|
have sections attached, which will confuse the next |
|
|
|
_bfd_check_format call. */ |
|
|
|
bfd_reinit (abfd); |
|
|
|
|
|
|
|
/* Change BFD's target temporarily. */ |
|
|
|
abfd->xvec = *target; |
|
|
|
|
|
|
|
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) |
|
|
|
goto err_ret; |
|
|
|
@ -214,7 +306,11 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
|
|
|
|
temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); |
|
|
|
if (temp) |
|
|
|
match_targ = temp; |
|
|
|
{ |
|
|
|
match_targ = temp; |
|
|
|
if (preserve.marker != NULL) |
|
|
|
bfd_preserve_finish (abfd, &preserve); |
|
|
|
} |
|
|
|
|
|
|
|
if (temp && (abfd->format != bfd_archive || bfd_has_map (abfd))) |
|
|
|
{ |
|
|
|
@ -253,6 +349,9 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
} |
|
|
|
else if (err != bfd_error_wrong_format) |
|
|
|
goto err_ret; |
|
|
|
|
|
|
|
if (temp && !bfd_preserve_save (abfd, &preserve)) |
|
|
|
goto err_ret; |
|
|
|
} |
|
|
|
|
|
|
|
if (best_count == 1) |
|
|
|
@ -298,6 +397,13 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/* There is way too much undoing of half-known state here. We
|
|
|
|
really shouldn't iterate on live bfd's. Note that saving the |
|
|
|
whole bfd and restoring it would be even worse; the first thing |
|
|
|
you notice is that the cached bfd file position gets out of sync. */ |
|
|
|
if (preserve.marker != NULL) |
|
|
|
bfd_preserve_restore (abfd, &preserve); |
|
|
|
|
|
|
|
if (match_count == 1) |
|
|
|
{ |
|
|
|
abfd->xvec = right_targ; |
|
|
|
@ -306,9 +412,11 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
state (except possibly for XVEC). */ |
|
|
|
if (match_targ != right_targ) |
|
|
|
{ |
|
|
|
bfd_reinit (abfd); |
|
|
|
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) |
|
|
|
goto err_ret; |
|
|
|
match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); |
|
|
|
BFD_ASSERT (match_targ != NULL); |
|
|
|
} |
|
|
|
|
|
|
|
ok_ret: |
|
|
|
@ -322,7 +430,9 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
|
|
|
|
if (matching_vector) |
|
|
|
free (matching_vector); |
|
|
|
return TRUE; /* File position has moved, BTW. */ |
|
|
|
|
|
|
|
/* File position has moved, BTW. */ |
|
|
|
return TRUE; |
|
|
|
} |
|
|
|
|
|
|
|
if (match_count == 0) |
|
|
|
@ -334,11 +444,14 @@ bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching) |
|
|
|
abfd->format = bfd_unknown; |
|
|
|
if (matching_vector) |
|
|
|
free (matching_vector); |
|
|
|
if (preserve.marker != NULL) |
|
|
|
bfd_preserve_restore (abfd, &preserve); |
|
|
|
return FALSE; |
|
|
|
} |
|
|
|
|
|
|
|
abfd->xvec = save_targ; /* Restore original target type. */ |
|
|
|
abfd->format = bfd_unknown; /* Restore original format. */ |
|
|
|
/* Restore original target type and format. */ |
|
|
|
abfd->xvec = save_targ; |
|
|
|
abfd->format = bfd_unknown; |
|
|
|
bfd_set_error (bfd_error_file_ambiguously_recognized); |
|
|
|
|
|
|
|
if (matching) |
|
|
|
|
Alan Modra
14 years ago