Mon Sep 30 15:13:46 1991 Steve Chamberlain (steve at cygnus.com)

	* cpu-a29k.c, cpu-i386.c, cpu-m68k.c, cpu-mips.c, cpu-vax.c,
	cpu-h8300.c, cpu-i960.c, cpu-m88k.c, cpu-sparc.c: added. These
	files will eventually contain processor specific bits for bfd,
	like strange relocation information and dis/assembly.  So far only
	the H8 has been even partially done.  This work also ties in with
	the change in handling architectures.

	* aout-f1.h: (choose_reloc_size) now calls bfd_get_arch to
	discover the architecture of the bfd. (sunos4_callback) calls the
	function bfd_set_arch_mach rather than stuffing stuff directly
	into the bfd. (sunos4_write_object_contents), changed names of
	accessor functions.

	* aoutx.h: (set_arch_mach) now calls bfd_default_set_arch_mach to
	setup the environment.

	* archive.c: (bfd_slurp_coff_armap) coff archives always have the
	headers in big endian format, regardless of the endianess of the
	host or target.

	* archures.c: totally changed. Now an architecture is represented
	with a pointer to an info structure rather than an enumerated type
	and a long. The old info is available as two elements in the
	structure.  Future enhancements to architecure support will
	involve pointers to methods being placed into the info structure.

	* bfd.c: changed the definition of the bfd structure for the new
	architecture stuff.

	* bout.c: (b_out_set_arch_mach) changed to use the new
	architecture mechanism.

	* coffcode.h: (coff_set_arch_mach, coff_set_flags) changed to use
	the new architecture mechanism.

	* configure.in: added h8 stuff.

	* ieee.c: too many changes to note.  Now ieee files written with
	bfd gas and ld can be read by gld and ieee only linkers and
	simulators.

	* libbfd.c, libbfd.h: changed prototype of bfd_write.

	* newsos3.c: (newos3_callback) now calls bfd_set_arch_mach rather
	than fixing the structure directly.

	* oasys.c: (oasys_object_p) now calls bfd_default_set_arch_mach rather
	than fixing the structure directly.

	* opncls.c: (new_bfd) makes sure that bfd_init has been called
	before opening a bfd.

	* srec.c: (srec_set_arch_mach) now calls bfd_default_set_arch_mach
	rather than fixing the structure directly.

	* targets.c: (target_vector) now by defining SELECT_VECS (perhaps
	in the t/hmake file) a user can select which backends they want
	linked with bfd without changing the source.

	* init.c: new, looks after initializing modules.

	* howto.c: for future use, will allow an application to work out
	what cookie to use as a handle on a relcoatio howto.

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;
+}