import gdb-1999-07-07 post reformat

1 files changed, 512 insertions, 504 deletions

diff --git a/gdb/symtab.h b/gdb/symtab.h
index 4c06d83..86a119a 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1,22 +1,23 @@
 /* Symbol table definitions for GDB.
    Copyright 1986, 89, 91, 92, 93, 94, 95, 96, 1998
-             Free Software Foundation, Inc.
+   Free Software Foundation, Inc.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-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 2 of the License, or
-(at your option) any later version.
+   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 2 of the License, or
+   (at your option) any later version.
 
-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.
+   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 this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 #if !defined (SYMTAB_H)
 #define SYMTAB_H 1
@@ -36,7 +37,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #if 0 && defined(__GNUC__) && !defined(BYTE_BITFIELD)
 #define	BYTE_BITFIELD	:8;
 #else
-#define	BYTE_BITFIELD	/*nothing*/
+#define	BYTE_BITFIELD		/*nothing */
 #endif
 
 /* Define a structure for the information that is common to all symbol types,
@@ -48,75 +49,78 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    have tens or hundreds of thousands of these.  */
 
 struct general_symbol_info
-{
-  /* Name of the symbol.  This is a required field.  Storage for the name is
-     allocated on the psymbol_obstack or symbol_obstack for the associated
-     objfile. */
-
-  char *name;
-
-  /* Value of the symbol.  Which member of this union to use, and what
-     it means, depends on what kind of symbol this is and its
-     SYMBOL_CLASS.  See comments there for more details.  All of these
-     are in host byte order (though what they point to might be in
-     target byte order, e.g. LOC_CONST_BYTES).  */
-
-  union
-    {
-      /* The fact that this is a long not a LONGEST mainly limits the
-	 range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
-	 sure that is a big deal.  */
-      long ivalue;
-
-      struct block *block;
-
-      char *bytes;
-
-      CORE_ADDR address;
+  {
+    /* Name of the symbol.  This is a required field.  Storage for the name is
+       allocated on the psymbol_obstack or symbol_obstack for the associated
+       objfile. */
 
-      /* for opaque typedef struct chain */
+    char *name;
 
-      struct symbol *chain;
-    }
-  value;
+    /* Value of the symbol.  Which member of this union to use, and what
+       it means, depends on what kind of symbol this is and its
+       SYMBOL_CLASS.  See comments there for more details.  All of these
+       are in host byte order (though what they point to might be in
+       target byte order, e.g. LOC_CONST_BYTES).  */
 
-  /* Since one and only one language can apply, wrap the language specific
-     information inside a union. */
+    union
+      {
+	/* The fact that this is a long not a LONGEST mainly limits the
+	   range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
+	   sure that is a big deal.  */
+	long ivalue;
 
-  union
-    {
-      struct cplus_specific      /* For C++ */
-				/*  and Java */
-	{
-	  char *demangled_name;
-	} cplus_specific;
-      struct chill_specific      /* For Chill */
-	{
-	  char *demangled_name;
-	} chill_specific;
-    } language_specific;
+	struct block *block;
 
-  /* Record the source code language that applies to this symbol.
-     This is used to select one of the fields from the language specific
-     union above. */
+	char *bytes;
 
-  enum language language BYTE_BITFIELD;
+	CORE_ADDR address;
 
-  /* Which section is this symbol in?  This is an index into
-     section_offsets for this objfile.  Negative means that the symbol
-     does not get relocated relative to a section.
-     Disclaimer: currently this is just used for xcoff, so don't
-     expect all symbol-reading code to set it correctly (the ELF code
-     also tries to set it correctly).  */
+	/* for opaque typedef struct chain */
 
-  short section;
+	struct symbol *chain;
+      }
+    value;
 
-  /* The bfd section associated with this symbol. */
+    /* Since one and only one language can apply, wrap the language specific
+       information inside a union. */
 
-  asection *bfd_section;
-};
+    union
+      {
+	struct cplus_specific	/* For C++ */
+	/*  and Java */
+	  {
+	    char *demangled_name;
+	  }
+	cplus_specific;
+	struct chill_specific	/* For Chill */
+	  {
+	    char *demangled_name;
+	  }
+	chill_specific;
+      }
+    language_specific;
+
+    /* Record the source code language that applies to this symbol.
+       This is used to select one of the fields from the language specific
+       union above. */
+
+    enum language language BYTE_BITFIELD;
+
+    /* Which section is this symbol in?  This is an index into
+       section_offsets for this objfile.  Negative means that the symbol
+       does not get relocated relative to a section.
+       Disclaimer: currently this is just used for xcoff, so don't
+       expect all symbol-reading code to set it correctly (the ELF code
+       also tries to set it correctly).  */
+
+    short section;
+
+    /* The bfd section associated with this symbol. */
+
+    asection *bfd_section;
+  };
 
-extern CORE_ADDR symbol_overlayed_address PARAMS((CORE_ADDR, asection *));
+extern CORE_ADDR symbol_overlayed_address PARAMS ((CORE_ADDR, asection *));
 
 #define SYMBOL_NAME(symbol)		(symbol)->ginfo.name
 #define SYMBOL_VALUE(symbol)		(symbol)->ginfo.value.ivalue
@@ -270,7 +274,7 @@ extern CORE_ADDR symbol_overlayed_address PARAMS((CORE_ADDR, asection *));
   (STREQ (SYMBOL_NAME (symbol), (name))					\
    || (SYMBOL_DEMANGLED_NAME (symbol) != NULL				\
        && strcmp_iw (SYMBOL_DEMANGLED_NAME (symbol), (name)) == 0))
-   
+
 /* Macro that tests a symbol for an re-match against the last compiled regular
    expression.  First test the unencoded name, then look for and test a C++
    encoded name if it exists.
@@ -280,7 +284,7 @@ extern CORE_ADDR symbol_overlayed_address PARAMS((CORE_ADDR, asection *));
   (re_exec (SYMBOL_NAME (symbol)) != 0					\
    || (SYMBOL_DEMANGLED_NAME (symbol) != NULL				\
        && re_exec (SYMBOL_DEMANGLED_NAME (symbol)) != 0))
-   
+
 /* Define a simple structure used to hold some very basic information about
    all defined global symbols (text, data, bss, abs, etc).  The only required
    information is the general_symbol_info.
@@ -294,70 +298,71 @@ extern CORE_ADDR symbol_overlayed_address PARAMS((CORE_ADDR, asection *));
    used to figure out what full symbol table entries need to be read in. */
 
 struct minimal_symbol
