diff options
Diffstat (limited to 'bfd/archures.c')
| -rw-r--r-- | bfd/archures.c | 765 |
1 files changed, 442 insertions, 323 deletions
diff --git a/bfd/archures.c b/bfd/archures.c index 55295a9..4ffb328 100644 --- a/bfd/archures.c +++ b/bfd/archures.c @@ -1,6 +1,7 @@ /* BFD library support routines for architectures. Copyright (C) 1990-1991 Free Software Foundation, Inc. - Hacked by John Gilmore of Cygnus Support. + Hacked by John Gilmore and Steve Chamberlain of Cygnus Support. + This file is part of BFD, the Binary File Descriptor library. @@ -21,9 +22,25 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /*doc* @section Architectures BFD's idea of an architecture is implimented in @code{archures.c}. BFD -keeps two atoms in a BFD describing the architecture of the data -attached to the BFD, the @code{enum bfd_architecture arch} field and -the @code{unsigned long machine} field. +keeps one atoms in a BFD describing the architecture of the data +attached to the BFD; a pointer to a @code{bfd_arch_info_struct}. + +Pointers to structures can be requested independently of a bfd so that +an archictectures information can be interrogated without access to an +open bfd. + +The arch information is provided by each architecture package. The +set of default architectures is selected by the #define +@code{SELECT_ARCHITECTURES}. This is normally set up in the +@ital{config/h-} file of your choice. If the name is not defined, +then all the architectures supported are included. + +When BFD starts up, all the architectures are called with an +initialize method. It is up to the architecture back end to insert as +many items into the list of arches as it wants to, generally this +would be one for each machine and one for the default case (an item +with a machine field of 0). + */ /*proto* bfd_architecture @@ -70,7 +87,7 @@ enum bfd_architecture bfd_arch_convex, {* Convex *} bfd_arch_m88k, {* Motorola 88xxx *} bfd_arch_pyramid, {* Pyramid Technology *} - bfd_arch_h8_300, {* Hitachi H8/300 *} + bfd_arch_h8300, {* Hitachi H8/300 *} bfd_arch_last }; *- @@ -85,44 +102,49 @@ stuff #include <sysdep.h> #include "bfd.h" +#include "libbfd.h" + +/*proto* bfd_arch_info_struct +This structure contains information on architectures. +*+ +typedef int bfd_reloc_code_enum_type; + +typedef struct bfd_arch_info_struct +{ + int bits_per_word; + int bits_per_address; + int bits_per_byte; + enum bfd_architecture arch; + long mach; + char *arch_name; + CONST char *printable_name; +{* true if this is the default machine for the architecture *} + boolean the_default; + CONST struct bfd_arch_info_struct * EXFUN((*compatible),(CONST struct bfd_arch_info_struct *a, + CONST struct bfd_arch_info_struct *b)); + + + boolean EXFUN((*scan),(CONST struct bfd_arch_info_struct *,CONST char *)); + unsigned int EXFUN((*disassemble),(bfd_vma addr, CONST char *data, + PTR stream)); + CONST struct reloc_howto_struct *EXFUN((*reloc_type_lookup), (bfd_reloc_code_enum_type code)); -static char *prt_num_mach (); -static boolean scan_num_mach (); -static char *prt_960_mach (); -static boolean scan_960_mach (); - -struct arch_print { - enum bfd_architecture arch; - char *astr; - char *(*mach_print)(); - boolean (*mach_scan)(); -} arch_print[] = { - - {bfd_arch_unknown, "unknown", prt_num_mach, scan_num_mach}, - {bfd_arch_obscure, "obscure", prt_num_mach, scan_num_mach}, - {bfd_arch_m68k, "m68k", prt_num_mach, scan_num_mach}, - {bfd_arch_vax, "vax", prt_num_mach, scan_num_mach}, - {bfd_arch_i960, "i960", prt_960_mach, scan_960_mach}, - {bfd_arch_a29k, "a29k", prt_num_mach, scan_num_mach}, - {bfd_arch_sparc, "sparc", prt_num_mach, scan_num_mach}, - {bfd_arch_mips, "mips", prt_num_mach, scan_num_mach}, - {bfd_arch_i386, "i386", prt_num_mach, scan_num_mach}, - {bfd_arch_ns32k, "ns32k", prt_num_mach, scan_num_mach}, - {bfd_arch_tahoe, "tahoe", prt_num_mach, scan_num_mach}, - {bfd_arch_i860, "i860", prt_num_mach, scan_num_mach}, - {bfd_arch_romp, "romp", prt_num_mach, scan_num_mach}, - {bfd_arch_alliant, "alliant", prt_num_mach, scan_num_mach}, - {bfd_arch_convex, "convex", prt_num_mach, scan_num_mach}, - {bfd_arch_m88k, "m88k", prt_num_mach, scan_num_mach}, - {bfd_arch_pyramid, "pyramid", prt_num_mach, scan_num_mach}, - {bfd_arch_h8_300, "H8/300", prt_num_mach, scan_num_mach}, - {bfd_arch_unknown, (char *)0, prt_num_mach, scan_num_mach}, -}; - -/*proto* bfd_prinable_arch_mach + struct bfd_arch_info_struct *next; + +} bfd_arch_info_struct_type; + + +*- +*/ + +bfd_arch_info_struct_type *bfd_arch_info_list; + +/*proto* bfd_printable_arch_mach Return a printable string representing the architecture and machine -type. The result is only good until the next call to -@code{bfd_printable_arch_mach}. +type. + +NB. The use of this routine is depreciated. + *; PROTO(CONST char *,bfd_printable_arch_mach, (enum bfd_architecture arch, unsigned long machine)); */ @@ -132,333 +154,430 @@ DEFUN(bfd_printable_arch_mach,(arch, machine), enum bfd_architecture arch AND unsigned long machine) { - struct arch_print *ap; - - for (ap = arch_print; ap->astr; ap++) { - if (ap->arch == arch) { - if (machine == 0) - return ap->astr; - return (*ap->mach_print)(ap, machine); + bfd_arch_info_struct_type *ap; + + for (ap = bfd_arch_info_list; + ap != (bfd_arch_info_struct_type *)NULL; + ap = ap->next) { + if (ap->arch == arch && + ((ap->mach == machine) || (ap->the_default && machine == 0))) { + return ap->printable_name; } } return "UNKNOWN!"; } -static char * -prt_num_mach (ap, machine) - struct arch_print *ap; - unsigned long machine; -{ - static char result[20]; - sprintf(result, "%s:%ld", ap->astr, (long) machine); - return result; +/*proto* bfd_printable_name + +Return a printable string representing the architecture and machine +from the pointer to the arch info structure + +*; CONST char *EXFUN(bfd_printable_name,(bfd *abfd)); + +*/ + +CONST char * +DEFUN(bfd_printable_name, (abfd), + bfd *abfd) +{ + return abfd->arch_info->printable_name; } + + /*proto* -*i bfd_scan_arch_mach -Scan a string and attempt to turn it into an archive and machine type combination. -*; PROTO(boolean, bfd_scan_arch_mach, - (CONST char *, enum bfd_architecture *, unsigned long *)); +*i bfd_scan_arch +This routine is provided with a string and tries to work out if bfd +supports any cpu which could be described with the name provided. The +routine returns a pointer to an arch_info structure if a machine is +found, otherwise NULL. + +*; bfd_arch_info_struct_type *EXFUN(bfd_scan_arch,(CONST char *)); */ -boolean -DEFUN(bfd_scan_arch_mach,(string, archp, machinep), - CONST char *string AND - enum bfd_architecture *archp AND - unsigned long *machinep) +bfd_arch_info_struct_type * +DEFUN(bfd_scan_arch,(string), + CONST char *string) { - struct arch_print *ap; - int len; - - /* First look for an architecture, possibly followed by machtype. */ - for (ap = arch_print; ap->astr; ap++) { - if (ap->astr[0] != string[0]) + struct bfd_arch_info_struct *ap; + + /* Look through all the installed architectures */ + for (ap = bfd_arch_info_list; + ap != (bfd_arch_info_struct_type *)NULL; + ap = ap->next) { + /* Don't bother with anything if the first chars don't match */ + if (ap->arch_name[0] != string[0]) continue; - len = strlen (ap->astr); - if (!strncmp (ap->astr, string, len)) { - /* We found the architecture, now see about the machine type */ - if (archp) - *archp = ap->arch; - if (string[len] != '\0') { - if (ap->mach_scan (string+len, ap, archp, machinep, 1)) - return true; - } - if (machinep) - *machinep = 0; - return true; - } + if (ap->scan(ap, string)) + return ap; } + return (bfd_arch_info_struct_type *)NULL; +} + - /* Couldn't find an architecture -- try for just a machine type */ - for (ap = arch_print; ap->astr; ap++) { - if (ap->mach_scan (string, ap, archp, machinep, 0)) - return true; - } - return false; +/*proto* bfd_arch_get_compatible +This routine is used to determine whether two BFDs' architectures and +machine types are compatible. It calculates the lowest common +denominator between the two architectures and machine types implied by +the BFDs and returns a pointer to an arch_info structure describing +the compatible machine. + +*; CONST bfd_arch_info_struct_type *EXFUN(bfd_arch_get_compatible, + (CONST bfd *abfd, + CONST bfd *bbfd)); +*/ + +CONST bfd_arch_info_struct_type * +DEFUN(bfd_arch_get_compatible,(abfd, bbfd), +CONST bfd *abfd AND +CONST bfd *bbfd) + +{ + return abfd->arch_info->compatible(abfd->arch_info,bbfd->arch_info); } -static boolean -scan_num_mach (string, ap, archp, machinep, archspec) - char *string; - struct arch_print *ap; - enum bfd_architecture *archp; - unsigned long *machinep; - int archspec; + +/*proto-internal* bfd_default_arch_struct + +What bfds are seeded with + +*+ +extern bfd_arch_info_struct_type bfd_default_arch_struct; +*- +*/ + +bfd_arch_info_struct_type bfd_default_arch_struct = + { + 32,32,8,bfd_arch_unknown,0,"unknown","unknown",true, + bfd_default_compatible, bfd_default_scan, + + }; + +/*proto* bfd_set_arch_info + +*; void EXFUN(bfd_set_arch_info,(bfd *, bfd_arch_info_struct_type *)); + +*/ + +void DEFUN(bfd_set_arch_info,(abfd, arg), +bfd *abfd AND +bfd_arch_info_struct_type *arg) { - enum bfd_architecture arch; - unsigned long machine; - char achar; - - if (archspec) { - - /* Architecture already specified, now go for machine type. */ - if (string[0] != ':') - return false; - /* We'll take any valid number that occupies the entire string */ - if (1 != sscanf (string+1, "%lu%c", &machine, &achar)) - return false; - arch = ap->arch; - - } else { - - /* We couldn't identify an architecture prefix. Perhaps the entire - thing is a machine type. Be a lot picker. */ - if (1 != sscanf (string, "%lu%c", &machine, &achar)) - return false; - switch (machine) { - case 68010: - case 68020: - case 68030: - case 68040: - case 68332: - case 68050: arch = bfd_arch_m68k; break; - case 68000: arch = bfd_arch_m68k; machine = 0; break; - - case 80960: - case 960: arch = bfd_arch_i960; machine = 0; break; - - case 386: - case 80386: arch = bfd_arch_i386; machine = 0; break; - case 486: arch = bfd_arch_i386; break; - - case 29000: arch = bfd_arch_a29k; machine = 0; break; - - case 32016: - case 32032: - case 32132: - case 32232: - case 32332: - case 32432: - case 32532: arch = bfd_arch_ns32k; break; - case 32000: arch = bfd_arch_ns32k; machine = 0; break; - - case 860: - case 80860: arch = bfd_arch_i860; machine = 0; break; - - default: return false; + abfd->arch_info = arg; +} + +/*proto-internal* bfd_default_set_arch_mach + +Set the architecture and machine type in a bfd. This finds the correct +pointer to structure and inserts it into the arch_info pointer. + +*; boolean EXFUN(bfd_default_set_arch_mach,(bfd *abfd, + enum bfd_architecture arch, + unsigned long mach)); + +*/ + +boolean DEFUN(bfd_default_set_arch_mach,(abfd, arch, mach), + bfd *abfd AND + enum bfd_architecture arch AND + unsigned long mach) +{ + static struct bfd_arch_info_struct *old_ptr = &bfd_default_arch_struct; + boolean found = false; + /* run through the table to find the one we want, we keep a little + cache to speed things up */ + if (old_ptr == 0 || arch != old_ptr->arch || mach != old_ptr->mach) { + bfd_arch_info_struct_type *ptr; + old_ptr = (bfd_arch_info_struct_type *)NULL; + for (ptr = bfd_arch_info_list; + ptr != (bfd_arch_info_struct_type *)NULL; + ptr= ptr->next) { + if (ptr->arch == arch && + ((ptr->mach == mach) || (ptr->the_default && mach == 0))) { + old_ptr = ptr; + found = true; + break; + } } + if (found==false) { + /*looked for it and it wasn't there, so put in the default */ + old_ptr = &bfd_default_arch_struct; + + } + } + else { + /* it was in the cache */ + found = true; } - if (archp) - *archp = arch; - if (machinep) - *machinep = machine; - return true; + abfd->arch_info = old_ptr; + + return found; } - -/* Intel 960 machine variants. */ -static char * -prt_960_mach (ap, machine) - struct arch_print *ap; - unsigned long machine; + + + + +/*proto* bfd_get_arch + +Returns the enumerated type which describes the supplied bfd's +architecture + +*; enum bfd_architecture EXFUN(bfd_get_arch, (bfd *abfd)); +*/ + + enum bfd_architecture DEFUN(bfd_get_arch, (abfd), bfd *abfd) + { + return abfd->arch_info->arch; + + + } + +/*proto* bfd_get_mach + +Returns the long type which describes the supplied bfd's +machine + +*; unsigned long EXFUN(bfd_get_mach, (bfd *abfd)); +*/ + +unsigned long DEFUN(bfd_get_mach, (abfd), bfd *abfd) { - static char result[20]; - char *str; - - switch (machine) { - case bfd_mach_i960_core: str = "core"; break; - case bfd_mach_i960_kb_sb: str = "kb"; break; - case bfd_mach_i960_mc: str = "mc"; break; - case bfd_mach_i960_xa: str = "xa"; break; - case bfd_mach_i960_ca: str = "ca"; break; - case bfd_mach_i960_ka_sa: str = "ka"; break; - default: - return prt_num_mach (ap, machine); + return abfd->arch_info->mach; + } + +/*proto* bfd_arch_bits_per_byte + +Returns the number of bits in one of the architectures bytes + +*; unsigned int EXFUN(bfd_arch_bits_per_byte, (bfd *abfd)); +*/ + +unsigned int DEFUN(bfd_arch_bits_per_byte, (abfd), bfd *abfd) + { + return abfd->arch_info->bits_per_byte; + } + +/*proto* bfd_arch_bits_per_address + +Returns the number of bits in one of the architectures addresses + +*; unsigned int EXFUN(bfd_arch_bits_per_address, (bfd *abfd)); +*/ + +unsigned int DEFUN(bfd_arch_bits_per_address, (abfd), bfd *abfd) + { + return abfd->arch_info->bits_per_address; } - sprintf (result, "%s:%s", ap->astr, str); - return result; + + + +extern void EXFUN(bfd_h8300_arch,(void)); +extern void EXFUN(bfd_i960_arch,(void)); +extern void EXFUN(bfd_empty_arch,(void)); +extern void EXFUN(bfd_sparc_arch,(void)); +extern void EXFUN(bfd_m88k_arch,(void)); +extern void EXFUN(bfd_m68k_arch,(void)); +extern void EXFUN(bfd_vax_arch,(void)); +extern void EXFUN(bfd_a29k_arch,(void)); +extern void EXFUN(bfd_mips_arch,(void)); +extern void EXFUN(bfd_i386_arch,(void)); + + + +static void EXFUN((*archures_init_table[]),()) = +{ +#ifdef SELECT_ARCHITECTURES + SELECT_ARCHITECTURES, +#else + bfd_sparc_arch, + bfd_a29k_arch, + bfd_mips_arch, + bfd_h8300_arch, + bfd_i386_arch, + bfd_m88k_arch, + bfd_i960_arch, + bfd_m68k_arch, + bfd_vax_arch, +#endif + 0 + }; + + + +/*proto-internal* + +This routine initializes the architecture dispatch table by calling +all installed architecture packages and getting them to poke around. + +*; PROTO(void, bfd_arch_init,(void)); + +*/ + +void +DEFUN_VOID(bfd_arch_init) +{ + void EXFUN((**ptable),()); + for (ptable = archures_init_table; + *ptable ; + ptable++) + { + (*ptable)(); + } } -static boolean -scan_960_mach (string, ap, archp, machinep, archspec) - char *string; - struct arch_print *ap; - enum bfd_architecture *archp; - unsigned long *machinep; - int archspec; + +/*proto-internal* bfd_arch_linkin + +Link the provided arch info structure into the list + +*; void EXFUN(bfd_arch_linkin,(bfd_arch_info_struct_type *)); + +*/ + +void DEFUN(bfd_arch_linkin,(ptr), + bfd_arch_info_struct_type *ptr) { - unsigned long machine; + ptr->next = bfd_arch_info_list; + bfd_arch_info_list = ptr; +} - if (!archspec) - return false; - if (string[0] != ':') - return false; - string++; - if (string[0] == '\0') - return false; - if (string[0] == 'c' && string[1] == 'o' && string[2] == 'r' && - string[3] == 'e' && string[4] == '\0') - machine = bfd_mach_i960_core; - else if (string[1] == '\0' || string[2] != '\0') /* rest are 2-char */ - return false; - else if (string[0] == 'k' && string[1] == 'b') - machine = bfd_mach_i960_kb_sb; - else if (string[0] == 's' && string[1] == 'b') - machine = bfd_mach_i960_kb_sb; - else if (string[0] == 'm' && string[1] == 'c') - machine = bfd_mach_i960_mc; - else if (string[0] == 'x' && string[1] == 'a') - machine = bfd_mach_i960_xa; - else if (string[0] == 'c' && string[1] == 'a') - machine = bfd_mach_i960_ca; - else if (string[0] == 'k' && string[1] == 'a') - machine = bfd_mach_i960_ka_sa; - else if (string[0] == 's' && string[1] == 'a') - machine = bfd_mach_i960_ka_sa; - else - return false; - if (archp) - *archp = ap->arch; - if (machinep) - *machinep = machine; - return true; +/*proto-internal* bfd_default_compatible + +The default function for testing for compatibility + +*; CONST bfd_arch_info_struct_type *EXFUN(bfd_default_compatible, + (CONST bfd_arch_info_struct_type *a, + CONST bfd_arch_info_struct_type *b)); +*/ + +CONST bfd_arch_info_struct_type * +DEFUN(bfd_default_compatible,(a,b), + CONST bfd_arch_info_struct_type *a AND + CONST bfd_arch_info_struct_type *b) +{ + if(a->arch != b->arch) return (bfd_arch_info_struct_type *)NULL; + + if (a->mach > b->mach) { + return a; + } + if (b->mach > a->mach) { + return b; + } + return a; } +/*proto-internal* bfd_default_scan +The default function for working out whether this is an architecture +hit and a machine hit - -/*proto* -*i bfd_arch_compatible -This routine is used to determine whether two BFDs' architectures and machine types are -compatible. It calculates the lowest common denominator between the -two architectures and machine types implied by the BFDs and sets the -objects pointed at by @var{archp} and @var{machine} if non NULL. - -This routine returns @code{true} if the BFDs are of compatible type, -otherwise @code{false}. -*; PROTO(boolean, bfd_arch_compatible, - (bfd *abfd, - bfd *bbfd, - enum bfd_architecture *archp, - unsigned long *machinep)); -*-*/ - -boolean -DEFUN(bfd_arch_compatible,(abfd, bbfd, archp, machinep), - bfd *abfd AND - bfd *bbfd AND - enum bfd_architecture *archp AND - unsigned long *machinep) +*; boolean EXFUN(bfd_default_scan,(CONST struct bfd_arch_info_struct *, CONST char *)); + +*/ + +boolean +DEFUN(bfd_default_scan,(info, string), +CONST struct bfd_arch_info_struct *info AND +CONST char *string) { - enum bfd_architecture archa, archb; - unsigned long macha, machb; - int pick_a; - - archa = bfd_get_architecture (abfd); - archb = bfd_get_architecture (bbfd); - macha = bfd_get_machine (abfd); - machb = bfd_get_machine (bbfd); - - if (archb == bfd_arch_unknown) - pick_a = 1; - else if (archa == bfd_arch_unknown) - pick_a = 0; - else if (archa != archb) - return false; /* Not compatible */ - else { - /* Architectures are the same. Check machine types. */ - if (macha == machb) /* Same machine type */ - pick_a = 1; - else if (machb == 0) /* B is default */ - pick_a = 1; - else if (macha == 0) /* A is default */ - pick_a = 0; - else switch (archa) { - /* If particular machine types of one architecture are not - compatible with each other, this is the place to put those tests - (returning false if incompatible). */ - - case bfd_arch_i960: - /* The i960 has two distinct subspecies which may not interbreed: - CORE CA - CORE KA KB MC - Any architecture on the same line is compatible, the one on - the right is the least restrictive. */ - /* So, if either is a ca then the other must be a be core or ca */ - if (macha == bfd_mach_i960_ca) { - if (machb != bfd_mach_i960_ca && - machb != bfd_mach_i960_core) { - return false; - } - pick_a = 1; - } - else if (machb == bfd_mach_i960_ca) { - if (macha != bfd_mach_i960_ca && - macha != bfd_mach_i960_core) { - return false; - } - pick_a = 0; - } - else { - /* This must be from the bottom row, so take the higest */ - pick_a = (macha > machb); - } - break; - - /* For these chips, as far as we care, "lower" numbers are included - by "higher" numbers, e.g. merge 68010 and 68020 into 68020, - 386 and 486 into 486, etc. This will need to change - if&when we care about things like 68332. */ - case bfd_arch_m68k: - case bfd_arch_ns32k: - case bfd_arch_i386: - pick_a = (macha > machb); - break; - - /* By default, pick first file's type, for lack of something better. */ - default: - pick_a = 1; - } + CONST char *ptr_src; + CONST char *ptr_tst; + unsigned long number; + enum bfd_architecture arch; + /* First test for an exact match */ + if (strcmp(string, info->printable_name) == 0) return true; + + /* See how much of the supplied string matches with the + architecture, eg the string m68k:68020 would match the 68k entry + up to the :, then we get left with the machine number */ + + for (ptr_src = string, + ptr_tst = info->arch_name; + *ptr_src && *ptr_tst; + ptr_src++, + ptr_tst++) + { + if (*ptr_src != *ptr_tst) break; + } + + /* Chewed up as much of the architecture as will match, skip any + colons */ + if (*ptr_src == ':') ptr_src++; + + if (*ptr_src == 0) { + /* nothing more, then only keep this one if it is the default + machine for this architecture */ + return info->the_default; + } + number = 0; + while (isdigit(*ptr_src)) { + number = number * 10 + *ptr_src - '0'; + ptr_src++; } - /* Set result based on our pick */ - if (!pick_a) { - archa = archb; - macha = machb; + switch (number) { + case 68010: + case 68020: + case 68030: + case 68040: + case 68332: + case 68050: + case 68000: + arch = bfd_arch_m68k; + break; + case 386: + case 80386: + case 486: + arch = bfd_arch_i386; + break; + case 29000: + arch = bfd_arch_a29k; + break; + + case 32016: + case 32032: + case 32132: + case 32232: + case 32332: + case 32432: + case 32532: + case 32000: + arch = bfd_arch_ns32k; + break; + + case 860: + case 80860: + arch = bfd_arch_i860; + break; + + default: + return false; } - if (archp) - *archp = archa; - if (machinep) - *machinep = macha; + if (arch != info->arch) + return false; + + if (number != info->mach) + return false; return true; } -/*proto* bfd_set_arch_mach -Set atch mach -*+ -#define bfd_set_arch_mach(abfd, arch, mach) \ - BFD_SEND (abfd, _bfd_set_arch_mach,\ - (abfd, arch, mach)) -*- -*/ -foo() { } +/*proto* bfd_get_arch_info +*; bfd_arch_info_struct_type * EXFUN(bfd_get_arch_info,(bfd *)); +*/ +bfd_arch_info_struct_type * +DEFUN(bfd_get_arch_info,(abfd), +bfd *abfd) +{ + return abfd->arch_info; +} |