Documentation

1 files changed, 210 insertions, 112 deletions

diff --git a/bfd/archures.c b/bfd/archures.c
index 18d49de..3a8b0c0 100644
--- a/bfd/archures.c
+++ b/bfd/archures.c
@@ -1,28 +1,90 @@
-/* BFD library support routines for architectures. */
+/* BFD library support routines for architectures.
+   Copyright (C) 1990-1991 Free Software Foundation, Inc.
+   Hacked by John Gilmore of Cygnus Support.
 
-/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+This file is part of BFD, the Binary File Descriptor library.
 
-This file is part of BFD, the Binary File Diddler.
-
-BFD is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
 
-BFD is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with BFD; see the file COPYING.  If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+along with this program; if not, write to the Free Software
+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
+attatched to the bfd, the @code{enum bfd_architecture arch} field and
+the @code{unsigned long machine} field.
+*/
+
+/*proto* bfd_architecture
+This enum gives the object file's CPU
+architecture, in a global sense.  E.g. what processor family does it
+belong to?  There is another field, which indicates what processor
+within the family is in use.  The machine gives a number which
+distingushes different versions of the architecture, containing for
+example 2 and 3 for Intel i960 KA and i960 KB, and 68020 and 68030 for
+Motorola 68020 and 68030.
+
+*+
+enum bfd_architecture 
+{
+  bfd_arch_unknown,   {* File arch not known *}
+  bfd_arch_obscure,   {* Arch known, not one of these *}
+  bfd_arch_m68k,      {* Motorola 68xxx *}
+  bfd_arch_vax,       {* DEC Vax *}   
+  bfd_arch_i960,      {* Intel 960 *}
+    {* The order of the following is important.
+       lower number indicates a machine type that 
+       only accepts a subset of the instructions
+       available to machines with higher numbers.
+       The exception is the "ca", which is
+       incompatible with all other machines except 
+       "core". *}
+
+#define bfd_mach_i960_core      1
+#define bfd_mach_i960_ka_sa     2
+#define bfd_mach_i960_kb_sb     3
+#define bfd_mach_i960_mc        4
+#define bfd_mach_i960_xa        5
+#define bfd_mach_i960_ca        6
+
+  bfd_arch_a29k,      {* AMD 29000 *}
+  bfd_arch_sparc,     {* SPARC *}
+  bfd_arch_mips,      {* MIPS Rxxxx *}
+  bfd_arch_i386,      {* Intel 386 *}
+  bfd_arch_ns32k,     {* National Semiconductor 32xxx *}
+  bfd_arch_tahoe,     {* CCI/Harris Tahoe *}
+  bfd_arch_i860,      {* Intel 860 *}
+  bfd_arch_romp,      {* IBM ROMP RS/6000 *}
+  bfd_arch_alliant,   {* Alliant *}
+  bfd_arch_convex,    {* Convex *}
+  bfd_arch_m88k,      {* Motorola 88xxx *}
+  bfd_arch_pyramid,   {* Pyramid Technology *}
+  bfd_arch_h8_300,    {* Hitachi H8/300 *}
+  bfd_arch_last
+  };
+*-
+
+stuff
+
+*/
+
+
 
 /* $Id$ */
 
-#include "sysdep.h"
+#include <sysdep.h>
 #include "bfd.h"
-#include "archures.h"
 
 static char *prt_num_mach ();
 static boolean scan_num_mach ();
@@ -30,48 +92,52 @@ 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)();
+        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},
+        {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},
 };
 
-/* Return a printable string representing the architecture and machine
-   type.  The result is only good until the next call to
-   bfd_printable_arch_mach.  */
-
-char *
-bfd_printable_arch_mach (arch, machine)
-     enum bfd_architecture arch;
-     unsigned long machine;
+/*proto* bfd_prinable_arch_mach
+Return a printable string representing the architecture and machine
+type. The result is only good until the next call to
+bfd_printable_arch_mach.  
+*; PROTO(CONST char *,bfd_printable_arch_mach,
+    (enum bfd_architecture arch, unsigned long machine));
+*/
+
+CONST char *
+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->astr;
       return (*ap->mach_print)(ap, machine);
     }
   }