-{
+  {
 
-  /* The general symbol info required for all types of symbols.
+    /* The general symbol info required for all types of symbols.
 
-     The SYMBOL_VALUE_ADDRESS contains the address that this symbol
-     corresponds to.  */
+       The SYMBOL_VALUE_ADDRESS contains the address that this symbol
+       corresponds to.  */
 
-  struct general_symbol_info ginfo;
+    struct general_symbol_info ginfo;
 
-  /* The info field is available for caching machine-specific information
-     so it doesn't have to rederive the info constantly (over a serial line).
-     It is initialized to zero and stays that way until target-dependent code
-     sets it.  Storage for any data pointed to by this field should be allo-
-     cated on the symbol_obstack for the associated objfile.  
-     The type would be "void *" except for reasons of compatibility with older
-     compilers.  This field is optional.
+    /* The info field is available for caching machine-specific information
+       so it doesn't have to rederive the info constantly (over a serial line).
+       It is initialized to zero and stays that way until target-dependent code
+       sets it.  Storage for any data pointed to by this field should be allo-
+       cated on the symbol_obstack for the associated objfile.  
+       The type would be "void *" except for reasons of compatibility with older
+       compilers.  This field is optional.
 
-     Currently, the AMD 29000 tdep.c uses it to remember things it has decoded
-     from the instructions in the function header, and the MIPS-16 code uses
-     it to identify 16-bit procedures.  */
+       Currently, the AMD 29000 tdep.c uses it to remember things it has decoded
+       from the instructions in the function header, and the MIPS-16 code uses
+       it to identify 16-bit procedures.  */
 
-  char *info;
+    char *info;
 
 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
-  /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
-  char *filename;
+    /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
+    char *filename;
 #endif
 
-  /* Classification types for this symbol.  These should be taken as "advisory
-     only", since if gdb can't easily figure out a classification it simply
-     selects mst_unknown.  It may also have to guess when it can't figure out
-     which is a better match between two types (mst_data versus mst_bss) for
-     example.  Since the minimal symbol info is sometimes derived from the
-     BFD library's view of a file, we need to live with what information bfd
-     supplies. */
-
-  enum minimal_symbol_type
-    {
-      mst_unknown = 0,		/* Unknown type, the default */
-      mst_text,			/* Generally executable instructions */
-      mst_data,			/* Generally initialized data */
-      mst_bss,			/* Generally uninitialized data */
-      mst_abs,			/* Generally absolute (nonrelocatable) */
-      /* GDB uses mst_solib_trampoline for the start address of a shared
-	 library trampoline entry.  Breakpoints for shared library functions
-	 are put there if the shared library is not yet loaded.
-	 After the shared library is loaded, lookup_minimal_symbol will
-	 prefer the minimal symbol from the shared library (usually
-	 a mst_text symbol) over the mst_solib_trampoline symbol, and the
-	 breakpoints will be moved to their true address in the shared
-	 library via breakpoint_re_set.  */
-      mst_solib_trampoline,	/* Shared library trampoline code */
-      /* For the mst_file* types, the names are only guaranteed to be unique
-	 within a given .o file.  */
-      mst_file_text,		/* Static version of mst_text */
-      mst_file_data,		/* Static version of mst_data */
-      mst_file_bss		/* Static version of mst_bss */
-    } type BYTE_BITFIELD;
-};
+    /* Classification types for this symbol.  These should be taken as "advisory
+       only", since if gdb can't easily figure out a classification it simply
+       selects mst_unknown.  It may also have to guess when it can't figure out
+       which is a better match between two types (mst_data versus mst_bss) for
+       example.  Since the minimal symbol info is sometimes derived from the
+       BFD library's view of a file, we need to live with what information bfd
+       supplies. */
+
+    enum minimal_symbol_type
+      {
+	mst_unknown = 0,	/* Unknown type, the default */
+	mst_text,		/* Generally executable instructions */
+	mst_data,		/* Generally initialized data */
+	mst_bss,		/* Generally uninitialized data */
+	mst_abs,		/* Generally absolute (nonrelocatable) */
+	/* GDB uses mst_solib_trampoline for the start address of a shared
+	   library trampoline entry.  Breakpoints for shared library functions
+	   are put there if the shared library is not yet loaded.
+	   After the shared library is loaded, lookup_minimal_symbol will
+	   prefer the minimal symbol from the shared library (usually
+	   a mst_text symbol) over the mst_solib_trampoline symbol, and the
+	   breakpoints will be moved to their true address in the shared
+	   library via breakpoint_re_set.  */
+	mst_solib_trampoline,	/* Shared library trampoline code */
+	/* For the mst_file* types, the names are only guaranteed to be unique
+	   within a given .o file.  */
+	mst_file_text,		/* Static version of mst_text */
+	mst_file_data,		/* Static version of mst_data */
+	mst_file_bss		/* Static version of mst_bss */
+      }
+    type BYTE_BITFIELD;
+  };
 
 #define MSYMBOL_INFO(msymbol)		(msymbol)->info
 #define MSYMBOL_TYPE(msymbol)		(msymbol)->type
-
 
+
 /* All of the name-scope contours of the program
    are represented by `struct block' objects.
    All of these objects are pointed to by the blockvector.
@@ -385,12 +390,12 @@ struct minimal_symbol
    the blocks appear in the order of a depth-first tree walk.  */
 
 struct blockvector
-{
-  /* Number of blocks in the list.  */
-  int nblocks;
-  /* The blocks themselves.  */
-  struct block *block[1];
-};
+  {
+    /* Number of blocks in the list.  */
+    int nblocks;
+    /* The blocks themselves.  */
+    struct block *block[1];
+  };
 
 #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
 #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
@@ -402,47 +407,47 @@ struct blockvector
 #define	FIRST_LOCAL_BLOCK	2
 
 struct block
-{
+  {
 
-  /* Addresses in the executable code that are in this block.  */
+    /* Addresses in the executable code that are in this block.  */
 
-  CORE_ADDR startaddr;
-  CORE_ADDR endaddr;
+    CORE_ADDR startaddr;
+    CORE_ADDR endaddr;
 
-  /* The symbol that names this block, if the block is the body of a
-     function; otherwise, zero.  */
+    /* The symbol that names this block, if the block is the body of a
+       function; otherwise, zero.  */
 
-  struct symbol *function;
+    struct symbol *function;
 
-  /* The `struct block' for the containing block, or 0 if none.
+    /* The `struct block' for the containing block, or 0 if none.
 
-     The superblock of a top-level local block (i.e. a function in the
-     case of C) is the STATIC_BLOCK.  The superblock of the
-     STATIC_BLOCK is the GLOBAL_BLOCK.  */
+       The superblock of a top-level local block (i.e. a function in the
+       case of C) is the STATIC_BLOCK.  The superblock of the
+       STATIC_BLOCK is the GLOBAL_BLOCK.  */
 
-  struct block *superblock;
+    struct block *superblock;
 
-  /* Version of GCC used to compile the function corresponding
-     to this block, or 0 if not compiled with GCC.  When possible,
-     GCC should be compatible with the native compiler, or if that
-     is not feasible, the differences should be fixed during symbol
-     reading.  As of 16 Apr 93, this flag is never used to distinguish
-     between gcc2 and the native compiler.
+    /* Version of GCC used to compile the function corresponding
+       to this block, or 0 if not compiled with GCC.  When possible,
+       GCC should be compatible with the native compiler, or if that
+       is not feasible, the differences should be fixed during symbol
+       reading.  As of 16 Apr 93, this flag is never used to distinguish
+       between gcc2 and the native compiler.
 
-     If there is no function corresponding to this block, this meaning
-     of this flag is undefined.  */
+       If there is no function corresponding to this block, this meaning
+       of this flag is undefined.  */
 
-  unsigned char gcc_compile_flag;
+    unsigned char gcc_compile_flag;
 
-  /* Number of local symbols.  */
+    /* Number of local symbols.  */
 
-  int nsyms;
+    int nsyms;
 
-  /* The symbols.  If some of them are arguments, then they must be
-     in the order in which we would like to print them.  */
+    /* The symbols.  If some of them are arguments, then they must be
+       in the order in which we would like to print them.  */
 
-  struct symbol *sym[1];
-};
+    struct symbol *sym[1];
+  };
 
 #define BLOCK_START(bl)		(bl)->startaddr
 #define BLOCK_END(bl)		(bl)->endaddr
