This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] re-indent symtab.h (1/2)


To: gdb-patches@sources.redhat.com
Subject: [PATCH] re-indent symtab.h
Mime-Version: 1.0 (generated by tm-edit 1.8)
Content-Type: text/plain; charset=US-ASCII

As per Andrew's suggestion, I've run symtab.h through gdb_indent.sh.
(Is there a consistent pattern in the usage of _ vs - in GDB file
names?)  I also added 2002 to the list of Copyright years, while I've
added.

Patch is below; committed as obvious.

David Carlton
carlton@math.stanford.edu

Index: symtab.h
===================================================================
RCS file: /cvs/src/src/gdb/symtab.h,v
retrieving revision 1.38
diff -u -p -r1.38 symtab.h
--- symtab.h	1 Aug 2002 17:18:33 -0000	1.38
+++ symtab.h	12 Sep 2002 19:18:44 -0000
@@ -1,6 +1,6 @@
 /* Symbol table definitions for GDB.
    Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
-   1997, 1998, 1999, 2000, 2001
+   1997, 1998, 1999, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -46,78 +46,78 @@ struct obstack;
    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;
+
+    /* for opaque typedef struct chain */
+
+    struct symbol *chain;
+  }
+  value;
+
+  /* Since one and only one language can apply, wrap the language specific
+     information inside a union. */
+
+  union
   {
-    /* 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;
-
-	/* for opaque typedef struct chain */
-
-	struct symbol *chain;
-      }
-    value;
-
-    /* Since one and only one language can apply, wrap the language specific
-       information inside a union. */
-
-    union
-      {
-	struct cplus_specific	/* For C++ */
-	/*  and Java */
-	  {
-	    char *demangled_name;
-	  }
-	cplus_specific;
+    struct cplus_specific	/* For C++ */
+      /*  and Java */
+    {
+      char *demangled_name;
+    }
+    cplus_specific;
 #if 0
-	/* OBSOLETE struct chill_specific	 *//* For Chill */
-	/* OBSOLETE   { */
-	/* OBSOLETE     char *demangled_name; */
-	/* OBSOLETE   } */
-	/* OBSOLETE chill_specific; */
+/* OBSOLETE struct chill_specific        *//* For Chill */
+    /* OBSOLETE   { */
+    /* OBSOLETE     char *demangled_name; */
+    /* OBSOLETE   } */
+    /* OBSOLETE chill_specific; */
 #endif
-      }
-    language_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. */
+  /* 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;
+  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).  */
+  /* 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;
+  short section;
 
-    /* The bfd section associated with this symbol. */
+  /* The bfd section associated with this symbol. */
 
-    asection *bfd_section;
-  };
+  asection *bfd_section;
+};
 
 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, asection *);
 
@@ -160,9 +160,9 @@ extern CORE_ADDR symbol_overlayed_addres
 #define SYMBOL_INIT_DEMANGLED_NAME(symbol,obstack) \
   (symbol_init_demangled_name (&symbol->ginfo, (obstack)))
 extern void symbol_init_demangled_name (struct general_symbol_info *symbol,
-                                        struct obstack *obstack);
+					struct obstack *obstack);
+
 
-  
 /* Macro that returns the demangled name for a symbol based on the language
    for that symbol.  If no demangled name exists, returns NULL. */
 
@@ -233,82 +233,82 @@ extern void symbol_init_demangled_name (
    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.
-
-       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.  */
+  /* 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.
 
-    char *info;
+     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;
 
 #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;
-
-    /* Minimal symbols with the same hash key are kept on a linked
-       list.  This is the link.  */
+  /* 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;
+
+  /* Minimal symbols with the same hash key are kept on a linked
+     list.  This is the link.  */
 
-    struct minimal_symbol *hash_next;
+  struct minimal_symbol *hash_next;
 
-    /* Minimal symbols are stored in two different hash tables.  This is
-       the `next' pointer for the demangled hash table.  */
+  /* Minimal symbols are stored in two different hash tables.  This is
+     the `next' pointer for the demangled hash table.  */
 
-    struct minimal_symbol *demangled_hash_next;
-  };
+  struct minimal_symbol *demangled_hash_next;
+};
 
 #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.
@@ -336,12 +336,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]
@@ -353,66 +353,66 @@ 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;
 
-    /* The symbols for this block are either in a simple linear list or
-       in a simple hashtable.  Blocks which correspond to a function
-       (which have a list of symbols corresponding to arguments) use
-       a linear list, as do some older symbol readers (currently only
-       mdebugread and dstread).  Other blocks are hashed.
+  /* The symbols for this block are either in a simple linear list or
+     in a simple hashtable.  Blocks which correspond to a function
+     (which have a list of symbols corresponding to arguments) use
+     a linear list, as do some older symbol readers (currently only
+     mdebugread and dstread).  Other blocks are hashed.
 
-       The hashtable uses the same hash function as the minsym hashtables,
-       found in minsyms.c:minsym_hash_iw.  Symbols are hashed based on
-       their demangled name if appropriate, and on their name otherwise.
-       The hash function ignores space, and stops at the beginning of the
-       argument list if any.
+     The hashtable uses the same hash function as the minsym hashtables,
+     found in minsyms.c:minsym_hash_iw.  Symbols are hashed based on
+     their demangled name if appropriate, and on their name otherwise.
+     The hash function ignores space, and stops at the beginning of the
+     argument list if any.
 
-       The table is laid out in NSYMS/5 buckets and symbols are chained via
-       their hash_next field.  */
+     The table is laid out in NSYMS/5 buckets and symbols are chained via
+     their hash_next field.  */
 
