OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge in changes from gdb-3.95 release into mainstream of BFD development. 

Support defaulted (search all) targets and specific (only check one)
targets.
This commit is contained in:
John Gilmore 1991-05-29 00:20:02 +00:00
parent dcc355360e
commit c0e5039e64
10 changed files with 216 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bfd/Makefile.in
View File

@ -52,7 +52,8 @@ STAGESTUFF = $(TARGETLIB) $(OFILES)
all: $(TARGETLIB)
OFILES = $(BFD_LIBS) $(BFD_BACKENDS)
# XDEPFILES comes from the host config; TDEPFILES from the target config.
OFILES = $(BFD_LIBS) $(BFD_BACKENDS) $(XDEPFILES) $(TDEPFILES)
$(TARGETLIB): $(OFILES)
rm -f $(TARGETLIB)

1
bfd/aoutf1.h
View File

@ -86,6 +86,7 @@ sunos4_callback (abfd)
struct internal_exec *execp = exec_hdr (abfd);
WORK_OUT_FILE_POSITIONS(abfd, execp);
/* Determine the architecture and machine type of the object file. */
switch (N_MACHTYPE (*exec_hdr (abfd))) {

64
bfd/bfd.c
View File

@ -154,35 +154,45 @@ bfd_format_string (format)
/** Target configurations */
extern bfd_target *target_vector[];
extern bfd_target *default_vector[];
/* Returns a pointer to the transfer vector for the object target
named target_name. If target_name is NULL, chooses the one in the
environment variable GNUTARGET; if that is null or not defined then
the first entry in the target list is chosen. Passing in the
string "default" or setting the environment variable to "default"
will cause the first entry in the target list to be returned. */
will cause the first entry in the target list to be returned,
and "target_defaulted" will be set in the bfd. This causes
bfd_check_format to loop over all the targets to find the one
that matches the file being read. */
bfd_target *
DEFUN(bfd_find_target,(target_name),
CONST char *target_name)
DEFUN(bfd_find_target,(target_name, abfd),
CONST char *target_name AND
bfd *abfd)
{
bfd_target **target;
extern char *getenv ();
CONST char *targname = (target_name ? target_name : getenv ("GNUTARGET"));
/* This is safe; the vector cannot be null */
if (targname == NULL || !strcmp (targname, "default"))
return target_vector[0];
if (targname == NULL || !strcmp (targname, "default")) {
abfd->target_defaulted = true;
return abfd->xvec = target_vector[0];
}
abfd->target_defaulted = false;
for (target = &target_vector[0]; *target != NULL; target++) {
if (!strcmp (targname, (*target)->name))
return *target;
return abfd->xvec = *target;
}
bfd_error = invalid_target;
return NULL;
}
/* Returns a freshly-consed, NULL-terminated vector of the names of all the
valid bfd targets. Do not modify the names */
@ -209,16 +219,8 @@ bfd_target_list ()
return name_list;
}
/** Init a bfd for read of the proper format.
*/
/* We should be able to find out if the target was defaulted or user-specified.
If the user specified the target explicitly then we should do no search.
I guess the best way to do this is to pass an extra argument which specifies
the DWIM. */
/* I have chanegd this always to set the filepos to the origin before
guessing. -- Gumby, 14 Februar 1991*/
/* Init a bfd for read of the proper format. If the target was unspecified,
search all the possible targets. */
boolean
DEFUN(bfd_check_format,(abfd, format),
@ -235,22 +237,27 @@ DEFUN(bfd_check_format,(abfd, format),
return false;
}
if (abfd->format != bfd_unknown) return (abfd->format == format) ? true:false;
if (abfd->format != bfd_unknown)
return (abfd->format == format)? true: false;
/* presume the answer is yes */
abfd->format = format;
bfd_seek (abfd, (file_ptr)0, SEEK_SET); /* rewind! */
/* If the target type was explicitly specified, just check that target. */
right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
if (right_targ) {
abfd->xvec = right_targ; /* Set the target as returned */
return true; /* File position has moved, BTW */
if (!abfd->target_defaulted) {
bfd_seek (abfd, (file_ptr)0, SEEK_SET); /* rewind! */
right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
if (right_targ) {
abfd->xvec = right_targ; /* Set the target as returned */
return true; /* File position has moved, BTW */
}
return false; /* Specified target is not right */
}
/* This isn't a <format> file in the specified or defaulted target type.
See if we recognize it for any other target type. (We check them
all to make sure it's uniquely recognized.) */
/* 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;
@ -265,6 +272,11 @@ DEFUN(bfd_check_format,(abfd, format),
if (temp) { /* This format checks out as ok! */
right_targ = temp;
match_count++;
/* If this is the default target, accept it, even if other targets
might match. People who want those other targets have to set
the GNUTARGET variable. */
if (temp == default_vector[0])
break;
#ifdef GNU960
/* Big- and little-endian b.out archives look the same, but it doesn't
* matter: there is no difference in their headers, and member file byte
@ -287,7 +299,7 @@ DEFUN(bfd_check_format,(abfd, format),
bfd_error = ((match_count == 0) ? file_not_recognized :
file_ambiguously_recognized);
return false;
}
}
boolean
DEFUN(bfd_set_format,(abfd, format),

4
bfd/bfd.doc
View File

@ -633,10 +633,10 @@ boolean bfd_set_symtab (bfd *outbfd, asymbol **location,
after using this function (although the storage may be
reclaimed once the bfd has been closed).
If you're done with the symol table you can tell bfd about it by
If you're done with the symbol table you can tell bfd about it by
calling bfd_reclaim_symbol_table, which takes a bfd. Calling this
function will also reclaim any relocation entries you may have
requested. If you don't use this function bfd will keep around all
requested. If you don't use this function, bfd will keep around all
symbol information until the bfd is closed.
Similarly, relocations have a canonical format. See the file bfd.h for

4
bfd/ieee.c
View File

@ -902,7 +902,7 @@ static boolean
DEFUN(ieee_mkobject,(abfd),
bfd *abfd)
{
ieee_data(abfd) = (ieee_data_type *)bfd_alloc(abfd,sizeof(ieee_data_type));
set_tdata (abfd, bfd_alloc(abfd,sizeof(ieee_data_type)));
return true;
}
@ -993,7 +993,7 @@ DEFUN(ieee_object_p,(abfd),
return abfd->xvec;
fail:
(void) bfd_release(abfd, ieee);
ieee_data(abfd) = save;
set_tdata (abfd, save);
return (bfd_target *)NULL;
}

168
bfd/libaout.h
View File

@ -24,6 +24,29 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* $Id$ */
#ifdef __STDC__
#define CAT3(a,b,c) a##b##c
#else
#define CAT3(a,b,c) a/**/b/**/c
#endif
#if ARCH_SIZE==64
#define GET_WORD bfd_h_get_64
#define GET_SWORD (int64_type)GET_WORD
#define PUT_WORD bfd_h_put_64
#define NAME(x,y) CAT3(x,_64_,y)
#define JNAME(x) CAT(x,_64)
#define BYTES_IN_WORD 8
#else
#define GET_WORD bfd_h_get_32
#define GET_SWORD (int32_type)GET_WORD
#define PUT_WORD bfd_h_put_32
#define NAME(x,y) CAT3(x,_32_,y)
#define JNAME(x) CAT(x,_32)
#define BYTES_IN_WORD 4
#endif
#define adata(bfd) ((struct aoutdata *) ((bfd)->tdata))
#define exec_hdr(bfd) (adata(bfd)->hdr)
#define obj_textsec(bfd) (adata(bfd)->textsec)
@ -42,7 +65,7 @@ typedef struct aout_symbol {
} aout_symbol_type;
struct aoutdata {
struct exec *hdr; /* exec file header */
struct internal_exec *hdr; /* exec file header */
aout_symbol_type *symbols; /* symtab for input bfd */
@ -74,52 +97,133 @@ struct aoutdata {
#define get_tdata(x) ((struct aoutdata *)((x)->tdata))
/* Prototype declarations for functions defined in aout.c. */
/* Prototype declarations for functions defined in aoutx.h */
PROTO (boolean, aout_squirt_out_relocs,(bfd *abfd, asection *section));
PROTO (boolean, NAME(aout,squirt_out_relocs),(bfd *abfd, asection *section));
PROTO (bfd_target *, some_aout_object_p, (bfd *abfd,
PROTO (bfd_target *, NAME(aout,some_aout_object_p), (bfd *abfd,
bfd_target *(*callback)()));
PROTO (boolean, aout_mkobject, (bfd *abfd));
PROTO (enum machine_type, aout_machine_type, (enum bfd_architecture arch,
PROTO (boolean, NAME(aout,mkobject), (bfd *abfd));
PROTO (enum machine_type, NAME(aout,machine_type), (enum bfd_architecture arch,
unsigned long machine));
PROTO (boolean, aout_set_arch_mach, (bfd *abfd, enum bfd_architecture arch,
PROTO (boolean, NAME(aout,set_arch_mach), (bfd *abfd, enum bfd_architecture arch,
unsigned long machine));
PROTO (boolean, aout_new_section_hook, (bfd *abfd, asection *newsect));
PROTO (boolean, aout_set_section_contents, (bfd *abfd, sec_ptr section,
PTR location, file_ptr offset, int count));
PROTO (boolean, NAME(aout,new_section_hook), (bfd *abfd, asection *newsect));
PROTO (boolean, NAME(aout,set_section_contents), (bfd *abfd, sec_ptr section,
PTR location, file_ptr offset, bfd_size_type count));
PROTO (asymbol *, aout_make_empty_symbol, (bfd *abfd));
PROTO (boolean, aout_slurp_symbol_table, (bfd *abfd));
PROTO (void, aout_write_syms, (bfd *abfd));
PROTO (void, aout_reclaim_symbol_table, (bfd *abfd));
PROTO (unsigned int, aout_get_symtab_upper_bound, (bfd *abfd));
PROTO (unsigned int, aout_get_symtab, (bfd *abfd, asymbol **location));
PROTO (boolean, aout_slurp_reloc_table, (bfd *abfd, sec_ptr asect,
PROTO (asymbol *,NAME(aout,make_empty_symbol), (bfd *abfd));
PROTO (boolean, NAME(aout,slurp_symbol_table), (bfd *abfd));
PROTO (void, NAME(aout,write_syms), (bfd *abfd));
PROTO (void, NAME(aout,reclaim_symbol_table), (bfd *abfd));
PROTO (unsigned int, NAME(aout,get_symtab_upper_bound), (bfd *abfd));
PROTO (unsigned int, NAME(aout,get_symtab), (bfd *abfd, asymbol **location));
PROTO (boolean, NAME(aout,slurp_reloc_table), (bfd *abfd, sec_ptr asect,
asymbol **symbols));
PROTO (unsigned int, aout_canonicalize_reloc, (bfd *abfd, sec_ptr section,
PROTO (unsigned int, NAME(aout,canonicalize_reloc), (bfd *abfd, sec_ptr section,
arelent **relptr, asymbol **symbols));
PROTO (unsigned int, aout_get_reloc_upper_bound, (bfd *abfd, sec_ptr asect));
PROTO (void, aout_reclaim_reloc, (bfd *ignore_abfd, sec_ptr ignore));
PROTO (alent *, aout_get_lineno, (bfd *ignore_abfd, asymbol *ignore_symbol));
PROTO (void, aout_print_symbol, (bfd *ignore_abfd, PTR file,
PROTO (unsigned int, NAME(aout,get_reloc_upper_bound), (bfd *abfd, sec_ptr asect));
PROTO (void, NAME(aout,reclaim_reloc), (bfd *ignore_abfd, sec_ptr ignore));
PROTO (alent *, NAME(aout,get_lineno), (bfd *ignore_abfd, asymbol *ignore_symbol));
PROTO (void, NAME(aout,print_symbol), (bfd *ignore_abfd, PTR file,
asymbol *symbol, bfd_print_symbol_enum_type how));
PROTO (boolean, aout_close_and_cleanup, (bfd *abfd));
PROTO (boolean, aout_find_nearest_line, (bfd *abfd, asection *section,
PROTO (boolean, NAME(aout,close_and_cleanup), (bfd *abfd));
PROTO (boolean, NAME(aout,find_nearest_line), (bfd *abfd, asection *section,
asymbol **symbols, bfd_vma offset, CONST char **filename_ptr,
CONST char **functionname_ptr, unsigned int *line_ptr));
PROTO (int, aout_sizeof_headers, (bfd *ignore_abfd));
PROTO (int, NAME(aout,sizeof_headers), (bfd *ignore_abfd, boolean exec));
/* Helper routines in aout.c. */
PROTO (void, bfd_aout_swap_exec_header_in, (bfd *abfd,
unsigned char *raw_bytes, struct exec *execp));
PROTO (void, NAME(aout,swap_exec_header_in), (bfd *abfd,
struct external_exec *raw_bytes, struct internal_exec *execp));
PROTO (void, bfd_aout_swap_exec_header_out,(bfd *abfd, struct exec *execp,
unsigned char *raw_bytes));
PROTO (void, NAME(aout,swap_exec_header_out),(bfd *abfd, struct internal_exec *execp,
struct external_exec *raw_bytes));
/* A.out uses the generic versions of these routines... */
#define aout_get_section_contents bfd_generic_get_section_contents
#define aout_close_and_cleanup bfd_generic_close_and_cleanup
#define aout_32_get_section_contents bfd_generic_get_section_contents
#define aout_32_close_and_cleanup bfd_generic_close_and_cleanup
#define aout_64_get_section_contents bfd_generic_get_section_contents
#define aout_64_close_and_cleanup bfd_generic_close_and_cleanup
/* Calculate the file positions of the parts of a newly read aout header */
#define WORK_OUT_FILE_POSITIONS(abfd, execp) \
obj_datasec (abfd)->vma = N_DATADDR(*execp); \
obj_bsssec (abfd)->vma = N_BSSADDR(*execp); \
obj_textsec (abfd)->vma = N_TXTADDR(*execp); \
\
/* The file offsets of the sections */ \
obj_textsec (abfd)->filepos = N_TXTOFF (*execp); \
obj_datasec (abfd)->filepos = N_DATOFF (*execp); \
\
/* The file offsets of the relocation info */ \
obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp); \
obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp); \
\
/* The file offsets of the string table and symbol table. */ \
obj_sym_filepos (abfd) = N_SYMOFF (*execp); \
obj_str_filepos (abfd) = N_STROFF (*execp); \
#define WRITE_HEADERS(abfd, execp) \
{ \
if (abfd->flags & D_PAGED) \
{ \
execp->a_text = obj_textsec (abfd)->size + EXEC_BYTES_SIZE; \
N_SET_MAGIC (*execp, ZMAGIC); \
} \
else if (abfd->flags & WP_TEXT) \
{ \
N_SET_MAGIC (*execp, NMAGIC); \
} \
else { \
N_SET_MAGIC(*execp, OMAGIC); \
} \
if (abfd->flags & D_PAGED) \
{ \
data_pad = ((obj_datasec(abfd)->size + PAGE_SIZE -1) \
& (- PAGE_SIZE)) - obj_datasec(abfd)->size; \
\
if (data_pad > obj_bsssec(abfd)->size) \
execp->a_bss = 0; \
else \
execp->a_bss = obj_bsssec(abfd)->size - data_pad; \
execp->a_data = obj_datasec(abfd)->size + data_pad; \
} \
else \
{ \
execp->a_data = obj_datasec (abfd)->size; \
execp->a_bss = obj_bsssec (abfd)->size; \
} \
\
execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_LIST_SIZE; \
execp->a_entry = bfd_get_start_address (abfd); \
\
execp->a_trsize = ((obj_textsec (abfd)->reloc_count) * \
obj_reloc_entry_size (abfd)); \
execp->a_drsize = ((obj_datasec (abfd)->reloc_count) * \
obj_reloc_entry_size (abfd)); \
NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes); \
\
bfd_seek (abfd, 0L, false); \
bfd_write ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd); \
/* Now write out reloc info, followed by syms and strings */ \
\
if (bfd_get_symcount (abfd) != 0) \
{ \
bfd_seek (abfd, \
(long)(N_SYMOFF(*execp)), false); \
\
NAME(aout,write_syms)(abfd); \
\
bfd_seek (abfd, (long)(N_TRELOFF(*execp)), false); \
\
if (!NAME(aout,squirt_out_relocs) (abfd, obj_textsec (abfd))) return false; \
bfd_seek (abfd, (long)(N_DRELOFF(*execp)), false); \
\
if (!NAME(aout,squirt_out_relocs)(abfd, obj_datasec (abfd))) return false; \
} \
}

2
bfd/libbfd.h
View File

@ -67,7 +67,7 @@ PROTO(PTR, bfd_zalloc,(bfd *abfd, bfd_size_type size));
PROTO(PTR, bfd_realloc,(bfd *abfd, PTR orig, bfd_size_type new));
#define bfd_release(x,y) (void) obstack_free(&(x->memory),y)
PROTO (bfd_target *, bfd_find_target, (CONST char *target_name));
PROTO (bfd_target *, bfd_find_target, (CONST char *target_name, bfd *));
PROTO (bfd_size_type, bfd_read, (PTR ptr, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
PROTO (bfd_size_type, bfd_write, (PTR ptr, bfd_size_type size, bfd_size_type nitems, bfd *abfd));

2
bfd/oasys.c
View File

@ -394,7 +394,7 @@ DEFUN(oasys_object_p,(abfd),
fail:
(void) bfd_release(abfd, oasys);
oasys_data(abfd) = save;
set_tdata (abfd, save);
return (bfd_target *)NULL;
}

41
bfd/opncls.c
View File

@ -107,21 +107,19 @@ DEFUN(bfd_openr, (filename, target),
bfd *nbfd;
bfd_target *target_vec;
target_vec = bfd_find_target (target);
if (target_vec == NULL) {
bfd_error = invalid_target;
return NULL;
}
bfd_error = system_call_error;
nbfd = new_bfd();
if (nbfd == NULL) {
bfd_error = no_memory;
return NULL;
}
target_vec = bfd_find_target (target, nbfd);
if (target_vec == NULL) {
bfd_error = invalid_target;
return NULL;
}
nbfd->filename = filename;
nbfd->xvec = target_vec;
nbfd->direction = read_direction;
if (bfd_open_file (nbfd) == NULL) {
@ -155,12 +153,6 @@ DEFUN(bfd_fdopenr,(filename, target, fd),
struct flock lock, *lockp = &lock;
#endif
target_vec = bfd_find_target (target);
if (target_vec == NULL) {
bfd_error = invalid_target;
return NULL;
}
bfd_error = system_call_error;
fdflags = fcntl (fd, F_GETFL);
@ -177,6 +169,13 @@ DEFUN(bfd_fdopenr,(filename, target, fd),
bfd_error = no_memory;
return NULL;
}
target_vec = bfd_find_target (target, nbfd);
if (target_vec == NULL) {
bfd_error = invalid_target;
return NULL;
}
#ifdef BFD_LOCKS
nbfd->lock = (struct flock *) (nbfd + 1);
#endif
@ -190,7 +189,6 @@ DEFUN(bfd_fdopenr,(filename, target, fd),
/* OK, put everything where it belongs */
nbfd->filename = filename;
nbfd->xvec = target_vec;
/* As a special case we allow a FD open for read/write to
be written through, although doing so requires that we end
@ -206,7 +204,7 @@ DEFUN(bfd_fdopenr,(filename, target, fd),
memcpy (nbfd->lock, lockp, sizeof (struct flock))
#endif
bfd_cache_init (nbfd);
bfd_cache_init (nbfd);
return nbfd;
}
@ -224,9 +222,6 @@ DEFUN(bfd_openw,(filename, target),
bfd *nbfd;
bfd_target *target_vec;
target_vec = bfd_find_target (target);
if (target_vec == NULL) return NULL;
bfd_error = system_call_error;
/* nbfd has to point to head of malloc'ed block so that bfd_close may
@ -238,8 +233,10 @@ DEFUN(bfd_openw,(filename, target),
return NULL;
}
target_vec = bfd_find_target (target, nbfd);
if (target_vec == NULL) return NULL;
nbfd->filename = filename;
nbfd->xvec = target_vec;
nbfd->direction = write_direction;
if (bfd_open_file (nbfd) == NULL) {
@ -249,10 +246,8 @@ DEFUN(bfd_openw,(filename, target),
}
return nbfd;
}
/** Close up shop, get your deposit back. */
/* Close up shop, get your deposit back. */
boolean
bfd_close (abfd)
bfd *abfd;

16
bfd/targets.c
View File

@ -41,6 +41,10 @@ extern bfd_target m88k_bcs_vec;
extern bfd_target m68kcoff_vec;
extern bfd_target i386coff_vec;
#ifdef DEFAULT_VECTOR
extern bfd_target DEFAULT_VECTOR;
#endif
#ifdef GNU960
#define ICOFF_LITTLE_VEC icoff_little_vec
#define ICOFF_BIG_VEC icoff_big_vec
@ -128,6 +132,16 @@ bfd_target *target_vector[] = {
&M68KCOFF_VEC,
#endif /* M68KCOFF_VEC */
NULL, /* end of list marker */
};
/* default_vector[0] contains either the address of the default vector,
if there is one, or zero if there isn't. */
bfd_target *default_vector[] = {
#ifdef DEFAULT_VECTOR
&DEFAULT_VECTOR,
#endif
0,
};