@@ -458,198 +463,199 @@ struct block
    arguments.  */
 
 #define BLOCK_SHOULD_SORT(bl) ((bl)->nsyms >= 40 && BLOCK_FUNCTION (bl) == NULL)
-
 
+
 /* Represent one symbol name; a variable, constant, function or typedef.  */
 
 /* Different name spaces for symbols.  Looking up a symbol specifies a
    namespace and ignores symbol definitions in other name spaces. */
- 
-typedef enum 
-{
-  /* UNDEF_NAMESPACE is used when a namespace has not been discovered or
-     none of the following apply.  This usually indicates an error either
-     in the symbol information or in gdb's handling of symbols. */
 
-  UNDEF_NAMESPACE,
+typedef enum
+  {
+    /* UNDEF_NAMESPACE is used when a namespace has not been discovered or
+       none of the following apply.  This usually indicates an error either
+       in the symbol information or in gdb's handling of symbols. */
+
+    UNDEF_NAMESPACE,
 
-  /* VAR_NAMESPACE is the usual namespace.  In C, this contains variables,
-     function names, typedef names and enum type values. */
+    /* VAR_NAMESPACE is the usual namespace.  In C, this contains variables,
+       function names, typedef names and enum type values. */
 
-  VAR_NAMESPACE,
+    VAR_NAMESPACE,
 
-  /* STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
-     Thus, if `struct foo' is used in a C program, it produces a symbol named
-     `foo' in the STRUCT_NAMESPACE. */
+    /* STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
+       Thus, if `struct foo' is used in a C program, it produces a symbol named
+       `foo' in the STRUCT_NAMESPACE. */
 
-  STRUCT_NAMESPACE,
+    STRUCT_NAMESPACE,
 
-  /* LABEL_NAMESPACE may be used for names of labels (for gotos);
-     currently it is not used and labels are not recorded at all.  */
+    /* LABEL_NAMESPACE may be used for names of labels (for gotos);
+       currently it is not used and labels are not recorded at all.  */
 
-  LABEL_NAMESPACE,
+    LABEL_NAMESPACE,
 
-  /* Searching namespaces. These overlap with VAR_NAMESPACE, providing
-     some granularity with the search_symbols function. */
+    /* Searching namespaces. These overlap with VAR_NAMESPACE, providing
+       some granularity with the search_symbols function. */
 
-  /* Everything in VAR_NAMESPACE minus FUNCTIONS_-, TYPES_-, and
-     METHODS_NAMESPACE */
-  VARIABLES_NAMESPACE,
+    /* Everything in VAR_NAMESPACE minus FUNCTIONS_-, TYPES_-, and
+       METHODS_NAMESPACE */
+    VARIABLES_NAMESPACE,
 
-  /* All functions -- for some reason not methods, though. */
-  FUNCTIONS_NAMESPACE,
+    /* All functions -- for some reason not methods, though. */
+    FUNCTIONS_NAMESPACE,
 
-  /* All defined types */
-  TYPES_NAMESPACE,
+    /* All defined types */
+    TYPES_NAMESPACE,
 
-  /* All class methods -- why is this separated out? */
-  METHODS_NAMESPACE
+    /* All class methods -- why is this separated out? */
+    METHODS_NAMESPACE
 
-} namespace_enum;
+  }
+namespace_enum;
 
 /* An address-class says where to find the value of a symbol.  */
 
 enum address_class