@@ -89,8 +155,12 @@ prt_num_mach (ap, machine)
   return result;
 }
 
-/* Scan a string and attempt to turn it into an archive and machine type
-   combination.  */
+/*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 *));
+*/
 
 boolean
 DEFUN(bfd_scan_arch_mach,(string, archp, machinep),
@@ -109,13 +179,13 @@ DEFUN(bfd_scan_arch_mach,(string, archp, machinep),
     if (!strncmp (ap->astr, string, len)) {
       /* We found the architecture, now see about the machine type */
       if (archp)
-	*archp = ap->arch;
+        *archp = ap->arch;
       if (string[len] != '\0') {
-	if (ap->mach_scan (string+len, ap, archp, machinep, 1))
-	  return true;
+        if (ap->mach_scan (string+len, ap, archp, machinep, 1))
+          return true;
       }
       if (machinep)
-	*machinep = 0;
+        *machinep = 0;
       return true;
     }
   }
@@ -163,17 +233,17 @@ scan_num_mach (string, ap, archp, machinep, archspec)
     case 68030:
     case 68040:
     case 68332:
-    case 68050:		arch = bfd_arch_m68k; break;
-    case 68000:		arch = bfd_arch_m68k; machine = 0; break;
+    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 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 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 29000:         arch = bfd_arch_a29k; machine = 0; break;
 
     case 32016:
     case 32032:
@@ -181,13 +251,13 @@ scan_num_mach (string, ap, archp, machinep, archspec)
     case 32232:
     case 32332:
     case 32432:
-    case 32532:		arch = bfd_arch_ns32k; break;
-    case 32000:		arch = bfd_arch_ns32k; machine = 0; break;
+    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;
+    case 80860:         arch = bfd_arch_i860; machine = 0; break;
 
-    default:		return false;
+    default:            return false;
     }
   }
 
@@ -209,14 +279,14 @@ prt_960_mach (ap, machine)
   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;
+  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 prt_num_mach (ap, machine);
   }
   sprintf (result, "%s:%s", ap->astr, str);
   return result;
@@ -242,7 +312,7 @@ scan_960_mach (string, ap, archp, machinep, archspec)
   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 */
+  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;
@@ -270,16 +340,28 @@ scan_960_mach (string, ap, archp, machinep, archspec)
 
 
 
-/* Determine whether two BFDs' architectures and machine types are
-   compatible.  Return merged architecture and machine type if nonnull
-   pointers.  */
+/*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
-bfd_arch_compatible (abfd, bbfd, archp, machinep)
-    bfd *abfd;
-    bfd *bbfd;
-    enum bfd_architecture *archp;
-    unsigned long *machinep;
+DEFUN(bfd_arch_compatible,(abfd, bbfd, archp, machinep),
+    bfd *abfd AND
+    bfd *bbfd AND
+    enum bfd_architecture *archp AND
+    unsigned long *machinep)
 {
   enum bfd_architecture archa, archb;
   unsigned long macha, machb;
@@ -291,55 +373,55 @@ bfd_arch_compatible (abfd, bbfd, archp, machinep)
   machb = bfd_get_machine (bbfd);
 
   if (archb == bfd_arch_unknown)
-	pick_a = 1;
+        pick_a = 1;
   else if (archa == bfd_arch_unknown)
-	pick_a = 0;
+        pick_a = 0;
   else if (archa != archb)
-	return false;			/* Not compatible */
+        return false;                   /* Not compatible */
   else {
     /* Architectures are the same.  Check machine types.  */
-    if (macha == machb)		/* Same machine type */
+    if (macha == machb)         /* Same machine type */
       pick_a = 1;
-    else if (machb == 0)	/* B is default */
+    else if (machb == 0)        /* B is default */
       pick_a = 1;
-    else if (macha == 0)	/* A is default */
+    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).  */
+         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;
+        /* 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.  */
+         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:
@@ -364,3 +446,19 @@ bfd_arch_compatible (abfd, bbfd, archp, machinep)
 
   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() { }
+
+
+