-    /* If this is really a hashtable of the symbols, this flag is 1.  */
+  /* If this is really a hashtable of the symbols, this flag is 1.  */
 
-    unsigned char hashtable;
+  unsigned char hashtable;
 
-    /* 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
@@ -456,250 +456,248 @@ struct block
    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,
+{
+  /* 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. */
 
-    /* VAR_NAMESPACE is the usual namespace.  In C, this contains variables,
-       function names, typedef names and enum type values. */
+  UNDEF_NAMESPACE,
 
-    VAR_NAMESPACE,
+  /* VAR_NAMESPACE is the usual namespace.  In C, this contains variables,
+     function names, typedef names and enum type values. */
 
-    /* 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. */
+  VAR_NAMESPACE,
 
-    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. */
 
-    /* LABEL_NAMESPACE may be used for names of labels (for gotos);
-       currently it is not used and labels are not recorded at all.  */
+  STRUCT_NAMESPACE,
 
-    LABEL_NAMESPACE,
+  /* LABEL_NAMESPACE may be used for names of labels (for gotos);
+     currently it is not used and labels are not recorded at all.  */
 
-    /* Searching namespaces. These overlap with VAR_NAMESPACE, providing
-       some granularity with the search_symbols function. */
+  LABEL_NAMESPACE,
 
-    /* Everything in VAR_NAMESPACE minus FUNCTIONS_-, TYPES_-, and
-       METHODS_NAMESPACE */
-    VARIABLES_NAMESPACE,
+  /* Searching namespaces. These overlap with VAR_NAMESPACE, providing
+     some granularity with the search_symbols function. */
 
-    /* All functions -- for some reason not methods, though. */
-    FUNCTIONS_NAMESPACE,
+  /* Everything in VAR_NAMESPACE minus FUNCTIONS_-, TYPES_-, and
+     METHODS_NAMESPACE */
+  VARIABLES_NAMESPACE,
 
-    /* All defined types */
-    TYPES_NAMESPACE,
+  /* All functions -- for some reason not methods, though. */
+  FUNCTIONS_NAMESPACE,
 
-    /* All class methods -- why is this separated out? */
-    METHODS_NAMESPACE
+  /* All defined types */
+  TYPES_NAMESPACE,
 
-  }
+  /* All class methods -- why is this separated out? */
+  METHODS_NAMESPACE
+}
 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,
+  LOC_THREAD_LOCAL_STATIC,
 
-    /* The variable does not actually exist in the program.
-       The value is ignored.  */
+  /* The variable does not actually exist in the program.
+     The value is ignored.  */
 
-    LOC_OPTIMIZED_OUT,
+  LOC_OPTIMIZED_OUT,
 
-    /* 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.
-     */
+  /* 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
-
-  };
+  LOC_INDIRECT
+};
 
 /* Linked list of symbol's live ranges. */
 
 struct range_list
-  {
-    CORE_ADDR start;
-    CORE_ADDR end;
-    struct range_list *next;
-  };
+{
+  CORE_ADDR start;
+  CORE_ADDR end;
+  struct range_list *next;
+};
 
 /* Linked list of aliases for a particular main/primary symbol.  */
 struct alias_list
-  {
-    struct symbol *sym;
-    struct alias_list *next;
-  };
+{
+  struct symbol *sym;
+  struct alias_list *next;
+};
 
 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. */
+  /* 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;
+  unsigned short line;
 
-    /* Some symbols require an additional value to be recorded on a per-
-       symbol basis.  Stash those values here. */
+  /* 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;
+  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;
 
-    struct symbol *hash_next;
-  };
+  struct symbol *hash_next;
+};
 
 
 #define SYMBOL_NAMESPACE(symbol)	(symbol)->namespace
@@ -718,21 +716,21 @@ 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
@@ -742,10 +740,10 @@ struct partial_symbol
    line 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
@@ -753,10 +751,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
@@ -776,22 +774,22 @@ struct linetable_entry
    zero length.  */
 
 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.
@@ -804,9 +802,9 @@ struct source
    extract offset values in the struct.  */
 
 struct section_offsets
-  {
-    CORE_ADDR offsets[1];	/* As many as needed. */
-  };
+{
+  CORE_ADDR offsets[1];		/* As many as needed. */
+};
 
 #define	ANOFFSET(secoff, whichone) \
    ((whichone == -1) \
@@ -823,100 +821,100 @@ struct section_offsets
    These objects are chained through the `next' field.  */
 
 struct symtab
-  {
+{
 
-    /* Chain of all existing symtabs.  */
+  /* Chain of all existing symtabs.  */
 
-    struct symtab *next;
+  struct symtab *next;
 
-    /* List of all symbol scope blocks for this symtab.  May be shared
-       between different symtabs (and normally is for all the symtabs
-       in a given compilation unit).  */
+  /* List of all symbol scope blocks for this symtab.  May be shared
+     between different symtabs (and normally is for all the symtabs
+     in a given compilation unit).  */
 
-    struct blockvector *blockvector;
+  struct blockvector *blockvector;
 
-    /* Table mapping core addresses to line numbers for this file.
-       Can be NULL if none.  Never shared between different symtabs.  */
+  /* Table mapping core addresses to line numbers for this file.
+     Can be NULL if none.  Never shared between different symtabs.  */
 
-    struct linetable *linetable;
+  struct linetable *linetable;
 
-    /* Section in objfile->section_offsets for the blockvector and


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]