-{
-  /* Not used; catches errors */
+  {
+    /* Not used; catches errors */
+
+    LOC_UNDEF,
 
-  LOC_UNDEF,
+    /* Value is constant int SYMBOL_VALUE, host byteorder */
 
-  /* Value is constant int SYMBOL_VALUE, host byteorder */
+    LOC_CONST,
 
-  LOC_CONST,
+    /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
 
-  /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
+    LOC_STATIC,
 
-  LOC_STATIC,
+    /* Value is in register.  SYMBOL_VALUE is the register number.  */
 
-  /* Value is in register.  SYMBOL_VALUE is the register number.  */
+    LOC_REGISTER,
 
-  LOC_REGISTER,
+    /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
 
-  /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
+    LOC_ARG,
 
-  LOC_ARG,
+    /* Value address is at SYMBOL_VALUE offset in arglist.  */
 
-  /* Value address is at SYMBOL_VALUE offset in arglist.  */
+    LOC_REF_ARG,
 
-  LOC_REF_ARG,
+    /* Value is in register number SYMBOL_VALUE.  Just like LOC_REGISTER
+       except this is an argument.  Probably the cleaner way to handle
+       this would be to separate address_class (which would include
+       separate ARG and LOCAL to deal with FRAME_ARGS_ADDRESS versus
+       FRAME_LOCALS_ADDRESS), and an is_argument flag.
 
-  /* Value is in register number SYMBOL_VALUE.  Just like LOC_REGISTER
-     except this is an argument.  Probably the cleaner way to handle
-     this would be to separate address_class (which would include
-     separate ARG and LOCAL to deal with FRAME_ARGS_ADDRESS versus
-     FRAME_LOCALS_ADDRESS), and an is_argument flag.
+       For some symbol formats (stabs, for some compilers at least),
+       the compiler generates two symbols, an argument and a register.
+       In some cases we combine them to a single LOC_REGPARM in symbol
+       reading, but currently not for all cases (e.g. it's passed on the
+       stack and then loaded into a register).  */
 
-     For some symbol formats (stabs, for some compilers at least),
-     the compiler generates two symbols, an argument and a register.
-     In some cases we combine them to a single LOC_REGPARM in symbol
-     reading, but currently not for all cases (e.g. it's passed on the
-     stack and then loaded into a register).  */
+    LOC_REGPARM,
 
-  LOC_REGPARM,
+    /* Value is in specified register.  Just like LOC_REGPARM except the
+       register holds the address of the argument instead of the argument
+       itself. This is currently used for the passing of structs and unions
+       on sparc and hppa.  It is also used for call by reference where the
+       address is in a register, at least by mipsread.c.  */
 
-  /* Value is in specified register.  Just like LOC_REGPARM except the
-     register holds the address of the argument instead of the argument
-     itself. This is currently used for the passing of structs and unions
-     on sparc and hppa.  It is also used for call by reference where the
-     address is in a register, at least by mipsread.c.  */
+    LOC_REGPARM_ADDR,
 
-  LOC_REGPARM_ADDR,
+    /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
 
-  /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
+    LOC_LOCAL,
 
-  LOC_LOCAL,
+    /* Value not used; definition in SYMBOL_TYPE.  Symbols in the namespace
+       STRUCT_NAMESPACE all have this class.  */
 
-  /* Value not used; definition in SYMBOL_TYPE.  Symbols in the namespace
-     STRUCT_NAMESPACE all have this class.  */
+    LOC_TYPEDEF,
 
-  LOC_TYPEDEF,
+    /* Value is address SYMBOL_VALUE_ADDRESS in the code */
 
-  /* Value is address SYMBOL_VALUE_ADDRESS in the code */
+    LOC_LABEL,
 
-  LOC_LABEL,
+    /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
+       In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
+       of the block.  Function names have this class. */
 
-  /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
-     In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
-     of the block.  Function names have this class. */
+    LOC_BLOCK,
 
-  LOC_BLOCK,
+    /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
+       target byte order.  */
 
-  /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
-     target byte order.  */
+    LOC_CONST_BYTES,
 
-  LOC_CONST_BYTES,
+    /* Value is arg at SYMBOL_VALUE offset in stack frame. Differs from
+       LOC_LOCAL in that symbol is an argument; differs from LOC_ARG in
+       that we find it in the frame (FRAME_LOCALS_ADDRESS), not in the
+       arglist (FRAME_ARGS_ADDRESS).  Added for i960, which passes args
+       in regs then copies to frame.  */
 
-  /* Value is arg at SYMBOL_VALUE offset in stack frame. Differs from
-     LOC_LOCAL in that symbol is an argument; differs from LOC_ARG in
-     that we find it in the frame (FRAME_LOCALS_ADDRESS), not in the
-     arglist (FRAME_ARGS_ADDRESS).  Added for i960, which passes args
-     in regs then copies to frame.  */
+    LOC_LOCAL_ARG,
 
-  LOC_LOCAL_ARG,
+    /* Value is at SYMBOL_VALUE offset from the current value of
+       register number SYMBOL_BASEREG.  This exists mainly for the same
+       things that LOC_LOCAL and LOC_ARG do; but we need to do this
+       instead because on 88k DWARF gives us the offset from the
+       frame/stack pointer, rather than the offset from the "canonical
+       frame address" used by COFF, stabs, etc., and we don't know how
+       to convert between these until we start examining prologues.
 
-  /* Value is at SYMBOL_VALUE offset from the current value of
-     register number SYMBOL_BASEREG.  This exists mainly for the same
-     things that LOC_LOCAL and LOC_ARG do; but we need to do this
-     instead because on 88k DWARF gives us the offset from the
-     frame/stack pointer, rather than the offset from the "canonical
-     frame address" used by COFF, stabs, etc., and we don't know how
-     to convert between these until we start examining prologues.
+       Note that LOC_BASEREG is much less general than a DWARF expression.
+       We don't need the generality (at least not yet), and storing a general
+       DWARF expression would presumably take up more space than the existing
+       scheme.  */
 
-     Note that LOC_BASEREG is much less general than a DWARF expression.
-     We don't need the generality (at least not yet), and storing a general
-     DWARF expression would presumably take up more space than the existing
-     scheme.  */
+    LOC_BASEREG,
 
-  LOC_BASEREG,
+    /* Same as LOC_BASEREG but it is an argument.  */
 
-  /* Same as LOC_BASEREG but it is an argument.  */
+    LOC_BASEREG_ARG,
 
-  LOC_BASEREG_ARG,
+    /* Value is at fixed address, but the address of the variable has
+       to be determined from the minimal symbol table whenever the
+       variable is referenced.
+       This happens if debugging information for a global symbol is
+       emitted and the corresponding minimal symbol is defined
+       in another object file or runtime common storage.
+       The linker might even remove the minimal symbol if the global
+       symbol is never referenced, in which case the symbol remains
+       unresolved.  */
 
-  /* Value is at fixed address, but the address of the variable has
-     to be determined from the minimal symbol table whenever the
-     variable is referenced.
-     This happens if debugging information for a global symbol is
-     emitted and the corresponding minimal symbol is defined
-     in another object file or runtime common storage.
-     The linker might even remove the minimal symbol if the global
-     symbol is never referenced, in which case the symbol remains
-     unresolved.  */
+    LOC_UNRESOLVED,
 
-  LOC_UNRESOLVED,
+    /* Value is at a thread-specific location calculated by a
+       target-specific method. */
 
-  /* Value is at a thread-specific location calculated by a
-     target-specific method. */
-     
-  LOC_THREAD_LOCAL_STATIC,
-     
-  /* The variable does not actually exist in the program.
-     The value is ignored.  */
+    LOC_THREAD_LOCAL_STATIC,
 
-  LOC_OPTIMIZED_OUT,
+    /* The variable does not actually exist in the program.
+       The value is ignored.  */
 
-  /* The variable is static, but actually lives at * (address).
-   * I.e. do an extra indirection to get to it.
-   * This is used on HP-UX to get at globals that are allocated
-   * in shared libraries, where references from images other
-   * than the one where the global was allocated are done
-   * with a level of indirection.
-   */
+    LOC_OPTIMIZED_OUT,
 
-  LOC_INDIRECT
+    /* The variable is static, but actually lives at * (address).
+     * I.e. do an extra indirection to get to it.
+     * This is used on HP-UX to get at globals that are allocated
+     * in shared libraries, where references from images other
+     * than the one where the global was allocated are done
+     * with a level of indirection.
+     */
 
-};
+    LOC_INDIRECT
+
+  };
 
 /* Linked list of symbol's live ranges. */
 
-struct range_list		
-{
-  CORE_ADDR start;
-  CORE_ADDR end;
-  struct range_list *next;	
-};
+struct range_list
+  {
+    CORE_ADDR start;
+    CORE_ADDR end;
+    struct range_list *next;
+  };
 
 /* Linked list of aliases for a particular main/primary symbol.  */
 struct alias_list
@@ -659,54 +665,54 @@ struct alias_list
   };
 
 struct symbol
-{
+  {
 
-  /* The general symbol info required for all types of symbols. */
+    /* The general symbol info required for all types of symbols. */
 
-  struct general_symbol_info ginfo;
+    struct general_symbol_info ginfo;
 
-  /* Data type of value */
+    /* Data type of value */
 
-  struct type *type;
+    struct type *type;
 
-  /* Name space code.  */
+    /* Name space code.  */
 
 #ifdef __MFC4__
-  /* FIXME: don't conflict with C++'s namespace */
-  /* would be safer to do a global change for all namespace identifiers. */
-  #define namespace _namespace
+    /* FIXME: don't conflict with C++'s namespace */
+    /* would be safer to do a global change for all namespace identifiers. */
+#define namespace _namespace
 #endif
-  namespace_enum namespace BYTE_BITFIELD;
+    namespace_enum namespace BYTE_BITFIELD;
 
-  /* Address class */
+    /* Address class */
 
-  enum address_class aclass BYTE_BITFIELD;
+    enum address_class aclass BYTE_BITFIELD;
 
-  /* Line number of definition.  FIXME:  Should we really make the assumption
-     that nobody will try to debug files longer than 64K lines?  What about
-     machine generated programs? */
+    /* Line number of definition.  FIXME:  Should we really make the assumption
+       that nobody will try to debug files longer than 64K lines?  What about
+       machine generated programs? */
 
-  unsigned short line;
-  
-  /* Some symbols require an additional value to be recorded on a per-
-     symbol basis.  Stash those values here. */
+    unsigned short line;
 
-  union
-    {
-      /* Used by LOC_BASEREG and LOC_BASEREG_ARG.  */
-      short basereg;
-    }
-  aux_value;
+    /* Some symbols require an additional value to be recorded on a per-
+       symbol basis.  Stash those values here. */
+
+    union
+      {
+	/* Used by LOC_BASEREG and LOC_BASEREG_ARG.  */
+	short basereg;
+      }
+    aux_value;
 
 
-  /* Link to a list of aliases for this symbol.
-     Only a "primary/main symbol may have aliases.  */
-  struct alias_list *aliases;
+    /* Link to a list of aliases for this symbol.
+       Only a "primary/main symbol may have aliases.  */
+    struct alias_list *aliases;
 
-  /* List of ranges where this symbol is active.  This is only
-     used by alias symbols at the current time.  */
-  struct range_list *ranges;
-};
+    /* List of ranges where this symbol is active.  This is only
+       used by alias symbols at the current time.  */
+    struct range_list *ranges;
+  };
 
 
 #define SYMBOL_NAMESPACE(symbol)	(symbol)->namespace
@@ -725,34 +731,34 @@ struct symbol
    normal symtab once the partial_symtab has been referenced.  */
 
 struct partial_symbol
-{
+  {
 
-  /* The general symbol info required for all types of symbols. */
+    /* The general symbol info required for all types of symbols. */
 
-  struct general_symbol_info ginfo;
+    struct general_symbol_info ginfo;
 
-  /* Name space code.  */
+    /* Name space code.  */
 
-  namespace_enum namespace BYTE_BITFIELD;
+    namespace_enum namespace BYTE_BITFIELD;
 
-  /* Address class (for info_symbols) */
+    /* Address class (for info_symbols) */
 
-  enum address_class aclass BYTE_BITFIELD;
+    enum address_class aclass BYTE_BITFIELD;
 
-};
+  };
 
 #define PSYMBOL_NAMESPACE(psymbol)	(psymbol)->namespace
 #define PSYMBOL_CLASS(psymbol)		(psymbol)->aclass
-
 
+
 /* Source-file information.  This describes the relation between source files,
    ine numbers and addresses in the program text.  */
 
 struct sourcevector
-{
-  int length;			/* Number of source files described */
-  struct source *source[1];	/* Descriptions of the files */
-};
+  {
+    int length;			/* Number of source files described */
+    struct source *source[1];	/* Descriptions of the files */
+  };
 
 /* Each item represents a line-->pc (or the reverse) mapping.  This is
    somewhat more wasteful of space than one might wish, but since only
@@ -760,10 +766,10 @@ struct sourcevector
    waste much space.  */
 
 struct linetable_entry
-{
-  int line;
-  CORE_ADDR pc;
-};
+  {
+    int line;
+    CORE_ADDR pc;
+  };
 
 /* The order of entries in the linetable is significant.  They should
    be sorted by increasing values of the pc field.  If there is more than
@@ -772,30 +778,30 @@ struct linetable_entry
 
    Example: a C for statement generally looks like this
 
-   	10	0x100	- for the init/test part of a for stmt.
-   	20	0x200
-   	30	0x300
-   	10	0x400	- for the increment part of a for stmt.
+   10   0x100   - for the init/test part of a for stmt.
+   20   0x200
+   30   0x300
+   10   0x400   - for the increment part of a for stmt.
 
-   */
+ */
 
 struct linetable
-{
-  int nitems;
+  {
+    int nitems;
 
-  /* Actually NITEMS elements.  If you don't like this use of the
-     `struct hack', you can shove it up your ANSI (seriously, if the
-     committee tells us how to do it, we can probably go along).  */
-  struct linetable_entry item[1];
-};
+    /* Actually NITEMS elements.  If you don't like this use of the
+       `struct hack', you can shove it up your ANSI (seriously, if the
+       committee tells us how to do it, we can probably go along).  */
+    struct linetable_entry item[1];
+  };
 
 /* All the information on one source file.  */
 
 struct source
-{
-  char *name;			/* Name of file */
-  struct linetable contents;
-};
+  {
+    char *name;			/* Name of file */
+    struct linetable contents;
+  };
 
 /* How to relocate the symbols from each section in a symbol file.
    Each struct contains an array of offsets.
@@ -809,13 +815,13 @@ struct source
 
 struct section_offsets
   {
-    CORE_ADDR offsets[1];		/* As many as needed. */
+    CORE_ADDR offsets[1];	/* As many as needed. */
   };
 
 #define	ANOFFSET(secoff, whichone)	(secoff->offsets[whichone])
 
 /* The maximum possible size of a section_offsets table.  */
- 
+
 #define SIZEOF_SECTION_OFFSETS \
   (sizeof (struct section_offsets) \
    + sizeof (((struct section_offsets *) 0)->offsets) * (SECT_OFF_MAX-1))
@@ -864,19 +870,19 @@ struct symtab
     /* This component says how to free the data we point to:
        free_contents => do a tree walk and free each object.
        free_nothing => do nothing; some other symtab will free
-         the data this one uses.
-      free_linetable => free just the linetable.  FIXME: Is this redundant
-      with the primary field?  */
+       the data this one uses.
+       free_linetable => free just the linetable.  FIXME: Is this redundant
+       with the primary field?  */
 
     enum free_code
       {
 	free_nothing, free_contents, free_linetable
-	}
+      }
     free_code;
 
     /* Pointer to one block of storage to be freed, if nonzero.  */
     /* This is IN ADDITION to the action indicated by free_code.  */
-    
+
     char *free_ptr;
 
     /* Total number of lines found in source file.  */
@@ -917,8 +923,8 @@ struct symtab
 
 #define BLOCKVECTOR(symtab)	(symtab)->blockvector
 #define LINETABLE(symtab)	(symtab)->linetable
-
 
+
 /* Each source file that has not been fully read in is represented by
    a partial_symtab.  This contains the information on where in the
    executable the debugging symbols for a specific file are, and a
@@ -931,90 +937,90 @@ struct symtab
    style execution of a bunch of .o's.  */
 
 struct partial_symtab
-{
+  {
 
-  /* Chain of all existing partial symtabs.  */
+    /* Chain of all existing partial symtabs.  */
 
-  struct partial_symtab *next;
+    struct partial_symtab *next;
 
-  /* Name of the source file which this partial_symtab defines */
+    /* Name of the source file which this partial_symtab defines */
 
-  char *filename;
+    char *filename;
 
-  /* Information about the object file from which symbols should be read.  */
+    /* Information about the object file from which symbols should be read.  */
 
-  struct objfile *objfile;
+    struct objfile *objfile;
 
-  /* Set of relocation offsets to apply to each section.  */ 
+    /* Set of relocation offsets to apply to each section.  */
 
-  struct section_offsets *section_offsets;
+    struct section_offsets *section_offsets;
 
-  /* Range of text addresses covered by this file; texthigh is the
-     beginning of the next section. */
+    /* Range of text addresses covered by this file; texthigh is the
+       beginning of the next section. */
 
-  CORE_ADDR textlow;
-  CORE_ADDR texthigh;
+    CORE_ADDR textlow;
+    CORE_ADDR texthigh;
 
-  /* Array of pointers to all of the partial_symtab's which this one
-     depends on.  Since this array can only be set to previous or
-     the current (?) psymtab, this dependency tree is guaranteed not
-     to have any loops.  "depends on" means that symbols must be read
-     for the dependencies before being read for this psymtab; this is
-     for type references in stabs, where if foo.c includes foo.h, declarations
-     in foo.h may use type numbers defined in foo.c.  For other debugging
-     formats there may be no need to use dependencies.  */
+    /* Array of pointers to all of the partial_symtab's which this one
+       depends on.  Since this array can only be set to previous or
+       the current (?) psymtab, this dependency tree is guaranteed not
+       to have any loops.  "depends on" means that symbols must be read
+       for the dependencies before being read for this psymtab; this is
+       for type references in stabs, where if foo.c includes foo.h, declarations
+       in foo.h may use type numbers defined in foo.c.  For other debugging
+       formats there may be no need to use dependencies.  */
 
-  struct partial_symtab **dependencies;
+    struct partial_symtab **dependencies;
 
-  int number_of_dependencies;
+    int number_of_dependencies;
 
-  /* Global symbol list.  This list will be sorted after readin to
-     improve access.  Binary search will be the usual method of
-     finding a symbol within it. globals_offset is an integer offset
-     within global_psymbols[].  */
+    /* Global symbol list.  This list will be sorted after readin to
+       improve access.  Binary search will be the usual method of
+       finding a symbol within it. globals_offset is an integer offset
+       within global_psymbols[].  */
 
-  int globals_offset;
-  int n_global_syms;
+    int globals_offset;
+    int n_global_syms;
 
-  /* Static symbol list.  This list will *not* be sorted after readin;
-     to find a symbol in it, exhaustive search must be used.  This is
-     reasonable because searches through this list will eventually
-     lead to either the read in of a files symbols for real (assumed
-     to take a *lot* of time; check) or an error (and we don't care
-     how long errors take).  This is an offset and size within
-     static_psymbols[].  */
+    /* Static symbol list.  This list will *not* be sorted after readin;
+       to find a symbol in it, exhaustive search must be used.  This is
+       reasonable because searches through this list will eventually
+       lead to either the read in of a files symbols for real (assumed
+       to take a *lot* of time; check) or an error (and we don't care
+       how long errors take).  This is an offset and size within
+       static_psymbols[].  */
 
-  int statics_offset;
-  int n_static_syms;
+    int statics_offset;
+    int n_static_syms;
 
-  /* Pointer to symtab eventually allocated for this source file, 0 if
-     !readin or if we haven't looked for the symtab after it was readin.  */
+    /* Pointer to symtab eventually allocated for this source file, 0 if
+       !readin or if we haven't looked for the symtab after it was readin.  */
 
-  struct symtab *symtab;
+    struct symtab *symtab;
 
-  /* Pointer to function which will read in the symtab corresponding to
-     this psymtab.  */
+    /* Pointer to function which will read in the symtab corresponding to
+       this psymtab.  */
 
-  void (*read_symtab) PARAMS ((struct partial_symtab *));
+    void (*read_symtab) PARAMS ((struct partial_symtab *));
 
-  /* Information that lets read_symtab() locate the part of the symbol table
-     that this psymtab corresponds to.  This information is private to the
-     format-dependent symbol reading routines.  For further detail examine
-     the various symbol reading modules.  Should really be (void *) but is
-     (char *) as with other such gdb variables.  (FIXME) */
+    /* Information that lets read_symtab() locate the part of the symbol table
+       that this psymtab corresponds to.  This information is private to the
+       format-dependent symbol reading routines.  For further detail examine
+       the various symbol reading modules.  Should really be (void *) but is
+       (char *) as with other such gdb variables.  (FIXME) */
 
-  char *read_symtab_private;
+    char *read_symtab_private;
 
-  /* Non-zero if the symtab corresponding to this psymtab has been readin */
+    /* Non-zero if the symtab corresponding to this psymtab has been readin */
 
-  unsigned char readin;
-};
+    unsigned char readin;
+  };
 
 /* A fast way to get from a psymtab to its symtab (after the first time).  */
 #define	PSYMTAB_TO_SYMTAB(pst)  \
     ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
-
 
+
 /* The virtual function table is now an array of structures which have the
    form { int16 offset, delta; void *pfn; }. 
 
@@ -1025,7 +1031,7 @@ struct partial_symtab
    PFN is a pointer to the virtual function.
 
    Note that this macro is g++ specific (FIXME). */
-  
+
 #define VTBL_FNADDR_OFFSET 2
 
 /* Macro that yields non-zero value iff NAME is the prefix for C++ operator
@@ -1053,8 +1059,8 @@ struct partial_symtab
 
 #define DESTRUCTOR_PREFIX_P(NAME) \
   ((NAME)[0] == '_' && is_cplus_marker ((NAME)[1]) && (NAME)[2] == '_')
-
 
+
 /* External variables and functions for the objects described above. */
 
 /* This symtab variable specifies the current file for printing source lines */
@@ -1082,97 +1088,97 @@ extern int asm_demangle;
 /* lookup a symbol table by source file name */
 
 extern struct symtab *
-lookup_symtab PARAMS ((char *));
+  lookup_symtab PARAMS ((char *));
 
 /* lookup a symbol by name (optional block, optional symtab) */
 
 extern struct symbol *
-lookup_symbol PARAMS ((const char *, const struct block *,
-		       const namespace_enum, int *, struct symtab **));
+  lookup_symbol PARAMS ((const char *, const struct block *,
+			 const namespace_enum, int *, struct symtab **));
 
 /* lookup a symbol by name, within a specified block */
-  
+
 extern struct symbol *
-lookup_block_symbol PARAMS ((const struct block *, const char *,
- 			     const namespace_enum));
+  lookup_block_symbol PARAMS ((const struct block *, const char *,
+			       const namespace_enum));
 
 /* lookup a [struct, union, enum] by name, within a specified block */
 
 extern struct type *
-lookup_struct PARAMS ((char *, struct block *));
+  lookup_struct PARAMS ((char *, struct block *));
 
 extern struct type *
-lookup_union PARAMS ((char *, struct block *));
+  lookup_union PARAMS ((char *, struct block *));
 
 extern struct type *
-lookup_enum PARAMS ((char *, struct block *));
+  lookup_enum PARAMS ((char *, struct block *));
 
 /* lookup the function corresponding to the block */
 
 extern struct symbol *
-block_function PARAMS ((struct block *));
+  block_function PARAMS ((struct block *));
 
 /* from blockframe.c: */
 
 /* lookup the function symbol corresponding to the address */
 
 extern struct symbol *
-find_pc_function PARAMS ((CORE_ADDR));
+  find_pc_function PARAMS ((CORE_ADDR));
 
 /* lookup the function corresponding to the address and section */
 
 extern struct symbol *
-find_pc_sect_function PARAMS ((CORE_ADDR, asection *));
-  
+  find_pc_sect_function PARAMS ((CORE_ADDR, asection *));
+
 /* lookup function from address, return name, start addr and end addr */
 
-extern int 
+extern int
 find_pc_partial_function PARAMS ((CORE_ADDR, char **,
-					     CORE_ADDR *, CORE_ADDR *));
+				  CORE_ADDR *, CORE_ADDR *));
 
 extern void
 clear_pc_function_cache PARAMS ((void));
 
-extern int 
-find_pc_sect_partial_function PARAMS ((CORE_ADDR, asection *, 
-                                       char **, CORE_ADDR *, CORE_ADDR *));
+extern int
+find_pc_sect_partial_function PARAMS ((CORE_ADDR, asection *,
+				       char **, CORE_ADDR *, CORE_ADDR *));
 
 /* from symtab.c: */
 
 /* lookup partial symbol table by filename */
 
 extern struct partial_symtab *
-lookup_partial_symtab PARAMS ((char *));
+  lookup_partial_symtab PARAMS ((char *));
 
 /* lookup partial symbol table by address */
 
 extern struct partial_symtab *
-find_pc_psymtab PARAMS ((CORE_ADDR));
+  find_pc_psymtab PARAMS ((CORE_ADDR));
 
 /* lookup partial symbol table by address and section */
 
 extern struct partial_symtab *
-find_pc_sect_psymtab PARAMS ((CORE_ADDR, asection *));
+  find_pc_sect_psymtab PARAMS ((CORE_ADDR, asection *));
 
 /* lookup full symbol table by address */
 
 extern struct symtab *
-find_pc_symtab PARAMS ((CORE_ADDR));
+  find_pc_symtab PARAMS ((CORE_ADDR));
 
 /* lookup full symbol table by address and section */
 
 extern struct symtab *
-find_pc_sect_symtab PARAMS ((CORE_ADDR, asection *));
+  find_pc_sect_symtab PARAMS ((CORE_ADDR, asection *));
 
 /* lookup partial symbol by address */
 
 extern struct partial_symbol *
-find_pc_psymbol PARAMS ((struct partial_symtab *, CORE_ADDR));
+  find_pc_psymbol PARAMS ((struct partial_symtab *, CORE_ADDR));
 
 /* lookup partial symbol by address and section */
 
 extern struct partial_symbol *
-find_pc_sect_psymbol PARAMS ((struct partial_symtab *, CORE_ADDR, asection *));
+  find_pc_sect_psymbol PARAMS ((struct partial_symtab *, CORE_ADDR, asection *));
 
 extern int
 find_pc_line_pc_range PARAMS ((CORE_ADDR, CORE_ADDR *, CORE_ADDR *));
@@ -1184,7 +1190,7 @@ extern void
 reread_symbols PARAMS ((void));
 
 extern struct type *
-lookup_transparent_type PARAMS ((const char *));
+  lookup_transparent_type PARAMS ((const char *));
 
 
 /* Macro for name of symbol to indicate a file compiled with gcc. */
@@ -1208,7 +1214,7 @@ extern struct minimal_symbol *prim_record_minimal_symbol_and_info
   PARAMS ((const char *, CORE_ADDR,
 	   enum minimal_symbol_type,
 	   char *info, int section,
-	   asection *bfd_section,
+	   asection * bfd_section,
 	   struct objfile *));
 
 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
@@ -1218,27 +1224,27 @@ extern CORE_ADDR find_stab_function_addr PARAMS ((char *,
 #endif
 
 extern struct minimal_symbol *
-lookup_minimal_symbol PARAMS ((const char *, const char *, struct objfile *));
+  lookup_minimal_symbol PARAMS ((const char *, const char *, struct objfile *));
 
 extern struct minimal_symbol *
-lookup_minimal_symbol_text PARAMS ((const char *, const char *, struct objfile *));
+  lookup_minimal_symbol_text PARAMS ((const char *, const char *, struct objfile *));
 
 struct minimal_symbol *
-lookup_minimal_symbol_solib_trampoline PARAMS ((const char *,
-						const char *,
-						struct objfile *));
+  lookup_minimal_symbol_solib_trampoline PARAMS ((const char *,
+						  const char *,
+						  struct objfile *));
 
 extern struct minimal_symbol *
-lookup_minimal_symbol_by_pc PARAMS ((CORE_ADDR));
+  lookup_minimal_symbol_by_pc PARAMS ((CORE_ADDR));
 
 extern struct minimal_symbol *
-lookup_minimal_symbol_by_pc_section PARAMS ((CORE_ADDR, asection *));
+  lookup_minimal_symbol_by_pc_section PARAMS ((CORE_ADDR, asection *));
 
 extern struct minimal_symbol *
-lookup_solib_trampoline_symbol_by_pc PARAMS ((CORE_ADDR));
+  lookup_solib_trampoline_symbol_by_pc PARAMS ((CORE_ADDR));
 
 extern CORE_ADDR
-find_solib_trampoline_target PARAMS ((CORE_ADDR));
+  find_solib_trampoline_target PARAMS ((CORE_ADDR));
 
 extern void
 init_minimal_symbol_collection PARAMS ((void));
@@ -1251,20 +1257,20 @@ install_minimal_symbols PARAMS ((struct objfile *));
 
 /* Sort all the minimal symbols in OBJFILE.  */
 
-extern void msymbols_sort PARAMS ((struct objfile *objfile));
+extern void msymbols_sort PARAMS ((struct objfile * objfile));
 
 struct symtab_and_line
-{
-  struct symtab *symtab;
-  asection      *section;
-  /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
-     0 is never a valid line number; it is used to indicate that line number
-     information is not available.  */
-  int line;
-
-  CORE_ADDR pc;
-  CORE_ADDR end;
-};
+  {
+    struct symtab *symtab;
+    asection *section;
+    /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
+       0 is never a valid line number; it is used to indicate that line number
+       information is not available.  */
+    int line;
+
+    CORE_ADDR pc;
+    CORE_ADDR end;
+  };
 
 #define INIT_SAL(sal) { \
   (sal)->symtab  = 0;   \
@@ -1275,34 +1281,36 @@ struct symtab_and_line
 }
 
 struct symtabs_and_lines
-{
-  struct symtab_and_line *sals;
-  int nelts;
-};
+  {
+    struct symtab_and_line *sals;
+    int nelts;
+  };
+
 
 
-
 /* Some types and macros needed for exception catchpoints.
    Can't put these in target.h because symtab_and_line isn't
    known there. This file will be included by breakpoint.c,
    hppa-tdep.c, etc. */
 
 /* Enums for exception-handling support */
-enum exception_event_kind {
-  EX_EVENT_THROW,
-  EX_EVENT_CATCH
-};
+enum exception_event_kind
+  {
+    EX_EVENT_THROW,
+    EX_EVENT_CATCH
+  };
 
 /* Type for returning info about an exception */
-struct exception_event_record {
-  enum exception_event_kind   kind;
-  struct symtab_and_line      throw_sal;
-  struct symtab_and_line      catch_sal;
-  /* This may need to be extended in the future, if
-     some platforms allow reporting more information,
-     such as point of rethrow, type of exception object,
-     type expected by catch clause, etc. */ 
-};
+struct exception_event_record
+  {
+    enum exception_event_kind kind;
+    struct symtab_and_line throw_sal;
+    struct symtab_and_line catch_sal;
+    /* This may need to be extended in the future, if
+       some platforms allow reporting more information,
+       such as point of rethrow, type of exception object,
+       type expected by catch clause, etc. */
+  };
 
 #define CURRENT_EXCEPTION_KIND       (current_exception_event->kind)
 #define CURRENT_EXCEPTION_CATCH_SAL  (current_exception_event->catch_sal)
@@ -1331,14 +1339,14 @@ find_pc_sect_line PARAMS ((CORE_ADDR, asection *, int));
    address in inferior memory of the symbol through 3rd arg.  */
 
 extern struct symbol *
-find_addr_symbol PARAMS ((CORE_ADDR, struct symtab **, CORE_ADDR *));
+  find_addr_symbol PARAMS ((CORE_ADDR, struct symtab **, CORE_ADDR *));
 
 /* Given a symtab and line number, return the pc there.  */
 
 extern int
 find_line_pc PARAMS ((struct symtab *, int, CORE_ADDR *));
 
-extern int 
+extern int
 find_line_pc_range PARAMS ((struct symtab_and_line,
 			    CORE_ADDR *, CORE_ADDR *));
 
@@ -1385,13 +1393,13 @@ free_symtab PARAMS ((struct symtab *));
 /* Symbol-reading stuff in symfile.c and solib.c.  */
 
 extern struct symtab *
-psymtab_to_symtab PARAMS ((struct partial_symtab *));
+  psymtab_to_symtab PARAMS ((struct partial_symtab *));
 
 extern void
 clear_solib PARAMS ((void));
 
 extern struct objfile *
-symbol_file_add PARAMS ((char *, int, CORE_ADDR, int, int, int, int, int));
+  symbol_file_add PARAMS ((char *, int, CORE_ADDR, int, int, int, int, int));
 
 /* source.c */
 
@@ -1410,21 +1418,21 @@ select_source_symtab PARAMS ((struct symtab *));
 extern char **make_symbol_completion_list PARAMS ((char *, char *));
 
 extern struct symbol **
-make_symbol_overload_list PARAMS ((struct symbol *));
+  make_symbol_overload_list PARAMS ((struct symbol *));
 
 /* symtab.c */
 
 extern struct partial_symtab *
-find_main_psymtab PARAMS ((void));
+  find_main_psymtab PARAMS ((void));
 
 /* blockframe.c */
 
 extern struct blockvector *
-blockvector_for_pc PARAMS ((CORE_ADDR, int *));
+  blockvector_for_pc PARAMS ((CORE_ADDR, int *));
 
 extern struct blockvector *
-blockvector_for_pc_sect PARAMS ((CORE_ADDR, asection *, int *, 
-				 struct symtab *));
+  blockvector_for_pc_sect PARAMS ((CORE_ADDR, asection *, int *,
+				   struct symtab *));
 
 /* symfile.c */
 
@@ -1440,32 +1448,32 @@ extern int
 in_prologue PARAMS ((CORE_ADDR pc, CORE_ADDR func_start));
 
 extern struct symbol *
-fixup_symbol_section PARAMS ((struct symbol  *, struct objfile *));
+  fixup_symbol_section PARAMS ((struct symbol *, struct objfile *));
 
 /* Symbol searching */
 
 /* When using search_symbols, a list of the following structs is returned.
    Callers must free the search list using free_symbol_search! */
 struct symbol_search
-{
-  /* The block in which the match was found. Could be, for example,
-     STATIC_BLOCK or GLOBAL_BLOCK. */
-  int block;
+  {
+    /* The block in which the match was found. Could be, for example,
+       STATIC_BLOCK or GLOBAL_BLOCK. */
+    int block;
 
-  /* Information describing what was found.
+    /* Information describing what was found.
 
-     If symtab abd symbol are NOT NULL, then information was found
-     for this match. */
-  struct symtab *symtab;
-  struct symbol *symbol;
+       If symtab abd symbol are NOT NULL, then information was found
+       for this match. */
+    struct symtab *symtab;
+    struct symbol *symbol;
 
-  /* If msymbol is non-null, then a match was made on something for
-     which only minimal_symbols exist. */
-  struct minimal_symbol *msymbol;
+    /* If msymbol is non-null, then a match was made on something for
+       which only minimal_symbols exist. */
+    struct minimal_symbol *msymbol;
 
-  /* A link to the next match, or NULL for the end. */
-  struct symbol_search *next;
-};
+    /* A link to the next match, or NULL for the end. */
+    struct symbol_search *next;
+  };
 
 extern void search_symbols PARAMS ((char *, namespace_enum, int, char **, struct symbol_search **));
 extern void free_search_symbols PARAMS ((struct symbol_search *));