Initial creation of sourceware repository

1 files changed, 0 insertions, 5865 deletions

diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
deleted file mode 100644
index cf52066..0000000
--- a/gdb/dwarf2read.c
+++ /dev/null
@@ -1,5865 +0,0 @@
-/* DWARF 2 debugging format support for GDB.
-   Copyright 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
-
-   Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
-   Inc.  with support from Florida State University (under contract
-   with the Ada Joint Program Office), and Silicon Graphics, Inc.
-   Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
-   based on Fred Fish's (Cygnus Support) implementation of DWARF 1
-   support in dwarfread.c
-
-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 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.  */
-
-#include "defs.h"
-#include "bfd.h"
-#include "elf-bfd.h"
-#include "symtab.h"
-#include "gdbtypes.h"
-#include "symfile.h"
-#include "objfiles.h"
-#include "elf/dwarf2.h"
-#include "buildsym.h"
-#include "demangle.h"
-#include "expression.h"
-#include "language.h"
-#include "complaints.h"
-
-#include <fcntl.h>
-#include "gdb_string.h"
-#include <sys/types.h>
-
-/* .debug_info header for a compilation unit 
-   Because of alignment constraints, this structure has padding and cannot
-   be mapped directly onto the beginning of the .debug_info section.  */
-typedef struct comp_unit_header
-  {
-    unsigned int length;	/* length of the .debug_info
-				   contribution */
-    unsigned short version;	/* version number -- 2 for DWARF
-				   version 2 */
-    unsigned int abbrev_offset;	/* offset into .debug_abbrev section */
-    unsigned char addr_size;	/* byte size of an address -- 4 */
-  }
-_COMP_UNIT_HEADER;
-#define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
-
-/* .debug_pubnames header
-   Because of alignment constraints, this structure has padding and cannot
-   be mapped directly onto the beginning of the .debug_info section.  */
-typedef struct pubnames_header
-  {
-    unsigned int length;	/* length of the .debug_pubnames
-				   contribution  */
-    unsigned char version;	/* version number -- 2 for DWARF
-				   version 2 */
-    unsigned int info_offset;	/* offset into .debug_info section */
-    unsigned int info_size;	/* byte size of .debug_info section
-				   portion */
-  }
-_PUBNAMES_HEADER;
-#define _ACTUAL_PUBNAMES_HEADER_SIZE 13
-
-/* .debug_pubnames header
-   Because of alignment constraints, this structure has padding and cannot
-   be mapped directly onto the beginning of the .debug_info section.  */
-typedef struct aranges_header
-  {
-    unsigned int length;	/* byte len of the .debug_aranges
-				   contribution */
-    unsigned short version;	/* version number -- 2 for DWARF
-				   version 2 */
-    unsigned int info_offset;	/* offset into .debug_info section */
-    unsigned char addr_size;	/* byte size of an address */
-    unsigned char seg_size;	/* byte size of segment descriptor */
-  }
-_ARANGES_HEADER;
-#define _ACTUAL_ARANGES_HEADER_SIZE 12
-
-/* .debug_line statement program prologue
-   Because of alignment constraints, this structure has padding and cannot
-   be mapped directly onto the beginning of the .debug_info section.  */
-typedef struct statement_prologue
-  {
-    unsigned int total_length;	/* byte length of the statement
-				   information */
-    unsigned short version;	/* version number -- 2 for DWARF
-				   version 2 */
-    unsigned int prologue_length;	/* # bytes between prologue &
-					   stmt program */
-    unsigned char minimum_instruction_length;	/* byte size of
-						   smallest instr */
-    unsigned char default_is_stmt;	/* initial value of is_stmt
-					   register */
-    char line_base;
-    unsigned char line_range;
-    unsigned char opcode_base;	/* number assigned to first special
-				   opcode */
-    unsigned char *standard_opcode_lengths;
-  }
-_STATEMENT_PROLOGUE;
-
-/* offsets and sizes of debugging sections */
-
-static file_ptr dwarf_info_offset;
-static file_ptr dwarf_abbrev_offset;
-static file_ptr dwarf_line_offset;
-static file_ptr dwarf_pubnames_offset;
-static file_ptr dwarf_aranges_offset;
-static file_ptr dwarf_loc_offset;
-static file_ptr dwarf_macinfo_offset;
-static file_ptr dwarf_str_offset;
-
-static unsigned int dwarf_info_size;
-static unsigned int dwarf_abbrev_size;
-static unsigned int dwarf_line_size;
-static unsigned int dwarf_pubnames_size;
-static unsigned int dwarf_aranges_size;
-static unsigned int dwarf_loc_size;
-static unsigned int dwarf_macinfo_size;
-static unsigned int dwarf_str_size;
-
-/* names of the debugging sections */
-
-#define INFO_SECTION     ".debug_info"
-#define ABBREV_SECTION   ".debug_abbrev"
-#define LINE_SECTION     ".debug_line"
-#define PUBNAMES_SECTION ".debug_pubnames"
-#define ARANGES_SECTION  ".debug_aranges"
-#define LOC_SECTION      ".debug_loc"
-#define MACINFO_SECTION  ".debug_macinfo"
-#define STR_SECTION      ".debug_str"
-
-/* local data types */
-
-/* The data in a compilation unit header looks like this.  */
-struct comp_unit_head
-  {
-    unsigned int length;
-    short version;
-    unsigned int abbrev_offset;
-    unsigned char addr_size;
-  };
-
-/* The data in the .debug_line statement prologue looks like this.  */
-struct line_head
-  {
-    unsigned int total_length;
-    unsigned short version;
-    unsigned int prologue_length;
-    unsigned char minimum_instruction_length;
-    unsigned char default_is_stmt;
-    int line_base;
-    unsigned char line_range;
-    unsigned char opcode_base;
-    unsigned char *standard_opcode_lengths;
-  };
-
-/* When we construct a partial symbol table entry we only
-   need this much information. */
-struct partial_die_info
-  {
-    enum dwarf_tag tag;
-    unsigned char has_children;
-    unsigned char is_external;
-    unsigned char is_declaration;
-    unsigned char has_type;
-    unsigned int offset;
-    unsigned int abbrev;
-    char *name;
-    CORE_ADDR lowpc;
-    CORE_ADDR highpc;
-    struct dwarf_block *locdesc;
-    unsigned int language;
-    char *sibling;
-  };
-
-/* This data structure holds the information of an abbrev. */
-struct abbrev_info
-  {
-    unsigned int number;	/* number identifying abbrev */
-    enum dwarf_tag tag;		/* dwarf tag */
-    int has_children;		/* boolean */
-    unsigned int num_attrs;	/* number of attributes */
-    struct attr_abbrev *attrs;	/* an array of attribute descriptions */
-    struct abbrev_info *next;	/* next in chain */
-  };
-
-struct attr_abbrev
-  {
-    enum dwarf_attribute name;
-    enum dwarf_form form;
-  };
-
-/* This data structure holds a complete die structure. */
-struct die_info
-  {
-    enum dwarf_tag tag;		 /* Tag indicating type of die */
-    unsigned short has_children; /* Does the die have children */
-    unsigned int abbrev;	 /* Abbrev number */
-    unsigned int offset;	 /* Offset in .debug_info section */
-    unsigned int num_attrs;	 /* Number of attributes */
-    struct attribute *attrs;	 /* An array of attributes */
-    struct die_info *next_ref;	 /* Next die in ref hash table */
-    struct die_info *next;	 /* Next die in linked list */
-    struct type *type;		 /* Cached type information */
-  };
-
-/* Attributes have a name and a value */
-struct attribute
-  {
-    enum dwarf_attribute name;
-    enum dwarf_form form;
-    union
-      {
-	char *str;
-	struct dwarf_block *blk;
-	unsigned int unsnd;
-	int snd;
-	CORE_ADDR addr;
-      }
-    u;
-  };
-
-/* Get at parts of an attribute structure */
-
-#define DW_STRING(attr)    ((attr)->u.str)
-#define DW_UNSND(attr)     ((attr)->u.unsnd)
-#define DW_BLOCK(attr)     ((attr)->u.blk)
-#define DW_SND(attr)       ((attr)->u.snd)
-#define DW_ADDR(attr)	   ((attr)->u.addr)
-
-/* Blocks are a bunch of untyped bytes. */
-struct dwarf_block
-  {
-    unsigned int size;
-    char *data;
-  };
-
-/* We only hold one compilation unit's abbrevs in
-   memory at any one time.  */
-#ifndef ABBREV_HASH_SIZE
-#define ABBREV_HASH_SIZE 121
-#endif
-#ifndef ATTR_ALLOC_CHUNK
-#define ATTR_ALLOC_CHUNK 4
-#endif
-
-static struct abbrev_info *dwarf2_abbrevs[ABBREV_HASH_SIZE];
-
-/* A hash table of die offsets for following references.  */
-#ifndef REF_HASH_SIZE
-#define REF_HASH_SIZE 1021
-#endif
-
-static struct die_info *die_ref_table[REF_HASH_SIZE];
-
-/* Obstack for allocating temporary storage used during symbol reading.  */
-static struct obstack dwarf2_tmp_obstack;
-
-/* Offset to the first byte of the current compilation unit header,
-   for resolving relative reference dies. */
-static unsigned int cu_header_offset;
-
-/* Allocate fields for structs, unions and enums in this size.  */
-#ifndef DW_FIELD_ALLOC_CHUNK
-#define DW_FIELD_ALLOC_CHUNK 4
-#endif
-
-/* The language we are debugging.  */
-static enum language cu_language;
-static const struct language_defn *cu_language_defn;
-
-/* Actually data from the sections.  */
-static char *dwarf_info_buffer;
-static char *dwarf_abbrev_buffer;
-static char *dwarf_line_buffer;
-
-/* A zeroed version of a partial die for initialization purposes.  */
-static struct partial_die_info zeroed_partial_die;
-
-/* The generic symbol table building routines have separate lists for
-   file scope symbols and all all other scopes (local scopes).  So
-   we need to select the right one to pass to add_symbol_to_list().
-   We do it by keeping a pointer to the correct list in list_in_scope.
-
-   FIXME:  The original dwarf code just treated the file scope as the first
-   local scope, and all other local scopes as nested local scopes, and worked
-   fine.  Check to see if we really need to distinguish these
-   in buildsym.c.  */
-static struct pending **list_in_scope = &file_symbols;
-
-/* FIXME: The following variables pass additional information from
-   decode_locdesc to the caller.  */
-static int optimized_out;	/* Kludge to identify optimized out variables */
-static int isreg;		/* Kludge to identify register variables */
-static int offreg;		/* Kludge to identify basereg references */
-static int basereg;		/* Which base register is it relative to?  */
-static int islocal;		/* Kludge to identify local variables */
-
-/* DW_AT_frame_base values for the current function.
-   frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
-   contains the register number for the frame register.
-   frame_base_offset is the offset from the frame register to the
-   virtual stack frame. */
-static int frame_base_reg;
-static CORE_ADDR frame_base_offset;
-
-/* This value is added to each symbol value.  FIXME:  Generalize to 
-   the section_offsets structure used by dbxread (once this is done,
-   pass the appropriate section number to end_symtab).  */
-static CORE_ADDR baseaddr;	/* Add to each symbol value */
-
-/* We put a pointer to this structure in the read_symtab_private field
-   of the psymtab.
-   The complete dwarf information for an objfile is kept in the
-   psymbol_obstack, so that absolute die references can be handled.
-   Most of the information in this structure is related to an entire
-   object file and could be passed via the sym_private field of the objfile.
-   It is however conceivable that dwarf2 might not be the only type
-   of symbols read from an object file.  */
-
-struct dwarf2_pinfo
-{
-  /* Pointer to start of dwarf info buffer for the objfile.  */
-
-  char *dwarf_info_buffer;
-
-  /* Offset in dwarf_info_buffer for this compilation unit. */
-
-  unsigned long dwarf_info_offset;
-
-  /* Pointer to start of dwarf abbreviation buffer for the objfile.  */
-
-  char *dwarf_abbrev_buffer;
-
-  /* Size of dwarf abbreviation section for the objfile.  */
-
-  unsigned int dwarf_abbrev_size;
-
-  /* Pointer to start of dwarf line buffer for the objfile.  */
-
-  char *dwarf_line_buffer;
-};
-
-#define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
-#define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
-#define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
-#define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
-#define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
-#define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
-
-/* Maintain an array of referenced fundamental types for the current
-   compilation unit being read.  For DWARF version 1, we have to construct
-   the fundamental types on the fly, since no information about the
-   fundamental types is supplied.  Each such fundamental type is created by
-   calling a language dependent routine to create the type, and then a
-   pointer to that type is then placed in the array at the index specified
-   by it's FT_<TYPENAME> value.  The array has a fixed size set by the
-   FT_NUM_MEMBERS compile time constant, which is the number of predefined
-   fundamental types gdb knows how to construct.  */
-static struct type *ftypes[FT_NUM_MEMBERS];	/* Fundamental types */
-
-/* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
-   but this would require a corresponding change in unpack_field_as_long
-   and friends.  */
-static int bits_per_byte = 8;
-
-/* The routines that read and process dies for a C struct or C++ class
-   pass lists of data member fields and lists of member function fields
-   in an instance of a field_info structure, as defined below.  */
-struct field_info
-{
-  /* List of data member and baseclasses fields. */
-  struct nextfield
-    {
-      struct nextfield *next;
-      int accessibility;
-      int virtuality;
-      struct field field;
-    } *fields;
-
-  /* Number of fields.  */
-  int nfields;
-
-  /* Number of baseclasses.  */
-  int nbaseclasses;
-
-  /* Set if the accesibility of one of the fields is not public.  */
-  int non_public_fields;
-
-  /* Member function fields array, entries are allocated in the order they
-     are encountered in the object file.  */
-  struct nextfnfield
-    {
-      struct nextfnfield *next;
-      struct fn_field fnfield;
-    } *fnfields;
-
-  /* Member function fieldlist array, contains name of possibly overloaded
-     member function, number of overloaded member functions and a pointer
-     to the head of the member function field chain.  */
-  struct fnfieldlist
-    {
-      char *name;
-      int length;
-      struct nextfnfield *head;
-    } *fnfieldlists;
-
-  /* Number of entries in the fnfieldlists array.  */
-  int nfnfields;
-};
-
-/* FIXME: Kludge to mark a varargs function type for C++ member function
-   argument processing.  */
-#define TYPE_FLAG_VARARGS	(1 << 10)
-
-/* Dwarf2 has no clean way to discern C++ static and non-static member
-   functions. G++ helps GDB by marking the first parameter for non-static
-   member functions (which is the this pointer) as artificial.
-   We pass this information between dwarf2_add_member_fn and
-   read_subroutine_type via TYPE_FIELD_ARTIFICIAL.  */
-#define TYPE_FIELD_ARTIFICIAL	TYPE_FIELD_BITPOS
-
-/* Various complaints about symbol reading that don't abort the process */
-
-static struct complaint dwarf2_const_ignored =
-{
-  "type qualifier 'const' ignored", 0, 0
-};
-static struct complaint dwarf2_volatile_ignored =
-{
-  "type qualifier 'volatile' ignored", 0, 0
-};
-static struct complaint dwarf2_non_const_array_bound_ignored =
-{
-  "non-constant array bounds form '%s' ignored", 0, 0
-};
-static struct complaint dwarf2_missing_line_number_section =
-{
-  "missing .debug_line section", 0, 0
-};
-static struct complaint dwarf2_mangled_line_number_section =
-{
-  "mangled .debug_line section", 0, 0
-};
-static struct complaint dwarf2_unsupported_die_ref_attr =
-{
-  "unsupported die ref attribute form: '%s'", 0, 0
-};
-static struct complaint dwarf2_unsupported_stack_op =
-{
-  "unsupported stack op: '%s'", 0, 0
-};
-static struct complaint dwarf2_unsupported_tag =
-{
-  "unsupported tag: '%s'", 0, 0
-};
-static struct complaint dwarf2_unsupported_at_encoding =
-{
-  "unsupported DW_AT_encoding: '%s'", 0, 0
-};
-static struct complaint dwarf2_unsupported_at_frame_base =
-{
-  "unsupported DW_AT_frame_base for function '%s'", 0, 0
-};
-static struct complaint dwarf2_unexpected_tag =
-{
-  "unexepected tag in read_type_die: '%s'", 0, 0
-};
-static struct complaint dwarf2_missing_at_frame_base =
-{
-  "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
-};
-static struct complaint dwarf2_bad_static_member_name =
-{
-  "unrecognized static data member name '%s'", 0, 0
-};
-static struct complaint dwarf2_unsupported_accessibility =
-{
-  "unsupported accessibility %d", 0, 0
-};
-static struct complaint dwarf2_bad_member_name_complaint =
-{
-  "cannot extract member name from '%s'", 0, 0
-};
-static struct complaint dwarf2_missing_member_fn_type_complaint =
-{
-  "member function type missing for '%s'", 0, 0
-};
-static struct complaint dwarf2_vtbl_not_found_complaint =
-{
-  "virtual function table pointer not found when defining class '%s'", 0, 0
-};
-static struct complaint dwarf2_absolute_sibling_complaint =
-{
-  "ignoring absolute DW_AT_sibling", 0, 0
-};
-static struct complaint dwarf2_const_value_length_mismatch =
-{
-  "const value length mismatch for '%s', got %d, expected %d", 0, 0
-};
-static struct complaint dwarf2_unsupported_const_value_attr =
-{
-  "unsupported const value attribute form: '%s'", 0, 0
-};
-
-/* Remember the addr_size read from the dwarf.
-   If a target expects to link compilation units with differing address
-   sizes, gdb needs to be sure that the appropriate size is here for
-   whatever scope is currently getting read. */
-static int address_size;
-
-/* Some elf32 object file formats while linked for a 32 bit address
-   space contain debug information that has assumed 64 bit
-   addresses. Eg 64 bit MIPS target produced by GCC/GAS/LD where the
-   symbol table contains 32bit address values while its .debug_info
-   section contains 64 bit address values.
-   ADDRESS_SIGNIFICANT_SIZE specifies the number significant bits in
-   the ADDRESS_SIZE bytes read from the file */
-static int address_significant_size;
-
-/* Externals references.  */
-extern int info_verbose;	/* From main.c; nonzero => verbose */
-
-/* local function prototypes */
-
-static void dwarf2_locate_sections PARAMS ((bfd *, asection *, PTR));
-
-#if 0
-static void dwarf2_build_psymtabs_easy PARAMS ((struct objfile *,
-						struct section_offsets *,
-						int));
-#endif
-
-static void dwarf2_build_psymtabs_hard PARAMS ((struct objfile *,
-						struct section_offsets *,
-						int));
-
-static char *scan_partial_symbols PARAMS ((char *, struct objfile *,
-					   CORE_ADDR *, CORE_ADDR *));
-
-static void add_partial_symbol PARAMS ((struct partial_die_info *,
-					struct objfile *));
-
-static void dwarf2_psymtab_to_symtab PARAMS ((struct partial_symtab *));
-
-static void psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
-
-static char *dwarf2_read_section PARAMS ((struct objfile *, file_ptr,
-					  unsigned int));
-
-static void dwarf2_read_abbrevs PARAMS ((bfd *, unsigned int));
-
-static void dwarf2_empty_abbrev_table PARAMS ((PTR));
-
-static struct abbrev_info *dwarf2_lookup_abbrev PARAMS ((unsigned int));
-
-static char *read_partial_die PARAMS ((struct partial_die_info *,
-				       bfd *, char *, int *));
-
-static char *read_full_die PARAMS ((struct die_info **, bfd *, char *));
-
-static char *read_attribute PARAMS ((struct attribute *, struct attr_abbrev *,
-				     bfd *, char *));
-
-static unsigned int read_1_byte PARAMS ((bfd *, char *));
-
-static int read_1_signed_byte PARAMS ((bfd *, char *));
-
-static unsigned int read_2_bytes PARAMS ((bfd *, char *));
-
-static unsigned int read_4_bytes PARAMS ((bfd *, char *));
-
-static unsigned int read_8_bytes PARAMS ((bfd *, char *));
-
-static CORE_ADDR read_address PARAMS ((bfd *, char *));
-
-static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
-
-static char *read_string PARAMS ((bfd *, char *, unsigned int *));
-
-static unsigned int read_unsigned_leb128 PARAMS ((bfd *, char *,
-						  unsigned int *));
-
-static int read_signed_leb128 PARAMS ((bfd *, char *, unsigned int *));
-
-static void set_cu_language PARAMS ((unsigned int));
-
-static struct attribute *dwarf_attr PARAMS ((struct die_info *,
-					     unsigned int));
-
-static void dwarf_decode_lines PARAMS ((unsigned int, char *, bfd *));
-
-static void dwarf2_start_subfile PARAMS ((char *, char *));
-
-static struct symbol *new_symbol PARAMS ((struct die_info *, struct type *,
-					  struct objfile *));
-
-static void dwarf2_const_value PARAMS ((struct attribute *, struct symbol *,
-					struct objfile *));
-
-static struct type *die_type PARAMS ((struct die_info *, struct objfile *));
-
-static struct type *die_containing_type PARAMS ((struct die_info *,
-						 struct objfile *));
-
-#if 0
-static struct type *type_at_offset PARAMS ((unsigned int, struct objfile *));
-#endif
-
-static struct type *tag_type_to_type PARAMS ((struct die_info *,
-					      struct objfile *));
-
-static void read_type_die PARAMS ((struct die_info *, struct objfile *));
-
-static void read_typedef PARAMS ((struct die_info *, struct objfile *));
-
-static void read_base_type PARAMS ((struct die_info *, struct objfile *));
-
-static void read_file_scope PARAMS ((struct die_info *, struct objfile *));
-
-static void read_func_scope PARAMS ((struct die_info *, struct objfile *));
-
-static void read_lexical_block_scope PARAMS ((struct die_info *,
-					      struct objfile *));
-
-static int dwarf2_get_pc_bounds PARAMS ((struct die_info *,
-					 CORE_ADDR *, CORE_ADDR *,
-					 struct objfile *));
-
-static void dwarf2_add_field PARAMS ((struct field_info *, struct die_info *,
-				      struct objfile *));
-
-static void dwarf2_attach_fields_to_type PARAMS ((struct field_info *,
-						  struct type *, 
-						  struct objfile *));
-
-static char *skip_member_fn_name PARAMS ((char *));
-
-static void dwarf2_add_member_fn PARAMS ((struct field_info *,
-					  struct die_info *, struct type *,
-					  struct objfile *objfile));
-
-static void dwarf2_attach_fn_fields_to_type PARAMS ((struct field_info *,
-						     struct type *,
-						     struct objfile *));
-
-static void read_structure_scope PARAMS ((struct die_info *, struct objfile *));
-
-static void read_common_block PARAMS ((struct die_info *, struct objfile *));
-
-static void read_enumeration PARAMS ((struct die_info *, struct objfile *));
-
-static struct type *dwarf_base_type PARAMS ((int, int, struct objfile *));
-
-static CORE_ADDR decode_locdesc PARAMS ((struct dwarf_block *,
-					 struct objfile *));
-
-static void read_array_type PARAMS ((struct die_info *, struct objfile *));
-
-static void read_tag_pointer_type PARAMS ((struct die_info *,
-					   struct objfile *));
-
-static void read_tag_ptr_to_member_type PARAMS ((struct die_info *,
-						 struct objfile *));
-
-static void read_tag_reference_type PARAMS ((struct die_info *,
-					     struct objfile *));
-
-static void read_tag_const_type PARAMS ((struct die_info *, struct objfile *));
-
-static void read_tag_volatile_type PARAMS ((struct die_info *,
-					    struct objfile *));
-
-static void read_tag_string_type PARAMS ((struct die_info *,
-					  struct objfile *));
-
-static void read_subroutine_type PARAMS ((struct die_info *,
-					  struct objfile *));
-
-struct die_info *read_comp_unit PARAMS ((char *, bfd *));
-
-static void free_die_list PARAMS ((struct die_info *));
-
-static void process_die PARAMS ((struct die_info *, struct objfile *));
-
-static char *dwarf2_linkage_name PARAMS ((struct die_info *));
-
-static char *dwarf_tag_name PARAMS ((unsigned int));
-
-static char *dwarf_attr_name PARAMS ((unsigned int));
-
-static char *dwarf_form_name PARAMS ((unsigned int));
-
-static char *dwarf_stack_op_name PARAMS ((unsigned int));
-
-static char *dwarf_bool_name PARAMS ((unsigned int));
-
-static char *dwarf_type_encoding_name PARAMS ((unsigned int));
-
-#if 0
-static char *dwarf_cfi_name PARAMS ((unsigned int));
-
-struct die_info *copy_die PARAMS ((struct die_info *));
-#endif
-
-struct die_info *sibling_die PARAMS ((struct die_info *));
-
-void dump_die PARAMS ((struct die_info *));
-
-void dump_die_list PARAMS ((struct die_info *));
-
-void store_in_ref_table PARAMS ((unsigned int, struct die_info *));
-
-static void dwarf2_empty_die_ref_table PARAMS ((void));
-
-static unsigned int dwarf2_get_ref_die_offset PARAMS ((struct attribute *));
-
-struct die_info *follow_die_ref PARAMS ((unsigned int));
-
-static struct type *dwarf2_fundamental_type PARAMS ((struct objfile *, int));
-
-/* memory allocation interface */
-
-static void dwarf2_free_tmp_obstack PARAMS ((PTR));
-
-static struct dwarf_block *dwarf_alloc_block PARAMS ((void));
-
-static struct abbrev_info *dwarf_alloc_abbrev PARAMS ((void));
-
-static struct die_info *dwarf_alloc_die PARAMS ((void));
-
-/* Try to locate the sections we need for DWARF 2 debugging
-   information and return true if we have enough to do something.  */
-
-int
-dwarf2_has_info (abfd)
-     bfd *abfd;
-{
-  dwarf_info_offset = dwarf_abbrev_offset = dwarf_line_offset = 0;
-  bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL);
-  if (dwarf_info_offset && dwarf_abbrev_offset)
-    {
-      return 1;
-    }
-  else
-    {
-      return 0;
-    }
-}
-
-/* This function is mapped across the sections and remembers the
-   offset and size of each of the debugging sections we are interested
-   in.  */
-
-static void
-dwarf2_locate_sections (ignore_abfd, sectp, ignore_ptr)
-     bfd *ignore_abfd;
-     asection *sectp;
-     PTR ignore_ptr;
-{
-  if (STREQ (sectp->name, INFO_SECTION))
-    {
-      dwarf_info_offset = sectp->filepos;
-      dwarf_info_size = bfd_get_section_size_before_reloc (sectp);
-    }
-  else if (STREQ (sectp->name, ABBREV_SECTION))
-    {
-      dwarf_abbrev_offset = sectp->filepos;
-      dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp);
-    }
-  else if (STREQ (sectp->name, LINE_SECTION))
-    {
-      dwarf_line_offset = sectp->filepos;
-      dwarf_line_size = bfd_get_section_size_before_reloc (sectp);
-    }
-  else if (STREQ (sectp->name, PUBNAMES_SECTION))
-    {
-      dwarf_pubnames_offset = sectp->filepos;
-      dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp);
-    }
-  else if (STREQ (sectp->name, ARANGES_SECTION))
-    {
-      dwarf_aranges_offset = sectp->filepos;
-      dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp);
-    }
-  else if (STREQ (sectp->name, LOC_SECTION))
-    {
-      dwarf_loc_offset = sectp->filepos;
-      dwarf_loc_size = bfd_get_section_size_before_reloc (sectp);
-    }
-  else if (STREQ (sectp->name, MACINFO_SECTION))
-    {
-      dwarf_macinfo_offset = sectp->filepos;
-      dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp);
-    }
-  else if (STREQ (sectp->name, STR_SECTION))
-    {
-      dwarf_str_offset = sectp->filepos;
-      dwarf_str_size = bfd_get_section_size_before_reloc (sectp);
-    }
-}
-
-/* Build a partial symbol table.  */
-
-void
-dwarf2_build_psymtabs (objfile, section_offsets, mainline)
-    struct objfile *objfile;
-    struct section_offsets *section_offsets;
-    int mainline;
-{
-
-  /* We definitely need the .debug_info and .debug_abbrev sections */
-
-  dwarf_info_buffer = dwarf2_read_section (objfile,
-					   dwarf_info_offset,
-					   dwarf_info_size);
-  dwarf_abbrev_buffer = dwarf2_read_section (objfile,
-					     dwarf_abbrev_offset,
-					     dwarf_abbrev_size);
-  dwarf_line_buffer = dwarf2_read_section (objfile,
-					   dwarf_line_offset,
-					   dwarf_line_size);
-
-  if (mainline || objfile->global_psymbols.size == 0 ||
-      objfile->static_psymbols.size == 0)
-    {
-      init_psymbol_list (objfile, 1024);
-    }
-
-#if 0
-  if (dwarf_aranges_offset && dwarf_pubnames_offset)
-    {
-      /* Things are significanlty easier if we have .debug_aranges and
-         .debug_pubnames sections */
-
-      dwarf2_build_psymtabs_easy (objfile, section_offsets, mainline);
-    }
-  else
-#endif
-    /* only test this case for now */
-    {		
-      /* In this case we have to work a bit harder */
-      dwarf2_build_psymtabs_hard (objfile, section_offsets, mainline);
-    }
-}
-
-#if 0
-/* Build the partial symbol table from the information in the
-   .debug_pubnames and .debug_aranges sections.  */
-
-static void
-dwarf2_build_psymtabs_easy (objfile, section_offsets, mainline)
-     struct objfile *objfile;
-     struct section_offsets *section_offsets;
-     int mainline;
-{
-  bfd *abfd = objfile->obfd;
-  char *aranges_buffer, *pubnames_buffer;
-  char *aranges_ptr, *pubnames_ptr;
-  unsigned int entry_length, version, info_offset, info_size;
-
-  pubnames_buffer = dwarf2_read_section (objfile,
-					 dwarf_pubnames_offset,
-					 dwarf_pubnames_size);
-  pubnames_ptr = pubnames_buffer;
-  while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size)
-    {
-      entry_length = read_4_bytes (abfd, pubnames_ptr);
-      pubnames_ptr += 4;
-      version = read_1_byte (abfd, pubnames_ptr);
-      pubnames_ptr += 1;
-      info_offset = read_4_bytes (abfd, pubnames_ptr);
-      pubnames_ptr += 4;
-      info_size = read_4_bytes (abfd, pubnames_ptr);
-      pubnames_ptr += 4;
-    }
-
-  aranges_buffer = dwarf2_read_section (objfile,
-					dwarf_aranges_offset,
-					dwarf_aranges_size);
-
-}
-#endif
-
-/* Build the partial symbol table by doing a quick pass through the
-   .debug_info and .debug_abbrev sections.  */
-
-static void
-dwarf2_build_psymtabs_hard (objfile, section_offsets, mainline)
-     struct objfile *objfile;
-     struct section_offsets *section_offsets;
-     int mainline;
-{
-  /* Instead of reading this into a big buffer, we should probably use
-     mmap()  on architectures that support it. (FIXME) */
-  bfd *abfd = objfile->obfd;
-  char *info_ptr, *abbrev_ptr;
-  char *beg_of_comp_unit;
-  struct comp_unit_head cu_header;
-  struct partial_die_info comp_unit_die;
-  struct partial_symtab *pst;
-  struct cleanup *back_to;
-  int comp_unit_has_pc_info;
-  CORE_ADDR lowpc, highpc;
-
-  /* Number of bytes of any addresses that are signficant */
-  address_significant_size = get_elf_backend_data (abfd)->s->arch_size / 8;
-
-  info_ptr = dwarf_info_buffer;
-  abbrev_ptr = dwarf_abbrev_buffer;
-
-  obstack_init (&dwarf2_tmp_obstack);
-  back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
-
-  while ((unsigned int) (info_ptr - dwarf_info_buffer)
-	  + ((info_ptr - dwarf_info_buffer) % 4) < dwarf_info_size)
-    {
-      beg_of_comp_unit = info_ptr;
-      cu_header.length = read_4_bytes (abfd, info_ptr);
-      info_ptr += 4;
-      cu_header.version = read_2_bytes (abfd, info_ptr);
-      info_ptr += 2;
-      cu_header.abbrev_offset = read_4_bytes (abfd, info_ptr);
-      info_ptr += 4;
-      cu_header.addr_size = read_1_byte (abfd, info_ptr);
-      info_ptr += 1;
-      address_size = cu_header.addr_size;
-
-      if (cu_header.version != 2)
-	{
-	  error ("Dwarf Error: wrong version in compilation unit header.");
-	  return;
-	}
-      if (cu_header.abbrev_offset >= dwarf_abbrev_size)
-	{
-	  error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).",
-		 (long) cu_header.abbrev_offset,
-		 (long) (beg_of_comp_unit - dwarf_info_buffer));
-	  return;
-	}
-      if (beg_of_comp_unit + cu_header.length + 4
-	  > dwarf_info_buffer + dwarf_info_size)
-	{
-	  error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).",
-		 (long) cu_header.length,
-		 (long) (beg_of_comp_unit - dwarf_info_buffer));
-	  return;
-	}
-      if (address_size < address_significant_size)
-	{
-	  error ("Dwarf Error: bad address size (%ld) in compilation unit header (offset 0x%lx + 11).",
-		 (long) cu_header.addr_size,
-		 (long) (beg_of_comp_unit - dwarf_info_buffer));
-	}
-
-      /* Read the abbrevs for this compilation unit into a table */
-      dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset);
-      make_cleanup (dwarf2_empty_abbrev_table, NULL);
-
-      /* Read the compilation unit die */
-      info_ptr = read_partial_die (&comp_unit_die, abfd,
-				   info_ptr, &comp_unit_has_pc_info);
-
-      /* Set the language we're debugging */
-      set_cu_language (comp_unit_die.language);
-
-      /* Allocate a new partial symbol table structure */
-      pst = start_psymtab_common (objfile, section_offsets,
-			          comp_unit_die.name ? comp_unit_die.name : "",
-				  comp_unit_die.lowpc,
-				  objfile->global_psymbols.next,
-				  objfile->static_psymbols.next);
-
-      pst->read_symtab_private = (char *)
-	obstack_alloc (&objfile->psymbol_obstack, sizeof (struct dwarf2_pinfo));
-      cu_header_offset = beg_of_comp_unit - dwarf_info_buffer;
-      DWARF_INFO_BUFFER(pst) = dwarf_info_buffer;
-      DWARF_INFO_OFFSET(pst) = beg_of_comp_unit - dwarf_info_buffer;
-      DWARF_ABBREV_BUFFER(pst) = dwarf_abbrev_buffer;
-      DWARF_ABBREV_SIZE(pst) = dwarf_abbrev_size;
-      DWARF_LINE_BUFFER(pst) = dwarf_line_buffer;
-      baseaddr = ANOFFSET (section_offsets, 0);
-
-      /* Store the function that reads in the rest of the symbol table */
-      pst->read_symtab = dwarf2_psymtab_to_symtab;
-
-      /* Check if comp unit has_children.
-         If so, read the rest of the partial symbols from this comp unit.
-         If not, there's no more debug_info for this comp unit. */
-      if (comp_unit_die.has_children)
-	{
-	  info_ptr = scan_partial_symbols (info_ptr, objfile, &lowpc, &highpc);
-
-	  /* If the compilation unit didn't have an explicit address range,
-	     then use the information extracted from its child dies.  */
-	  if (!comp_unit_has_pc_info)
-	    {
-	      comp_unit_die.lowpc  = lowpc;
-	      comp_unit_die.highpc = highpc;
-	    }
-	}
-      pst->textlow  = comp_unit_die.lowpc + baseaddr;
-      pst->texthigh = comp_unit_die.highpc + baseaddr;
-
-      pst->n_global_syms = objfile->global_psymbols.next -
-	(objfile->global_psymbols.list + pst->globals_offset);
-      pst->n_static_syms = objfile->static_psymbols.next -
-	(objfile->static_psymbols.list + pst->statics_offset);
-      sort_pst_symbols (pst);
-
-      /* If there is already a psymtab or symtab for a file of this
-         name, remove it. (If there is a symtab, more drastic things
-         also happen.) This happens in VxWorks.  */
-      free_named_symtabs (pst->filename);
-
-      info_ptr = beg_of_comp_unit + cu_header.length + 4;
-    }
-  do_cleanups (back_to);
-}
-
-/* Read in all interesting dies to the end of the compilation unit.  */
-
-static char *
-scan_partial_symbols (info_ptr, objfile, lowpc, highpc)
-     char *info_ptr;
-     struct objfile *objfile;
-     CORE_ADDR *lowpc;
-     CORE_ADDR *highpc;
-{
-  bfd *abfd = objfile->obfd;
-  struct partial_die_info pdi;
-
-  /* This function is called after we've read in the comp_unit_die in
-     order to read its children.  We start the nesting level at 1 since
-     we have pushed 1 level down in order to read the comp unit's children.
-     The comp unit itself is at level 0, so we stop reading when we pop
-     back to that level. */
-
-  int nesting_level = 1;
-  int has_pc_info;
-  
-  *lowpc  = ((CORE_ADDR) -1);
-  *highpc = ((CORE_ADDR) 0);
-
-  while (nesting_level)
-    {
-      info_ptr = read_partial_die (&pdi, abfd, info_ptr, &has_pc_info);
-
-      if (pdi.name)
-	{
-	  switch (pdi.tag)
-	    {
-	    case DW_TAG_subprogram:
-	      if (has_pc_info)
-		{
-		  if (pdi.lowpc < *lowpc)
-		    {
-		      *lowpc = pdi.lowpc;
-		    }
-		  if (pdi.highpc > *highpc)
-		    {
-		      *highpc = pdi.highpc;
-		    }
-		  if ((pdi.is_external || nesting_level == 1)
-		      && !pdi.is_declaration)
-		    {
-		      add_partial_symbol (&pdi, objfile);
-		    }
-		}
-	      break;
-	    case DW_TAG_variable:
-	    case DW_TAG_typedef:
-	    case DW_TAG_class_type:
-	    case DW_TAG_structure_type:
-	    case DW_TAG_union_type:
-	    case DW_TAG_enumeration_type:
-	      if ((pdi.is_external || nesting_level == 1)
-		  && !pdi.is_declaration)
-		{
-		  add_partial_symbol (&pdi, objfile);
-		}
-	      break;
-	    case DW_TAG_enumerator:
-	      /* File scope enumerators are added to the partial symbol
-		 table.  */
-	      if (nesting_level == 2)
-		add_partial_symbol (&pdi, objfile);
-	      break;
-	    case DW_TAG_base_type:
-	      /* File scope base type definitions are added to the partial
-		 symbol table.  */
-	      if (nesting_level == 1)
-		add_partial_symbol (&pdi, objfile);
-	      break;
-	    default:
-	      break;
-	    }
-	}
-
-      /* If the die has a sibling, skip to the sibling.
-	 Do not skip enumeration types, we want to record their
-	 enumerators.  */
-      if (pdi.sibling && pdi.tag != DW_TAG_enumeration_type)
-	{
-	  info_ptr = pdi.sibling;
-	}
-      else if (pdi.has_children)
-	{
-	  /* Die has children, but the optional DW_AT_sibling attribute
-	     is missing.  */
-	  nesting_level++;
-	}
-
-      if (pdi.tag == 0)
-	{
-	  nesting_level--;
-	}
-    }
-
-  /* If we didn't find a lowpc, set it to highpc to avoid complaints
-     from `maint check'.  */
-  if (*lowpc == ((CORE_ADDR) -1))
-    *lowpc = *highpc;
-  return info_ptr;
-}
-
-static void
-add_partial_symbol (pdi, objfile)
-     struct partial_die_info *pdi;
-     struct objfile *objfile;
-{
-  CORE_ADDR addr = 0;
-
-  switch (pdi->tag)
-    {
-    case DW_TAG_subprogram:
-      if (pdi->is_external)
-	{
-	  /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
-				      mst_text, objfile);*/
-	  add_psymbol_to_list (pdi->name, strlen (pdi->name),
-			       VAR_NAMESPACE, LOC_BLOCK,
-			       &objfile->global_psymbols,
-			       0, pdi->lowpc + baseaddr, cu_language, objfile);
-	}
-      else
-	{
-	  /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
-				      mst_file_text, objfile);*/
-	  add_psymbol_to_list (pdi->name, strlen (pdi->name),
-			       VAR_NAMESPACE, LOC_BLOCK,
-			       &objfile->static_psymbols,
-			       0, pdi->lowpc + baseaddr, cu_language, objfile);
-	}
-      break;
-    case DW_TAG_variable:
-      if (pdi->is_external)
-	{
-	  /* Global Variable.
-	     Don't enter into the minimal symbol tables as there is
-	     a minimal symbol table entry from the ELF symbols already.
-	     Enter into partial symbol table if it has a location
-	     descriptor or a type.
-	     If the location descriptor is missing, new_symbol will create
-	     a LOC_UNRESOLVED symbol, the address of the variable will then
-	     be determined from the minimal symbol table whenever the variable
-	     is referenced.
-	     The address for the partial symbol table entry is not
-	     used by GDB, but it comes in handy for debugging partial symbol
-	     table building.  */
-
-	  if (pdi->locdesc)
-	    addr = decode_locdesc (pdi->locdesc, objfile);
-	  if (pdi->locdesc || pdi->has_type)
-	    add_psymbol_to_list (pdi->name, strlen (pdi->name),
-				 VAR_NAMESPACE, LOC_STATIC,
-				 &objfile->global_psymbols,
-				 0, addr + baseaddr, cu_language, objfile);
-	}
-      else
-	{
-	  /* Static Variable. Skip symbols without location descriptors.  */
-	  if (pdi->locdesc == NULL)
-	    return;
-	  addr = decode_locdesc (pdi->locdesc, objfile);
-	  /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
-				      mst_file_data, objfile);*/
-	  add_psymbol_to_list (pdi->name, strlen (pdi->name),
-			       VAR_NAMESPACE, LOC_STATIC,
-			       &objfile->static_psymbols,
-			       0, addr + baseaddr, cu_language, objfile);
-	}
-      break;
-    case DW_TAG_typedef:
-    case DW_TAG_base_type:
-      add_psymbol_to_list (pdi->name, strlen (pdi->name),
-			   VAR_NAMESPACE, LOC_TYPEDEF,
-			   &objfile->static_psymbols,
-			   0, (CORE_ADDR) 0, cu_language, objfile);
-      break;
-    case DW_TAG_class_type:
-    case DW_TAG_structure_type:
-    case DW_TAG_union_type:
-    case DW_TAG_enumeration_type:
-      /* Skip aggregate types without children, these are external
-	 references.  */
-      if (pdi->has_children == 0)
-	return;
-      add_psymbol_to_list (pdi->name, strlen (pdi->name),
-			   STRUCT_NAMESPACE, LOC_TYPEDEF,
-			   &objfile->static_psymbols,
-			   0, (CORE_ADDR) 0, cu_language, objfile);
-
-      if (cu_language == language_cplus)
-	{
-	  /* For C++, these implicitly act as typedefs as well. */
-	  add_psymbol_to_list (pdi->name, strlen (pdi->name),
-			       VAR_NAMESPACE, LOC_TYPEDEF,
-			       &objfile->static_psymbols,
-			       0, (CORE_ADDR) 0, cu_language, objfile);
-	}
-      break;
-    case DW_TAG_enumerator:
-      add_psymbol_to_list (pdi->name, strlen (pdi->name),
-			   VAR_NAMESPACE, LOC_CONST,
-			   &objfile->static_psymbols,
-			   0, (CORE_ADDR) 0, cu_language, objfile);
-      break;
-    default:
-      break;
-    }
-}
-
-/* Expand this partial symbol table into a full symbol table.  */
-
-static void
-dwarf2_psymtab_to_symtab (pst)
-     struct partial_symtab *pst;
-{
-  /* FIXME: This is barely more than a stub.  */
-  if (pst != NULL)
-    {
-      if (pst->readin)
-	{
-	  warning ("bug: psymtab for %s is already read in.", pst->filename);
-	}
-      else
-	{
-	  if (info_verbose)
-	    {
-	      printf_filtered ("Reading in symbols for %s...", pst->filename);
-	      gdb_flush (gdb_stdout);
-	    }
-
-	  psymtab_to_symtab_1 (pst);
-
-	  /* Finish up the debug error message.  */
-	  if (info_verbose)
-	    printf_filtered ("done.\n");
-	}
-    }
-}
-
-static void
-psymtab_to_symtab_1 (pst)
-     struct partial_symtab *pst;
-{
-  struct objfile *objfile = pst->objfile;
-  bfd *abfd = objfile->obfd;
-  struct comp_unit_head cu_header;
-  struct die_info *dies;
-  unsigned long offset;
-  CORE_ADDR lowpc, highpc;
-  struct die_info *child_die;
-  char *info_ptr;
-  struct symtab *symtab;
-  struct cleanup *back_to;
-
-  /* Set local variables from the partial symbol table info.  */
-  offset = DWARF_INFO_OFFSET(pst);
-  dwarf_info_buffer = DWARF_INFO_BUFFER(pst);
-  dwarf_abbrev_buffer = DWARF_ABBREV_BUFFER(pst);
-  dwarf_abbrev_size = DWARF_ABBREV_SIZE(pst);
-  dwarf_line_buffer = DWARF_LINE_BUFFER(pst);
-  baseaddr = ANOFFSET (pst->section_offsets, 0);
-  cu_header_offset = offset;
-  info_ptr = dwarf_info_buffer + offset;
-
-  obstack_init (&dwarf2_tmp_obstack);
-  back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
-
-  buildsym_init ();
-  make_cleanup ((make_cleanup_func) really_free_pendings, NULL);
-
-  /* read in the comp_unit header  */
-  cu_header.length = read_4_bytes (abfd, info_ptr);
-  info_ptr += 4;
-  cu_header.version = read_2_bytes (abfd, info_ptr);
-  info_ptr += 2;
-  cu_header.abbrev_offset = read_4_bytes (abfd, info_ptr);
-  info_ptr += 4;
-  cu_header.addr_size = read_1_byte (abfd, info_ptr);
-  info_ptr += 1;
-
-  /* Read the abbrevs for this compilation unit  */
-  dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset);
-  make_cleanup (dwarf2_empty_abbrev_table, NULL);
-
-  dies = read_comp_unit (info_ptr, abfd);
-
-  make_cleanup ((make_cleanup_func) free_die_list, dies);
-
-  /* Do line number decoding in read_file_scope () */
-  process_die (dies, objfile);
-
-  if (!dwarf2_get_pc_bounds (dies, &lowpc, &highpc, objfile))
-    {
-      /* Some compilers don't define a DW_AT_high_pc attribute for
-	 the compilation unit.   If the DW_AT_high_pc is missing,
-	 synthesize it, by scanning the DIE's below the compilation unit.  */
-      highpc = 0;
-      if (dies->has_children)
-	{
-	  child_die = dies->next;
-	  while (child_die && child_die->tag)
-	    {
-	      if (child_die->tag == DW_TAG_subprogram)
-		{
-		  CORE_ADDR low, high;
-
-		  if (dwarf2_get_pc_bounds (child_die, &low, &high, objfile))
-		    {
-		      highpc = max (highpc, high);
-		    }
-		}
-	      child_die = sibling_die (child_die);
-	    }
-	}
-    }
-  symtab = end_symtab (highpc + baseaddr, objfile, 0);
-
-  /* Set symtab language to language from DW_AT_language.
-     If the compilation is from a C file generated by language preprocessors,
-     do not set the language if it was already deduced by start_subfile.  */
-  if (symtab != NULL
-      && !(cu_language == language_c && symtab->language != language_c))
-    {
-      symtab->language = cu_language;
-    }
-  pst->symtab = symtab;
-  pst->readin = 1;
-  sort_symtab_syms (pst->symtab);
-
-  do_cleanups (back_to);
-}
-
-/* Process a die and its children.  */
-
-static void
-process_die (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  switch (die->tag)
-    {
-    case DW_TAG_padding:
-      break;
-    case DW_TAG_compile_unit:
-      read_file_scope (die, objfile);
-      break;
-    case DW_TAG_subprogram:
-      read_subroutine_type (die, objfile);
-      read_func_scope (die, objfile);
-      break;
-    case DW_TAG_inlined_subroutine:
-      /* FIXME:  These are ignored for now.
-	 They could be used to set breakpoints on all inlined instances
-	 of a function and make GDB `next' properly over inlined functions.  */
-      break;
-    case DW_TAG_lexical_block:
-      read_lexical_block_scope (die, objfile);
-      break;
-    case DW_TAG_class_type:
-    case DW_TAG_structure_type:
-    case DW_TAG_union_type:
-      read_structure_scope (die, objfile);
-      break;
-    case DW_TAG_enumeration_type:
-      read_enumeration (die, objfile);
-      break;
-    case DW_TAG_subroutine_type:
-      read_subroutine_type (die, objfile);
-      break;
-    case DW_TAG_array_type:
-      read_array_type (die, objfile);
-      break;
-    case DW_TAG_pointer_type:
-      read_tag_pointer_type (die, objfile);
-      break;
-    case DW_TAG_ptr_to_member_type:
-      read_tag_ptr_to_member_type (die, objfile);
-      break;
-    case DW_TAG_reference_type:
-      read_tag_reference_type (die, objfile);
-      break;
-    case DW_TAG_string_type:
-      read_tag_string_type (die, objfile);
-      break;
-    case DW_TAG_base_type:
-      read_base_type (die, objfile);
-      if (dwarf_attr (die, DW_AT_name))
-	{
-	  /* Add a typedef symbol for the base type definition.  */
-	  new_symbol (die, die->type, objfile);
-	}
-      break;
-    case DW_TAG_common_block:
-      read_common_block (die, objfile);
-      break;
-    case DW_TAG_common_inclusion:
-      break;
-    default:
-      new_symbol (die, NULL, objfile);
-      break;
-    }
-}
-
-static void
-read_file_scope (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  unsigned int line_offset = 0;
-  CORE_ADDR lowpc  = ((CORE_ADDR) -1);
-  CORE_ADDR highpc = ((CORE_ADDR) 0);
-  struct attribute *attr;
-  char *name = "<unknown>";
-  char *comp_dir = NULL;
-  struct die_info *child_die;
-  bfd *abfd = objfile->obfd;
-
-  if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile))
-    {
-      if (die->has_children)
-	{
-	  child_die = die->next;
-	  while (child_die && child_die->tag)
-	    {
-	      if (child_die->tag == DW_TAG_subprogram)
-		{
-		  CORE_ADDR low, high;
-
-		  if (dwarf2_get_pc_bounds (child_die, &low, &high, objfile))
-		    {
-		      lowpc = min (lowpc, low);
-		      highpc = max (highpc, high);
-		    }
-		}
-	      child_die = sibling_die (child_die);
-	    }
-	}
-    }
-
-  /* If we didn't find a lowpc, set it to highpc to avoid complaints
-     from finish_block.  */
-  if (lowpc == ((CORE_ADDR) -1))
-    lowpc = highpc;
-  lowpc += baseaddr;
-  highpc += baseaddr;
-
-  attr = dwarf_attr (die, DW_AT_name);
-  if (attr)
-    {
-      name = DW_STRING (attr);
-    }
-  attr = dwarf_attr (die, DW_AT_comp_dir);
-  if (attr)
-    {
-      comp_dir = DW_STRING (attr);
-      if (comp_dir)
-	{
-	  /* Irix 6.2 native cc prepends <machine>.: to the compilation
-	     directory, get rid of it.  */
-	  char *cp = strchr (comp_dir, ':');
-
-	  if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
-	    comp_dir = cp + 1;
-	}
-    }
-
-  if (objfile->ei.entry_point >= lowpc &&
-      objfile->ei.entry_point < highpc)
-    {
-      objfile->ei.entry_file_lowpc = lowpc;
-      objfile->ei.entry_file_highpc = highpc;
-    }
-
-  attr = dwarf_attr (die, DW_AT_language);
-  if (attr)
-    {
-      set_cu_language (DW_UNSND (attr));
-    }
-
-  /* We assume that we're processing GCC output. */
-  processing_gcc_compilation = 2;
-#if 0
-    /* FIXME:Do something here.  */
-    if (dip->at_producer != NULL)
-    {
-      handle_producer (dip->at_producer);
-    }
-#endif
-
-  /* The compilation unit may be in a different language or objfile,
-     zero out all remembered fundamental types.  */
-  memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
-
-  start_symtab (name, comp_dir, lowpc);
-  record_debugformat ("DWARF 2");
-
-  /* Decode line number information if present.  */
-  attr = dwarf_attr (die, DW_AT_stmt_list);
-  if (attr)
-    {
-      line_offset = DW_UNSND (attr);
-      dwarf_decode_lines (line_offset, comp_dir, abfd);
-    }
-
-  /* Process all dies in compilation unit.  */
-  if (die->has_children)
-    {
-      child_die = die->next;
-      while (child_die && child_die->tag)
-	{
-	  process_die (child_die, objfile);
-	  child_die = sibling_die (child_die);
-	}
-    }
-}
-
-static void
-read_func_scope (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  register struct context_stack *new;
-  CORE_ADDR lowpc;
-  CORE_ADDR highpc;
-  struct die_info *child_die;
-  struct attribute *attr;
-  char *name;
-
-  name = dwarf2_linkage_name (die);
-
-  /* Ignore functions with missing or empty names and functions with
-     missing or invalid low and high pc attributes.  */
-  if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile))
-    return;
-
-  lowpc += baseaddr;
-  highpc += baseaddr;
-
-  if (objfile->ei.entry_point >= lowpc &&
-      objfile->ei.entry_point < highpc)
-    {
-      objfile->ei.entry_func_lowpc = lowpc;
-      objfile->ei.entry_func_highpc = highpc;
-    }
-
-  if (STREQ (name, "main"))	/* FIXME: hardwired name */
-    {
-      objfile->ei.main_func_lowpc = lowpc;
-      objfile->ei.main_func_highpc = highpc;
-    }
-
-  /* Decode DW_AT_frame_base location descriptor if present, keep result
-     for DW_OP_fbreg operands in decode_locdesc.  */
-  frame_base_reg = -1;
-  frame_base_offset = 0;
-  attr = dwarf_attr (die, DW_AT_frame_base);
-  if (attr)
-    {
-      CORE_ADDR addr = decode_locdesc (DW_BLOCK (attr), objfile);
-      if (isreg)
-	frame_base_reg = addr;
-      else if (offreg)
-	{
-	  frame_base_reg = basereg;
-	  frame_base_offset = addr;
-	}
-      else
-	complain (&dwarf2_unsupported_at_frame_base, name);
-    }
-
-  new = push_context (0, lowpc);
-  new->name = new_symbol (die, die->type, objfile);
-  list_in_scope = &local_symbols;
-
-  if (die->has_children)
-    {
-      child_die = die->next;
-      while (child_die && child_die->tag)
-	{
-	  process_die (child_die, objfile);
-	  child_die = sibling_die (child_die);
-	}
-    }
-
-  new = pop_context ();
-  /* Make a block for the local symbols within.  */
-  finish_block (new->name, &local_symbols, new->old_blocks,
-		lowpc, highpc, objfile);
-  list_in_scope = &file_symbols;
-}
-
-/* Process all the DIES contained within a lexical block scope.  Start
-   a new scope, process the dies, and then close the scope.  */
-
-static void
-read_lexical_block_scope (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  register struct context_stack *new;
-  CORE_ADDR lowpc, highpc;
-  struct die_info *child_die;
-
-  /* Ignore blocks with missing or invalid low and high pc attributes.  */
-  if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile))
-    return;
-  lowpc += baseaddr;
-  highpc += baseaddr;
-
-  push_context (0, lowpc);
-  if (die->has_children)
-    {
-      child_die = die->next;
-      while (child_die && child_die->tag)
-	{
-	  process_die (child_die, objfile);
-	  child_die = sibling_die (child_die);
-	}
-    }
-  new = pop_context ();
-
-  if (local_symbols != NULL)
-    {
-      finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
-		    highpc, objfile);
-    }
-  local_symbols = new->locals;
-}
-
-/* Get low and high pc attributes from a die.
-   Return 1 if the attributes are present and valid, otherwise, return 0.  */
-
-static int
-dwarf2_get_pc_bounds (die, lowpc, highpc, objfile)
-     struct die_info *die;
-     CORE_ADDR *lowpc;
-     CORE_ADDR *highpc;
-     struct objfile *objfile;
-{
-  struct attribute *attr;
-  CORE_ADDR low;
-  CORE_ADDR high;
-
-  attr = dwarf_attr (die, DW_AT_low_pc);
-  if (attr)
-    low = DW_ADDR (attr);
-  else
-    return 0;
-  attr = dwarf_attr (die, DW_AT_high_pc);
-  if (attr)
-    high = DW_ADDR (attr);
-  else
-    return 0;
-
-  if (high < low)
-    return 0;
-
-  /* When using the GNU linker, .gnu.linkonce. sections are used to
-     eliminate duplicate copies of functions and vtables and such.
-     The linker will arbitrarily choose one and discard the others.
-     The AT_*_pc values for such functions refer to local labels in
-     these sections.  If the section from that file was discarded, the
-     labels are not in the output, so the relocs get a value of 0.
-     If this is a discarded function, mark the pc bounds as invalid,
-     so that GDB will ignore it.  */
-  if (low == 0 && (bfd_get_file_flags (objfile->obfd) & HAS_RELOC) == 0)
-    return 0;
-
-  *lowpc = low;
-  *highpc = high;
-  return 1;
-}
-
-/* Add an aggregate field to the field list.  */
-
-static void
-dwarf2_add_field (fip, die, objfile)
-     struct field_info *fip;
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct nextfield *new_field;
-  struct attribute *attr;
-  struct field *fp;
-  char *fieldname = "";
-
-  /* Allocate a new field list entry and link it in.  */
-  new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
-  make_cleanup (free, new_field);
-  memset (new_field, 0, sizeof (struct nextfield));
-  new_field->next = fip->fields;
-  fip->fields = new_field;
-  fip->nfields++;
-
-  /* Handle accessibility and virtuality of field.
-     The default accessibility for members is public, the default
-     accessibility for inheritance is private.  */
-  if (die->tag != DW_TAG_inheritance)
-    new_field->accessibility = DW_ACCESS_public;
-  else
-    new_field->accessibility = DW_ACCESS_private;
-  new_field->virtuality = DW_VIRTUALITY_none;
-
-  attr = dwarf_attr (die, DW_AT_accessibility);
-  if (attr)
-    new_field->accessibility = DW_UNSND (attr);
-  if (new_field->accessibility != DW_ACCESS_public)
-    fip->non_public_fields = 1;
-  attr = dwarf_attr (die, DW_AT_virtuality);
-  if (attr)
-    new_field->virtuality = DW_UNSND (attr);
-
-  fp = &new_field->field;
-  if (die->tag == DW_TAG_member)
-    {
-      /* Get type of field.  */
-      fp->type = die_type (die, objfile);
-
-      /* Get bit size of field (zero if none).  */
-      attr = dwarf_attr (die, DW_AT_bit_size);
-      if (attr)
-	{
-	  FIELD_BITSIZE (*fp) = DW_UNSND (attr);
-	}
-      else
-	{
-	  FIELD_BITSIZE (*fp) = 0;
-	}
-
-      /* Get bit offset of field.  */
-      attr = dwarf_attr (die, DW_AT_data_member_location);
-      if (attr)
-	{
-	  FIELD_BITPOS (*fp) =
-	    decode_locdesc (DW_BLOCK (attr), objfile) * bits_per_byte;
-	}
-      else
-	FIELD_BITPOS (*fp) = 0;
-      attr = dwarf_attr (die, DW_AT_bit_offset);
-      if (attr)
-	{
-	  if (BITS_BIG_ENDIAN)
-	    {
-	      /* For big endian bits, the DW_AT_bit_offset gives the
-		 additional bit offset from the MSB of the containing
-		 anonymous object to the MSB of the field.  We don't
-		 have to do anything special since we don't need to
-		 know the size of the anonymous object.  */
-	      FIELD_BITPOS (*fp) += DW_UNSND (attr);
-	    }
-	  else
-	    {
-	      /* For little endian bits, compute the bit offset to the
-		 MSB of the anonymous object, subtract off the number of
-		 bits from the MSB of the field to the MSB of the
-		 object, and then subtract off the number of bits of
-		 the field itself.  The result is the bit offset of
-		 the LSB of the field.  */
-	      int anonymous_size;
-	      int bit_offset = DW_UNSND (attr);
-
-	      attr = dwarf_attr (die, DW_AT_byte_size);
-	      if (attr)
-		{
-		  /* The size of the anonymous object containing
-		     the bit field is explicit, so use the
-		     indicated size (in bytes).  */
-		  anonymous_size = DW_UNSND (attr);
-		}
-	      else
-		{
-		  /* The size of the anonymous object containing
-		     the bit field must be inferred from the type
-		     attribute of the data member containing the
-		     bit field.  */
-		  anonymous_size = TYPE_LENGTH (fp->type);
-		}
-	      FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
-		- bit_offset - FIELD_BITSIZE (*fp);
-	    }
-	}
-
-      /* Get name of field.  */
-      attr = dwarf_attr (die, DW_AT_name);
-      if (attr && DW_STRING (attr))
-	fieldname = DW_STRING (attr);
-      fp->name = obsavestring (fieldname, strlen (fieldname),
-			       &objfile->type_obstack);
-
-      /* Change accessibility for artificial fields (e.g. virtual table
-	 pointer or virtual base class pointer) to private.  */
-      if (dwarf_attr (die, DW_AT_artificial))
-	{
-	  new_field->accessibility = DW_ACCESS_private;
-	  fip->non_public_fields = 1;
-	}
-    }
-  else if (die->tag == DW_TAG_variable)
-    {
-      char *physname;
-      char *cp;
-
-      /* C++ static member.
-	 Get physical name, extract field name from physical name.  */
-      physname = dwarf2_linkage_name (die);
-      if (physname == NULL)
-	return;
-
-      cp = physname;
-      while (*cp && !is_cplus_marker (*cp))
-	cp++;
-      if (*cp)
-	fieldname = cp + 1;
-      if (*fieldname == '\0')
-	{
-	  complain (&dwarf2_bad_static_member_name, physname);
-	}
-
-      SET_FIELD_PHYSNAME (*fp, obsavestring (physname, strlen (physname),
-					    &objfile->type_obstack));
-      FIELD_TYPE (*fp) = die_type (die, objfile);
-      FIELD_NAME (*fp) = obsavestring (fieldname, strlen (fieldname),
-			       &objfile->type_obstack);
-    }
-  else if (die->tag == DW_TAG_inheritance)
-    {
-      /* C++ base class field.  */
-      attr = dwarf_attr (die, DW_AT_data_member_location);
-      if (attr)
-	FIELD_BITPOS (*fp) = decode_locdesc (DW_BLOCK (attr), objfile) * bits_per_byte;
-      FIELD_BITSIZE (*fp) = 0;
-      FIELD_TYPE (*fp) = die_type (die, objfile);
-      FIELD_NAME (*fp) = type_name_no_tag (fp->type);
-      fip->nbaseclasses++;
-    }
-}
-
-/* Create the vector of fields, and attach it to the type.  */
-
-static void
-dwarf2_attach_fields_to_type (fip, type, objfile)
-     struct field_info *fip;
-     struct type *type;
-     struct objfile *objfile;
-{
-  int nfields = fip->nfields;
-
-  /* Record the field count, allocate space for the array of fields,
-     and create blank accessibility bitfields if necessary.  */
-  TYPE_NFIELDS (type) = nfields;
-  TYPE_FIELDS (type) = (struct field *)
-    TYPE_ALLOC (type, sizeof (struct field) * nfields);
-  memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
-
-  if (fip->non_public_fields)
-    {
-      ALLOCATE_CPLUS_STRUCT_TYPE (type);
-
-      TYPE_FIELD_PRIVATE_BITS (type) =
-	(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
-      B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
-
-      TYPE_FIELD_PROTECTED_BITS (type) =
-	(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
-      B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
-
-      TYPE_FIELD_IGNORE_BITS (type) =
-	(B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
-      B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
-    }
-
-  /* If the type has baseclasses, allocate and clear a bit vector for
-     TYPE_FIELD_VIRTUAL_BITS.  */
-  if (fip->nbaseclasses)
-    {
-      int num_bytes = B_BYTES (fip->nbaseclasses);
-      char *pointer;
-
-      ALLOCATE_CPLUS_STRUCT_TYPE (type);
-      pointer = (char *) TYPE_ALLOC (type, num_bytes);
-      TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
-      B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
-      TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
-    }
-
-  /* Copy the saved-up fields into the field vector.  Start from the head
-     of the list, adding to the tail of the field array, so that they end
-     up in the same order in the array in which they were added to the list.  */
-  while (nfields-- > 0)
-    {
-      TYPE_FIELD (type, nfields) = fip->fields->field;
-      switch (fip->fields->accessibility)
-	{
-	  case DW_ACCESS_private:
-	    SET_TYPE_FIELD_PRIVATE (type, nfields);
-	    break;
-
-	  case DW_ACCESS_protected:
-	    SET_TYPE_FIELD_PROTECTED (type, nfields);
-	    break;
-
-	  case DW_ACCESS_public:
-	    break;
-
-	  default:
-	    /* Unknown accessibility.  Complain and treat it as public.  */
-	    {
-	      complain (&dwarf2_unsupported_accessibility,
-			fip->fields->accessibility);
-	    }
-	    break;
-	}
-      if (nfields < fip->nbaseclasses)
-	{
-	  switch (fip->fields->virtuality)
-	    {
-	      case DW_VIRTUALITY_virtual:
-	      case DW_VIRTUALITY_pure_virtual:
-		SET_TYPE_FIELD_VIRTUAL (type, nfields);
-		break;
-	    }
-	}
-      fip->fields = fip->fields->next;
-    }
-}
-
-/* Skip to the end of a member function name in a mangled name.  */
-
-static char *
-skip_member_fn_name (physname)
-     char *physname;
-{
-  char *endname = physname;
-
-  /* Skip over leading underscores.  */
-  while (*endname == '_')
-    endname++;
-
-  /* Find two succesive underscores.  */
-  do
-    endname = strchr (endname, '_');
-  while (endname != NULL && *++endname != '_');
-
-  if (endname == NULL)
-    {
-      complain (&dwarf2_bad_member_name_complaint, physname);
-      endname = physname;
-    }
-  else
-    {
-      /* Take care of trailing underscores.  */
-      if (endname[1] != '_')
-        endname--;
-    }
-  return endname;
-}
-
-/* Add a member function to the proper fieldlist.  */
-
-static void
-dwarf2_add_member_fn (fip, die, type, objfile)
-     struct field_info *fip;
-     struct die_info *die;
-     struct type *type;
-     struct objfile *objfile;
-{
-  struct attribute *attr;
-  struct fnfieldlist *flp;
-  int i;
-  struct fn_field *fnp;
-  char *fieldname;
-  char *physname;
-  struct nextfnfield *new_fnfield;
-
-  /* Extract member function name from mangled name.  */
-  physname = dwarf2_linkage_name (die);
-  if (physname == NULL)
-    return;
-  if ((physname[0] == '_' && physname[1] == '_'
-        && strchr ("0123456789Qt", physname[2]))
-      || DESTRUCTOR_PREFIX_P (physname))
-    {
-      /* Constructor and destructor field names are set to the name
-	 of the class, but without template parameter lists.
-	 The name might be missing for anonymous aggregates.  */
-      if (TYPE_TAG_NAME (type))
-	{
-	  char *p = strchr (TYPE_TAG_NAME (type), '<');
-
-	  if (p == NULL)
-	    fieldname = TYPE_TAG_NAME (type);
-	  else
-	    fieldname = obsavestring (TYPE_TAG_NAME (type),
-				      p - TYPE_TAG_NAME (type),
-				      &objfile->type_obstack);
-	}
-      else
-	{
-	  char *anon_name = "";
-	  fieldname = obsavestring (anon_name, strlen (anon_name),
-				    &objfile->type_obstack);
-	}
-    }
-  else
-    {
-      char *endname = skip_member_fn_name (physname);
-
-      /* Ignore member function if we were unable not extract the member
-	 function name.  */
-      if (endname == physname)
-	return;
-      fieldname = obsavestring (physname, endname - physname,
-				&objfile->type_obstack);
-    }
-
-  /* Look up member function name in fieldlist.  */
-  for (i = 0; i < fip->nfnfields; i++)
-    {
-      if (STREQ (fip->fnfieldlists[i].name, fieldname))
-	break;
-    }
-
-  /* Create new list element if necessary.  */
-  if (i < fip->nfnfields)
-    flp = &fip->fnfieldlists[i];
-  else
-    {
-      if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
-	{
-	  fip->fnfieldlists = (struct fnfieldlist *)
-	    xrealloc (fip->fnfieldlists,
-		      (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
-		        * sizeof (struct fnfieldlist));
-	  if (fip->nfnfields == 0)
-	    make_cleanup ((make_cleanup_func) free_current_contents, 
-                          &fip->fnfieldlists);
-	}
-      flp = &fip->fnfieldlists[fip->nfnfields];
-      flp->name = fieldname;
-      flp->length = 0;
-      flp->head = NULL;
-      fip->nfnfields++;
-    }
-
-  /* Create a new member function field and chain it to the field list
-     entry. */
-  new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
-  make_cleanup (free, new_fnfield);
-  memset (new_fnfield, 0, sizeof (struct nextfnfield));
-  new_fnfield->next = flp->head;
-  flp->head = new_fnfield;
-  flp->length++;
-
-  /* Fill in the member function field info.  */
-  fnp = &new_fnfield->fnfield;
-  fnp->physname = obsavestring (physname, strlen (physname),
-				&objfile->type_obstack);
-  fnp->type = alloc_type (objfile);
-  if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
-    {
-      struct type *return_type = TYPE_TARGET_TYPE (die->type);
-      struct type **arg_types;
-      int nparams = TYPE_NFIELDS (die->type);
-      int iparams;
-
-      /* Copy argument types from the subroutine type.  */
-      arg_types = (struct type **)
-	TYPE_ALLOC (fnp->type, (nparams + 1) * sizeof (struct type *));
-      for (iparams = 0; iparams < nparams; iparams++)
-	arg_types[iparams] = TYPE_FIELD_TYPE (die->type, iparams);
-
-      /* Set last entry in argument type vector.  */
-      if (TYPE_FLAGS (die->type) & TYPE_FLAG_VARARGS)
-	arg_types[nparams] = NULL;
-      else
-	arg_types[nparams] = dwarf2_fundamental_type (objfile, FT_VOID);
-
-      smash_to_method_type (fnp->type, type, return_type, arg_types);
-
-      /* Handle static member functions.
-	 Dwarf2 has no clean way to discern C++ static and non-static
-	 member functions. G++ helps GDB by marking the first
-	 parameter for non-static member functions (which is the
-	 this pointer) as artificial. We obtain this information
-	 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL.  */
-      if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
-	fnp->voffset = VOFFSET_STATIC;
-    }
-  else
-    complain (&dwarf2_missing_member_fn_type_complaint, physname);
-
-  /* Get fcontext from DW_AT_containing_type if present.  */
-  if (dwarf_attr (die, DW_AT_containing_type) != NULL)
-    fnp->fcontext = die_containing_type (die, objfile);
-
-  /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
-     and is_volatile is irrelevant, as it is needed by gdb_mangle_name only.  */
-
-  /* Get accessibility.  */
-  attr = dwarf_attr (die, DW_AT_accessibility);
-  if (attr)
-    {
-      switch (DW_UNSND (attr))
-	{
-	  case DW_ACCESS_private:
-	    fnp->is_private = 1;
-	    break;
-	  case DW_ACCESS_protected:
-	    fnp->is_protected = 1;
-	    break;
-	}
-    }
-
-  /* Get index in virtual function table if it is a virtual member function.  */
-  attr = dwarf_attr (die, DW_AT_vtable_elem_location);
-  if (attr)
-    fnp->voffset = decode_locdesc (DW_BLOCK (attr), objfile) + 2;
-}
-
-/* Create the vector of member function fields, and attach it to the type.  */
-
-static void
-dwarf2_attach_fn_fields_to_type (fip, type, objfile)
-     struct field_info *fip;
-     struct type *type;
-     struct objfile *objfile;
-{
-  struct fnfieldlist *flp;
-  int total_length = 0;
-  int i;
-
-  ALLOCATE_CPLUS_STRUCT_TYPE (type);
-  TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
-    TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
-
-  for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
-    {
-      struct nextfnfield *nfp = flp->head;
-      struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
-      int k;
-
-      TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
-      TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
-      fn_flp->fn_fields = (struct fn_field *)
-	TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
-      for (k = flp->length; (k--, nfp); nfp = nfp->next)
-        fn_flp->fn_fields[k] = nfp->fnfield;
-
-      total_length += flp->length;
-    }
-
-  TYPE_NFN_FIELDS (type) = fip->nfnfields;
-  TYPE_NFN_FIELDS_TOTAL (type) = total_length;
-}
-
-/* Called when we find the DIE that starts a structure or union scope
-   (definition) to process all dies that define the members of the
-   structure or union.
-
-   NOTE: we need to call struct_type regardless of whether or not the
-   DIE has an at_name attribute, since it might be an anonymous
-   structure or union.  This gets the type entered into our set of
-   user defined types.
-
-   However, if the structure is incomplete (an opaque struct/union)
-   then suppress creating a symbol table entry for it since gdb only
-   wants to find the one with the complete definition.  Note that if
-   it is complete, we just call new_symbol, which does it's own
-   checking about whether the struct/union is anonymous or not (and
-   suppresses creating a symbol table entry itself).  */
-
-static void
-read_structure_scope (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type;
-  struct attribute *attr;
-
-  type = alloc_type (objfile);
-
-  INIT_CPLUS_SPECIFIC (type);
-  attr = dwarf_attr (die, DW_AT_name);
-  if (attr && DW_STRING (attr))
-    {
-      TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr),
-					   strlen (DW_STRING (attr)),
-					   &objfile->type_obstack);
-    }
-
-  if (die->tag == DW_TAG_structure_type)
-    {
-      TYPE_CODE (type) = TYPE_CODE_STRUCT;
-    }
-  else if (die->tag == DW_TAG_union_type)
-    {
-      TYPE_CODE (type) = TYPE_CODE_UNION;
-    }
-  else
-    {
-      /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
-	 in gdbtypes.h.  */
-      TYPE_CODE (type) = TYPE_CODE_CLASS;
-    }
-
-  attr = dwarf_attr (die, DW_AT_byte_size);
-  if (attr)
-    {
-      TYPE_LENGTH (type) = DW_UNSND (attr);
-    }
-  else
-    {
-      TYPE_LENGTH (type) = 0;
-    }
-
-  /* We need to add the type field to the die immediately so we don't
-     infinitely recurse when dealing with pointers to the structure
-     type within the structure itself. */
-  die->type = type;
-
-  if (die->has_children)
-    {
-      struct field_info fi;
-      struct die_info *child_die;
-      struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
-
-      memset (&fi, 0, sizeof (struct field_info));
-
-      child_die = die->next;
-
-      while (child_die && child_die->tag)
-	{
-	  if (child_die->tag == DW_TAG_member)
-	    {
-	      dwarf2_add_field (&fi, child_die, objfile);
-	    }
-	  else if (child_die->tag == DW_TAG_variable)
-	    {
-	      /* C++ static member.  */
-	      dwarf2_add_field (&fi, child_die, objfile);
-	    }
-	  else if (child_die->tag == DW_TAG_subprogram)
-	    {
-	      /* C++ member function. */
-	      process_die (child_die, objfile);
-	      dwarf2_add_member_fn (&fi, child_die, type, objfile);
-	    }
-	  else if (child_die->tag == DW_TAG_inheritance)
-	    {
-	      /* C++ base class field.  */
-	      dwarf2_add_field (&fi, child_die, objfile);
-	    }
-	  else
-	    {
-	      process_die (child_die, objfile);
-	    }
-	  child_die = sibling_die (child_die);
-	}
-
-      /* Attach fields and member functions to the type.  */
-      if (fi.nfields)
-	dwarf2_attach_fields_to_type (&fi, type, objfile);
-      if (fi.nfnfields)
-	{
-	  dwarf2_attach_fn_fields_to_type (&fi, type, objfile);
-
-          /* Get the type which refers to the base class (possibly this
-	     class itself) which contains the vtable pointer for the current
-	     class from the DW_AT_containing_type attribute.  */
-
-	  if (dwarf_attr (die, DW_AT_containing_type) != NULL)
-	    {
-	      struct type *t = die_containing_type (die, objfile);
-
-	      TYPE_VPTR_BASETYPE (type) = t;
-	      if (type == t)
-		{
-		  static const char vptr_name[] = { '_','v','p','t','r','\0' };
-		  int i;
-
-		  /* Our own class provides vtbl ptr.  */
-		  for (i = TYPE_NFIELDS (t) - 1;
-		       i >= TYPE_N_BASECLASSES (t);
-		       --i)
-		    {
-		      char *fieldname = TYPE_FIELD_NAME (t, i);
-
-		      if (STREQN (fieldname, vptr_name, strlen (vptr_name) - 1)
-			  && is_cplus_marker (fieldname[strlen (vptr_name)]))
-			{
-			  TYPE_VPTR_FIELDNO (type) = i;
-			  break;
-			}
-		    }
-
-		  /* Complain if virtual function table field not found.  */
-		  if (i < TYPE_N_BASECLASSES (t))
-		    complain (&dwarf2_vtbl_not_found_complaint,
-			      TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "");
-		}
-	      else
-		{
-		  TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
-		}
-	    }
-	}
-
-      new_symbol (die, type, objfile);
-
-      do_cleanups (back_to);
-    }
-  else
-    {
-      /* No children, must be stub. */
-      TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
-    }
-
-  die->type = type;
-}
-
-/* Given a pointer to a die which begins an enumeration, process all
-   the dies that define the members of the enumeration.
-
-   This will be much nicer in draft 6 of the DWARF spec when our
-   members will be dies instead squished into the DW_AT_element_list
-   attribute.
-
-   NOTE: We reverse the order of the element list.  */
-
-static void
-read_enumeration (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct die_info *child_die;
-  struct type *type;
-  struct field *fields;
-  struct attribute *attr;
-  struct symbol *sym;
-  int num_fields;
-  int unsigned_enum = 1;
-
-  type = alloc_type (objfile);
-
-  TYPE_CODE (type) = TYPE_CODE_ENUM;
-  attr = dwarf_attr (die, DW_AT_name);
-  if (attr && DW_STRING (attr))
-    {
-      TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr),
-					   strlen (DW_STRING (attr)),
-					   &objfile->type_obstack);
-    }
-
-  attr = dwarf_attr (die, DW_AT_byte_size);
-  if (attr)
-    {
-      TYPE_LENGTH (type) = DW_UNSND (attr);
-    }
-  else
-    {
-      TYPE_LENGTH (type) = 0;
-    }
-
-  num_fields = 0;
-  fields = NULL;
-  if (die->has_children)
-    {
-      child_die = die->next;
-      while (child_die && child_die->tag)
-	{
-	  if (child_die->tag != DW_TAG_enumerator)
-	    {
-	      process_die (child_die, objfile);
-	    }
-	  else
-	    {
-	      attr = dwarf_attr (child_die, DW_AT_name);
-	      if (attr)
-		{
-		  sym = new_symbol (child_die, type, objfile);
-		  if (SYMBOL_VALUE (sym) < 0)
-		    unsigned_enum = 0;
-
-		  if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
-		    {
-		      fields = (struct field *)
-			xrealloc (fields,
-				  (num_fields + DW_FIELD_ALLOC_CHUNK)
-				    * sizeof (struct field));
-		    }
-
-		  FIELD_NAME (fields[num_fields]) = SYMBOL_NAME (sym);
-		  FIELD_TYPE (fields[num_fields]) = NULL;
-		  FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
-		  FIELD_BITSIZE (fields[num_fields]) = 0;
-
-		  num_fields++;
-		}
-	    }
-
-	  child_die = sibling_die (child_die);
-	}
-
-      if (num_fields)
-	{
-	  TYPE_NFIELDS (type) = num_fields;
-	  TYPE_FIELDS (type) = (struct field *)
-	    TYPE_ALLOC (type, sizeof (struct field) * num_fields);
-	  memcpy (TYPE_FIELDS (type), fields,
-		  sizeof (struct field) * num_fields);
-	  free (fields);
-	}
-      if (unsigned_enum)
-	TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
-    }
-  die->type = type;
-  new_symbol (die, type, objfile);
-}
-
-/* Extract all information from a DW_TAG_array_type DIE and put it in
-   the DIE's type field.  For now, this only handles one dimensional
-   arrays.  */
-
-static void
-read_array_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct die_info *child_die;
-  struct type *type = NULL;
-  struct type *element_type, *range_type, *index_type;
-  struct type **range_types = NULL;
-  struct attribute *attr;
-  int ndim = 0;
-  struct cleanup *back_to;
-
-  /* Return if we've already decoded this type. */
-  if (die->type)
-    {
-      return;
-    }
-
-  element_type = die_type (die, objfile);
-
-  /* Irix 6.2 native cc creates array types without children for
-     arrays with unspecified length.  */
-  if (die->has_children == 0)
-    {
-      index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
-      range_type = create_range_type (NULL, index_type, 0, -1);
-      die->type = create_array_type (NULL, element_type, range_type);
-      return;
-    }
-
-  back_to = make_cleanup (null_cleanup, NULL);
-  child_die = die->next;
-  while (child_die && child_die->tag)
-    {
-      if (child_die->tag == DW_TAG_subrange_type)
-	{
-	  unsigned int low, high;
-
-	  /* Default bounds to an array with unspecified length.  */
-	  low = 0;
-	  high = -1;
-	  if (cu_language == language_fortran)
-	    {
-	      /* FORTRAN implies a lower bound of 1, if not given.  */
-	      low = 1;
-	    }
-
-	  index_type = die_type (child_die, objfile);
-	  attr = dwarf_attr (child_die, DW_AT_lower_bound);
-	  if (attr)
-	    {
-	      if (attr->form == DW_FORM_sdata)
-		{
-		  low = DW_SND (attr);
-		}
-	      else if (attr->form == DW_FORM_udata
-	               || attr->form == DW_FORM_data1
-	               || attr->form == DW_FORM_data2
-	               || attr->form == DW_FORM_data4)
-		{
-		  low = DW_UNSND (attr);
-		}
-	      else
-		{
-		  complain (&dwarf2_non_const_array_bound_ignored,
-			    dwarf_form_name (attr->form));
-#ifdef FORTRAN_HACK
-		  die->type = lookup_pointer_type (element_type);
-		  return;
-#else
-		  low = 0;
-#endif
-		}
-	    }
-	  attr = dwarf_attr (child_die, DW_AT_upper_bound);
-	  if (attr)
-	    {
-	      if (attr->form == DW_FORM_sdata)
-		{
-		  high = DW_SND (attr);
-		}
-	      else if (attr->form == DW_FORM_udata
-	               || attr->form == DW_FORM_data1
-	               || attr->form == DW_FORM_data2
-	               || attr->form == DW_FORM_data4)
-		{
-		  high = DW_UNSND (attr);
-		}
-	      else if (attr->form == DW_FORM_block1)
-		{
-		  /* GCC encodes arrays with unspecified or dynamic length
-		     with a DW_FORM_block1 attribute.
-		     FIXME: GDB does not yet know how to handle dynamic
-		     arrays properly, treat them as arrays with unspecified
-		     length for now.  */
-		  high = -1;
-		}
-	      else
-		{
-		  complain (&dwarf2_non_const_array_bound_ignored,
-			    dwarf_form_name (attr->form));
-#ifdef FORTRAN_HACK
-		  die->type = lookup_pointer_type (element_type);
-		  return;
-#else
-		  high = 1;
-#endif
-		}
-	    }
-
-	  /* Create a range type and save it for array type creation.  */
-	  if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
-	    {
-	      range_types = (struct type **)
-		xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
-				         * sizeof (struct type *));
-	      if (ndim == 0)
-		make_cleanup ((make_cleanup_func) free_current_contents, 
-                              &range_types);
-	    }
-	  range_types[ndim++] = create_range_type (NULL, index_type, low, high);
-	}
-      child_die = sibling_die (child_die);
-    }
-
-  /* Dwarf2 dimensions are output from left to right, create the
-     necessary array types in backwards order.  */
-  type = element_type;
-  while (ndim-- > 0)
-    type = create_array_type (NULL, type, range_types[ndim]);
-
-  do_cleanups (back_to);
-
-  /* Install the type in the die. */
-  die->type = type;
-}
-
-/* First cut: install each common block member as a global variable.  */
-
-static void
-read_common_block (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct die_info *child_die;
-  struct attribute *attr;
-  struct symbol *sym;
-  CORE_ADDR base = (CORE_ADDR) 0;
-
-  attr = dwarf_attr (die, DW_AT_location);
-  if (attr)
-    {
-      base = decode_locdesc (DW_BLOCK (attr), objfile);
-    }
-  if (die->has_children)
-    {
-      child_die = die->next;
-      while (child_die && child_die->tag)
-	{
-	  sym = new_symbol (child_die, NULL, objfile);
-	  attr = dwarf_attr (child_die, DW_AT_data_member_location);
-	  if (attr)
-	    {
-	      SYMBOL_VALUE_ADDRESS (sym) =
-		base + decode_locdesc (DW_BLOCK (attr), objfile);
-	      add_symbol_to_list (sym, &global_symbols);
-	    }
-	  child_die = sibling_die (child_die);
-	}
-    }
-}
-
-/* Extract all information from a DW_TAG_pointer_type DIE and add to
-   the user defined type vector.  */
-
-static void
-read_tag_pointer_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type;
-  struct attribute *attr;
-
-  if (die->type)
-    {
-      return;
-    }
-
-  type = lookup_pointer_type (die_type (die, objfile));
-  attr = dwarf_attr (die, DW_AT_byte_size);
-  if (attr)
-    {
-      TYPE_LENGTH (type) = DW_UNSND (attr);
-    }
-  else
-    {
-      TYPE_LENGTH (type) = address_size;
-    }
-  die->type = type;
-}
-
-/* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
-   the user defined type vector.  */
-
-static void
-read_tag_ptr_to_member_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type;
-  struct type *to_type;
-  struct type *domain;
-
-  if (die->type)
-    {
-      return;
-    }
-
-  type = alloc_type (objfile);
-  to_type = die_type (die, objfile);
-  domain = die_containing_type (die, objfile);
-  smash_to_member_type (type, domain, to_type);
-
-  die->type = type;
-}
-
-/* Extract all information from a DW_TAG_reference_type DIE and add to
-   the user defined type vector.  */
-
-static void
-read_tag_reference_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type;
-  struct attribute *attr;
-
-  if (die->type)
-    {
-      return;
-    }
-
-  type = lookup_reference_type (die_type (die, objfile));
-  attr = dwarf_attr (die, DW_AT_byte_size);
-  if (attr)
-    {
-      TYPE_LENGTH (type) = DW_UNSND (attr);
-    }
-  else
-    {
-      TYPE_LENGTH (type) = address_size;
-    }
-  die->type = type;
-}
-
-static void
-read_tag_const_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  if (die->type)
-    {
-      return;
-    }
-
-  complain (&dwarf2_const_ignored);
-  die->type = die_type (die, objfile);
-}
-
-static void
-read_tag_volatile_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  if (die->type)
-    {
-      return;
-    }
-
-  complain (&dwarf2_volatile_ignored);
-  die->type = die_type (die, objfile);
-}
-
-/* Extract all information from a DW_TAG_string_type DIE and add to
-   the user defined type vector.  It isn't really a user defined type,
-   but it behaves like one, with other DIE's using an AT_user_def_type
-   attribute to reference it.  */
-
-static void
-read_tag_string_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type, *range_type, *index_type, *char_type;
-  struct attribute *attr;
-  unsigned int length;
-
-  if (die->type)
-    {
-      return;
-    }
-
-  attr = dwarf_attr (die, DW_AT_string_length);
-  if (attr)
-    {
-      length = DW_UNSND (attr);
-    }
-  else
-    {
-      length = 1;
-    }
-  index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
-  range_type = create_range_type (NULL, index_type, 1, length);
-  char_type = dwarf2_fundamental_type (objfile, FT_CHAR);
-  type = create_string_type (char_type, range_type);
-  die->type = type;
-}
-
-/* Handle DIES due to C code like:
-
-   struct foo
-     {
-       int (*funcp)(int a, long l);
-       int b;
-     };
-
-   ('funcp' generates a DW_TAG_subroutine_type DIE)
-*/
-
-static void
-read_subroutine_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type;		/* Type that this function returns */
-  struct type *ftype;		/* Function that returns above type */
-  struct attribute *attr;
-
-  /* Decode the type that this subroutine returns */
-  if (die->type)
-    {
-      return;
-    }
-  type = die_type (die, objfile);
-  ftype = lookup_function_type (type);
-
-  /* All functions in C++ have prototypes.  */
-  attr = dwarf_attr (die, DW_AT_prototyped);
-  if ((attr && (DW_UNSND (attr) != 0))
-      || cu_language == language_cplus)
-    TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
-
-  if (die->has_children)
-    {
-      struct die_info *child_die;
-      int nparams = 0;
-      int iparams = 0;
-
-      /* Count the number of parameters.
-         FIXME: GDB currently ignores vararg functions, but knows about
-         vararg member functions.  */
-      child_die = die->next;
-      while (child_die && child_die->tag)
-	{
-	  if (child_die->tag == DW_TAG_formal_parameter)
-	    nparams++;
-	  else if (child_die->tag == DW_TAG_unspecified_parameters)
-	    TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
-	  child_die = sibling_die (child_die);
-	}
-
-      /* Allocate storage for parameters and fill them in.  */
-      TYPE_NFIELDS (ftype) = nparams;
-      TYPE_FIELDS (ftype) = (struct field *)
-	TYPE_ALLOC (ftype, nparams * sizeof (struct field));
-
-      child_die = die->next;
-      while (child_die && child_die->tag)
-	{
-	  if (child_die->tag == DW_TAG_formal_parameter)
-	    {
-	      /* Dwarf2 has no clean way to discern C++ static and non-static
-		 member functions. G++ helps GDB by marking the first
-		 parameter for non-static member functions (which is the
-		 this pointer) as artificial. We pass this information
-		 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.  */
-	      attr = dwarf_attr (child_die, DW_AT_artificial);
-	      if (attr)
-		TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
-	      else
-		TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
-	      TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, objfile);
-	      iparams++;
-	    }
-	  child_die = sibling_die (child_die);
-	}
-    }
-
-  die->type = ftype;
-}
-
-static void
-read_typedef (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type;
-
-  if (!die->type)
-    {
-      struct attribute *attr;
-      struct type *xtype;
-
-      xtype = die_type (die, objfile);
-
-      type = alloc_type (objfile);
-      TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
-      TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB;
-      TYPE_TARGET_TYPE (type) = xtype;
-      attr = dwarf_attr (die, DW_AT_name);
-      if (attr && DW_STRING (attr))
-	TYPE_NAME (type) = obsavestring (DW_STRING (attr),
-					 strlen (DW_STRING (attr)),
-					 &objfile->type_obstack);
-
-      die->type = type;
-    }
-}
-
-/* Find a representation of a given base type and install
-   it in the TYPE field of the die.  */
-
-static void
-read_base_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type;
-  struct attribute *attr;
-  int encoding = 0, size = 0;
-
-  /* If we've already decoded this die, this is a no-op. */
-  if (die->type)
-    {
-      return;
-    }
-
-  attr = dwarf_attr (die, DW_AT_encoding);
-  if (attr)
-    {
-      encoding = DW_UNSND (attr);
-    }
-  attr = dwarf_attr (die, DW_AT_byte_size);
-  if (attr)
-    {
-      size = DW_UNSND (attr);
-    }
-  attr = dwarf_attr (die, DW_AT_name);
-  if (attr && DW_STRING (attr))
-    {
-      enum type_code code = TYPE_CODE_INT;
-      int is_unsigned = 0;
-
-      switch (encoding)
-	{
-	case DW_ATE_address:
-	  /* Turn DW_ATE_address into a void * pointer.  */
-	  code = TYPE_CODE_PTR;
-	  is_unsigned = 1;
-	  break;
-	case DW_ATE_boolean:
-	  code = TYPE_CODE_BOOL;
-	  is_unsigned = 1;
-	  break;
-	case DW_ATE_complex_float:
-	  code = TYPE_CODE_COMPLEX;
-	  break;
-	case DW_ATE_float:
-	  code = TYPE_CODE_FLT;
-	  break;
-	case DW_ATE_signed:
-	case DW_ATE_signed_char:
-	  break;
-	case DW_ATE_unsigned:
-	case DW_ATE_unsigned_char:
-	  is_unsigned = 1;
-	  break;
-	default:
-	  complain (&dwarf2_unsupported_at_encoding,
-		    dwarf_type_encoding_name (encoding));
-	  break;
-	}
-      type = init_type (code, size, is_unsigned, DW_STRING (attr), objfile);
-      if (encoding == DW_ATE_address)
-	TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID);
-    }
-  else
-    {
-      type = dwarf_base_type (encoding, size, objfile);
-    }
-  die->type = type;
-}
-
-/* Read a whole compilation unit into a linked list of dies.  */
-
-struct die_info *
-read_comp_unit (info_ptr, abfd)
-    char *info_ptr;
-    bfd *abfd;
-{
-  struct die_info *first_die, *last_die, *die;
-  char *cur_ptr;
-  int nesting_level;
-
-  /* Reset die reference table, we are building a new one now. */
-  dwarf2_empty_die_ref_table ();
-
-  cur_ptr = info_ptr;
-  nesting_level = 0;
-  first_die = last_die = NULL;
-  do
-    {
-      cur_ptr = read_full_die (&die, abfd, cur_ptr);
-      if (die->has_children)
-	{
-	  nesting_level++;
-	}
-      if (die->tag == 0)
-	{
-	  nesting_level--;
-	}
-
-      die->next = NULL;
-
-      /* Enter die in reference hash table */
-      store_in_ref_table (die->offset, die);
-
-      if (!first_die)
-	{
-	  first_die = last_die = die;
-	}
-      else
-	{
-	  last_die->next = die;
-	  last_die = die;
-	}
-    }
-  while (nesting_level > 0);
-  return first_die;
-}
-
-/* Free a linked list of dies.  */
-
-static void
-free_die_list (dies)
-     struct die_info *dies;
-{
-  struct die_info *die, *next;
-
-  die = dies;
-  while (die)
-    {
-      next = die->next;
-      free (die->attrs);
-      free (die);
-      die = next;
-    }
-}
-
-/* Read the contents of the section at OFFSET and of size SIZE from the
-   object file specified by OBJFILE into the psymbol_obstack and return it.  */
-
-static char *
-dwarf2_read_section (objfile, offset, size)
-     struct objfile *objfile;
-     file_ptr offset;
-     unsigned int size;
-{
-  bfd *abfd = objfile->obfd;
-  char *buf;
-
-  if (size == 0)
-    return NULL;
-
-  buf = (char *) obstack_alloc (&objfile->psymbol_obstack, size);
-  if ((bfd_seek (abfd, offset, SEEK_SET) != 0) ||
-      (bfd_read (buf, size, 1, abfd) != size))
-    {
-      buf = NULL;
-      error ("Dwarf Error: Can't read DWARF data from '%s'",
-        bfd_get_filename (abfd));
-    }
-  return buf;
-}
-
-/* In DWARF version 2, the description of the debugging information is
-   stored in a separate .debug_abbrev section.  Before we read any
-   dies from a section we read in all abbreviations and install them
-   in a hash table.  */
-
-static void
-dwarf2_read_abbrevs (abfd, offset)
-     bfd * abfd;
-     unsigned int offset;
-{
-  char *abbrev_ptr;
-  struct abbrev_info *cur_abbrev;
-  unsigned int abbrev_number, bytes_read, abbrev_name;
-  unsigned int abbrev_form, hash_number;
-
-  /* empty the table */
-  dwarf2_empty_abbrev_table (NULL);
-
-  abbrev_ptr = dwarf_abbrev_buffer + offset;
-  abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
-  abbrev_ptr += bytes_read;
-
-  /* loop until we reach an abbrev number of 0 */
-  while (abbrev_number)
-    {
-      cur_abbrev = dwarf_alloc_abbrev ();
-
-      /* read in abbrev header */
-      cur_abbrev->number = abbrev_number;
-      cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
-      abbrev_ptr += bytes_read;
-      cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
-      abbrev_ptr += 1;
-
-      /* now read in declarations */
-      abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
-      abbrev_ptr += bytes_read;
-      abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
-      abbrev_ptr += bytes_read;
-      while (abbrev_name)
-	{
-	  if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
-	    {
-	      cur_abbrev->attrs = (struct attr_abbrev *)
-		xrealloc (cur_abbrev->attrs,
-			  (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
-			    * sizeof (struct attr_abbrev));
-	    }
-	  cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
-	  cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
-	  abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
-	  abbrev_ptr += bytes_read;
-	  abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
-	  abbrev_ptr += bytes_read;
-	}
-
-      hash_number = abbrev_number % ABBREV_HASH_SIZE;
-      cur_abbrev->next = dwarf2_abbrevs[hash_number];
-      dwarf2_abbrevs[hash_number] = cur_abbrev;
-
-      /* Get next abbreviation.
-         Under Irix6 the abbreviations for a compilation unit are not
-	 always properly terminated with an abbrev number of 0.
-	 Exit loop if we encounter an abbreviation which we have
-	 already read (which means we are about to read the abbreviations
-	 for the next compile unit) or if the end of the abbreviation
-	 table is reached.  */
-      if ((unsigned int) (abbrev_ptr - dwarf_abbrev_buffer)
-	    >= dwarf_abbrev_size)
-	break;
-      abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
-      abbrev_ptr += bytes_read;
-      if (dwarf2_lookup_abbrev (abbrev_number) != NULL)
-	break;
-    }
-}
-
-/* Empty the abbrev table for a new compilation unit.  */
-
-/* ARGSUSED */
-static void
-dwarf2_empty_abbrev_table (ignore)
-     PTR ignore;
-{
-  int i;
-  struct abbrev_info *abbrev, *next;
-
-  for (i = 0; i < ABBREV_HASH_SIZE; ++i)
-    {
-      next = NULL;
-      abbrev = dwarf2_abbrevs[i];
-      while (abbrev)
-	{
-	  next = abbrev->next;
-	  free (abbrev->attrs);
-	  free (abbrev);
-	  abbrev = next;
-	}
-      dwarf2_abbrevs[i] = NULL;
-    }
-}
-
-/* Lookup an abbrev_info structure in the abbrev hash table.  */
-
-static struct abbrev_info *
-dwarf2_lookup_abbrev (number)
-     unsigned int number;
-{
-  unsigned int hash_number;
-  struct abbrev_info *abbrev;
-
-  hash_number = number % ABBREV_HASH_SIZE;
-  abbrev = dwarf2_abbrevs[hash_number];
-
-  while (abbrev)
-    {
-      if (abbrev->number == number)
-	return abbrev;
-      else
-	abbrev = abbrev->next;
-    }
-  return NULL;
-}
-
-/* Read a minimal amount of information into the minimal die structure.  */
-
-static char *
-read_partial_die (part_die, abfd, info_ptr, has_pc_info)
-     struct partial_die_info *part_die;
-     bfd * abfd;
-     char *info_ptr;
-     int *has_pc_info;
-{
-  unsigned int abbrev_number, bytes_read, i;
-  struct abbrev_info *abbrev;
-  struct attribute attr;
-  struct attribute spec_attr;
-  int found_spec_attr = 0;
-  int has_low_pc_attr  = 0;
-  int has_high_pc_attr = 0;
-
-  *part_die = zeroed_partial_die;
-  *has_pc_info = 0;
-  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
-  info_ptr += bytes_read;
-  if (!abbrev_number)
-    return info_ptr;
-
-  abbrev = dwarf2_lookup_abbrev (abbrev_number);
-  if (!abbrev)
-    {
-      error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number);
-    }
-  part_die->offset = info_ptr - dwarf_info_buffer;
-  part_die->tag = abbrev->tag;
-  part_die->has_children = abbrev->has_children;
-  part_die->abbrev = abbrev_number;
-
-  for (i = 0; i < abbrev->num_attrs; ++i)
-    {
-      info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr);
-
-      /* Store the data if it is of an attribute we want to keep in a
-	 partial symbol table.  */
-      switch (attr.name)
-	{
-	case DW_AT_name:
-
-	  /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
-	  if (part_die->name == NULL)
-	    part_die->name = DW_STRING (&attr);
-	  break;
-	case DW_AT_MIPS_linkage_name:
-	  part_die->name = DW_STRING (&attr);
-	  break;
-	case DW_AT_low_pc:
-	  has_low_pc_attr = 1;
-	  part_die->lowpc = DW_ADDR (&attr);
-	  break;
-	case DW_AT_high_pc:
-	  has_high_pc_attr = 1;
-	  part_die->highpc = DW_ADDR (&attr);
-	  break;
-	case DW_AT_location:
-	  part_die->locdesc = DW_BLOCK (&attr);
-	  break;
-	case DW_AT_language:
-	  part_die->language = DW_UNSND (&attr);
-	  break;
-	case DW_AT_external:
-	  part_die->is_external = DW_UNSND (&attr);
-	  break;
-	case DW_AT_declaration:
-	  part_die->is_declaration = DW_UNSND (&attr);
-	  break;
-	case DW_AT_type:
-	  part_die->has_type = 1;
-	  break;
-	case DW_AT_abstract_origin:
-	case DW_AT_specification:
-	  found_spec_attr = 1;
-	  spec_attr = attr;
-	  break;
-	case DW_AT_sibling:
-	  /* Ignore absolute siblings, they might point outside of
-	     the current compile unit.  */
-	  if (attr.form == DW_FORM_ref_addr)
-	    complain(&dwarf2_absolute_sibling_complaint);
-	  else
-	    part_die->sibling =
-	      dwarf_info_buffer + dwarf2_get_ref_die_offset (&attr);
-	  break;
-	default:
-	  break;
-	}
-    }
-
-  /* If we found a reference attribute and the die has no name, try
-     to find a name in the referred to die.  */
-
-  if (found_spec_attr && part_die->name == NULL)
-    {
-      struct partial_die_info spec_die;
-      char *spec_ptr;
-      int dummy;
-
-      spec_ptr = dwarf_info_buffer + dwarf2_get_ref_die_offset (&spec_attr);
-      read_partial_die (&spec_die, abfd, spec_ptr, &dummy);
-      if (spec_die.name)
-	{
-	  part_die->name = spec_die.name;
-
-	  /* Copy DW_AT_external attribute if it is set.  */
-	  if (spec_die.is_external)
-	    part_die->is_external = spec_die.is_external;
-	}
-    }
-
-  /* When using the GNU linker, .gnu.linkonce. sections are used to
-     eliminate duplicate copies of functions and vtables and such.
-     The linker will arbitrarily choose one and discard the others.
-     The AT_*_pc values for such functions refer to local labels in
-     these sections.  If the section from that file was discarded, the
-     labels are not in the output, so the relocs get a value of 0.
-     If this is a discarded function, mark the pc bounds as invalid,
-     so that GDB will ignore it.  */
-  if (has_low_pc_attr && has_high_pc_attr
-      && part_die->lowpc < part_die->highpc
-      && (part_die->lowpc != 0
-	  || (bfd_get_file_flags (abfd) & HAS_RELOC)))
-    *has_pc_info = 1;
-  return info_ptr;
-}
-
-/* Read the die from the .debug_info section buffer.  And set diep to
-   point to a newly allocated die with its information.  */
-
-static char *
-read_full_die (diep, abfd, info_ptr)
-     struct die_info **diep;
-     bfd *abfd;
-     char *info_ptr;
-{
-  unsigned int abbrev_number, bytes_read, i, offset;
-  struct abbrev_info *abbrev;
-  struct die_info *die;
-
-  offset = info_ptr - dwarf_info_buffer;
-  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
-  info_ptr += bytes_read;
-  if (!abbrev_number)
-    {
-      die = dwarf_alloc_die ();
-      die->tag = 0;
-      die->abbrev = abbrev_number;
-      die->type = NULL;
-      *diep = die;
-      return info_ptr;
-    }
-
-  abbrev = dwarf2_lookup_abbrev (abbrev_number);
-  if (!abbrev)
-    {
-      error ("Dwarf Error: could not find abbrev number %d.", abbrev_number);
-    }
-  die = dwarf_alloc_die ();
-  die->offset = offset;
-  die->tag = abbrev->tag;
-  die->has_children = abbrev->has_children;
-  die->abbrev = abbrev_number;
-  die->type = NULL;
-
-  die->num_attrs = abbrev->num_attrs;
-  die->attrs = (struct attribute *)
-    xmalloc (die->num_attrs * sizeof (struct attribute));
-
-  for (i = 0; i < abbrev->num_attrs; ++i)
-    {
-      info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
-				 abfd, info_ptr);
-    }
-
-  *diep = die;
-  return info_ptr;
-}
-
-/* Read an attribute described by an abbreviated attribute.  */
-
-static char *
-read_attribute (attr, abbrev, abfd, info_ptr)
-     struct attribute *attr;
-     struct attr_abbrev *abbrev;
-     bfd *abfd;
-     char *info_ptr;
-{
-  unsigned int bytes_read;
-  struct dwarf_block *blk;
-
-  attr->name = abbrev->name;
-  attr->form = abbrev->form;
-  switch (abbrev->form)
-    {
-    case DW_FORM_addr:
-    case DW_FORM_ref_addr:
-      DW_ADDR (attr) = read_address (abfd, info_ptr);
-      info_ptr += address_size;
-      break;
-    case DW_FORM_block2:
-      blk = dwarf_alloc_block ();
-      blk->size = read_2_bytes (abfd, info_ptr);
-      info_ptr += 2;
-      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
-      info_ptr += blk->size;
-      DW_BLOCK (attr) = blk;
-      break;
-    case DW_FORM_block4:
-      blk = dwarf_alloc_block ();
-      blk->size = read_4_bytes (abfd, info_ptr);
-      info_ptr += 4;
-      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
-      info_ptr += blk->size;
-      DW_BLOCK (attr) = blk;
-      break;
-    case DW_FORM_data2:
-      DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
-      info_ptr += 2;
-      break;
-    case DW_FORM_data4:
-      DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
-      info_ptr += 4;
-      break;
-    case DW_FORM_data8:
-      DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
-      info_ptr += 8;
-      break;
-    case DW_FORM_string:
-      DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
-      info_ptr += bytes_read;
-      break;
-    case DW_FORM_block:
-      blk = dwarf_alloc_block ();
-      blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
-      info_ptr += bytes_read;
-      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
-      info_ptr += blk->size;
-      DW_BLOCK (attr) = blk;
-      break;
-    case DW_FORM_block1:
-      blk = dwarf_alloc_block ();
-      blk->size = read_1_byte (abfd, info_ptr);
-      info_ptr += 1;
-      blk->data = read_n_bytes (abfd, info_ptr, blk->size);
-      info_ptr += blk->size;
-      DW_BLOCK (attr) = blk;
-      break;
-    case DW_FORM_data1:
-      DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
-      info_ptr += 1;
-      break;
-    case DW_FORM_flag:
-      DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
-      info_ptr += 1;
-      break;
-    case DW_FORM_sdata:
-      DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
-      info_ptr += bytes_read;
-      break;
-    case DW_FORM_udata:
-      DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
-      info_ptr += bytes_read;
-      break;
-    case DW_FORM_ref1:
-      DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
-      info_ptr += 1;
-      break;
-    case DW_FORM_ref2:
-      DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
-      info_ptr += 2;
-      break;
-    case DW_FORM_ref4:
-      DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
-      info_ptr += 4;
-      break;
-    case DW_FORM_ref_udata:
-      DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
-      info_ptr += bytes_read;
-      break;
-    case DW_FORM_strp:
-    case DW_FORM_indirect:
-    default:
-      error ("Dwarf Error: Cannot handle %s in DWARF reader.",
-	     dwarf_form_name (abbrev->form));
-    }
-  return info_ptr;
-}
-
-/* read dwarf information from a buffer */
-
-static unsigned int
-read_1_byte (abfd, buf)
-     bfd *abfd;
-     char *buf;
-{
-  return bfd_get_8 (abfd, (bfd_byte *) buf);
-}
-
-static int
-read_1_signed_byte (abfd, buf)
-     bfd *abfd;
-     char *buf;
-{
-  return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
-}
-
-static unsigned int
-read_2_bytes (abfd, buf)
-     bfd *abfd;
-     char *buf;
-{
-  return bfd_get_16 (abfd, (bfd_byte *) buf);
-}
-
-static int
-read_2_signed_bytes (abfd, buf)
-     bfd *abfd;
-     char *buf;
-{
-  return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
-}
-
-static unsigned int
-read_4_bytes (abfd, buf)
-     bfd *abfd;
-     char *buf;
-{
-  return bfd_get_32 (abfd, (bfd_byte *) buf);
-}
-
-static int
-read_4_signed_bytes (abfd, buf)
-     bfd *abfd;
-     char *buf;
-{
-  return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
-}
-
-static unsigned int
-read_8_bytes (abfd, buf)
-     bfd *abfd;
-     char *buf;
-{
-  return bfd_get_64 (abfd, (bfd_byte *) buf);
-}
-
-static CORE_ADDR
-read_address (abfd, buf)
-     bfd *abfd;
-     char *buf;
-{
-  CORE_ADDR retval = 0;
-
-  switch (address_size)
-    {
-    case 4:
-      retval = bfd_get_32 (abfd, (bfd_byte *) buf);
-      break;
-    case 8:
-      retval = bfd_get_64 (abfd, (bfd_byte *) buf);
-      break;
-    default:
-      /* *THE* alternative is 8, right? */
-      abort ();
-    }
-  /* If the address being read is larger than the address that is
-     applicable for the object file format then mask it down to the
-     correct size.  Take care to avoid unnecessary shift or shift
-     overflow */
-  if (address_size > address_significant_size
-      && address_significant_size < sizeof (CORE_ADDR))
-    {
-      CORE_ADDR mask = ((CORE_ADDR) 0) - 1;
-      retval &= ~(mask << (address_significant_size * 8));
-    }
-  return retval;
-}
-
-static char *
-read_n_bytes (abfd, buf, size)
-     bfd * abfd;
-     char *buf;
-     unsigned int size;
-{
-  /* If the size of a host char is 8 bits, we can return a pointer
-     to the buffer, otherwise we have to copy the data to a buffer
-     allocated on the temporary obstack.  */
-#if HOST_CHAR_BIT == 8
-  return buf;
-#else
-  char *ret;
-  unsigned int i;
-
-  ret = obstack_alloc (&dwarf2_tmp_obstack, size);
-  for (i = 0; i < size; ++i)
-    {
-      ret[i] = bfd_get_8 (abfd, (bfd_byte *) buf);
-      buf++;
-    }
-  return ret;
-#endif
-}
-
-static char *
-read_string (abfd, buf, bytes_read_ptr)
-     bfd *abfd;
-     char *buf;
-     unsigned int *bytes_read_ptr;
-{
-  /* If the size of a host char is 8 bits, we can return a pointer
-     to the string, otherwise we have to copy the string to a buffer
-     allocated on the temporary obstack.  */
-#if HOST_CHAR_BIT == 8
-  if (*buf == '\0')
-    {
-      *bytes_read_ptr = 1;
-      return NULL;
-    }
-  *bytes_read_ptr = strlen (buf) + 1;
-  return buf;
-#else
-  int byte;
-  unsigned int i = 0;
-
-  while ((byte = bfd_get_8 (abfd, (bfd_byte *) buf)) != 0)
-    {
-      obstack_1grow (&dwarf2_tmp_obstack, byte);
-      i++;
-      buf++;
-    }
-  if (i == 0)
-    {
-      *bytes_read_ptr = 1;
-      return NULL;
-    }
-  obstack_1grow (&dwarf2_tmp_obstack, '\0');
-  *bytes_read_ptr = i + 1;
-  return obstack_finish (&dwarf2_tmp_obstack);
-#endif
-}
-
-static unsigned int
-read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
-     bfd *abfd;
-     char *buf;
-     unsigned int *bytes_read_ptr;
-{
-  unsigned int result, num_read;
-  int i, shift;
-  unsigned char byte;
-
-  result = 0;
-  shift = 0;
-  num_read = 0;
-  i = 0;
-  while (1)
-    {
-      byte = bfd_get_8 (abfd, (bfd_byte *) buf);
-      buf++;
-      num_read++;
-      result |= ((byte & 127) << shift);
-      if ((byte & 128) == 0)
-	{
-	  break;
-	}
-      shift += 7;
-    }
-  *bytes_read_ptr = num_read;
-  return result;
-}
-
-static int
-read_signed_leb128 (abfd, buf, bytes_read_ptr)
-     bfd *abfd;
-     char *buf;
-     unsigned int *bytes_read_ptr;
-{
-  int result;
-  int i, shift, size, num_read;
-  unsigned char byte;
-
-  result = 0;
-  shift = 0;
-  size = 32;
-  num_read = 0;
-  i = 0;
-  while (1)
-    {
-      byte = bfd_get_8 (abfd, (bfd_byte *) buf);
-      buf++;
-      num_read++;
-      result |= ((byte & 127) << shift);
-      shift += 7;
-      if ((byte & 128) == 0)
-	{
-	  break;
-	}
-    }
-  if ((shift < size) && (byte & 0x40))
-    {
-      result |= -(1 << shift);
-    }
-  *bytes_read_ptr = num_read;
-  return result;
-}
-
-static void
-set_cu_language (lang)
-     unsigned int lang;
-{
-  switch (lang)
-    {
-    case DW_LANG_C89:
-    case DW_LANG_C:
-      cu_language = language_c;
-      break;
-    case DW_LANG_C_plus_plus:
-      cu_language = language_cplus;
-      break;
-    case DW_LANG_Fortran77:
-    case DW_LANG_Fortran90:
-      cu_language = language_fortran;
-      break;
-    case DW_LANG_Mips_Assembler:
-      cu_language = language_asm;
-      break;
-    case DW_LANG_Ada83:
-    case DW_LANG_Cobol74:
-    case DW_LANG_Cobol85:
-    case DW_LANG_Pascal83:
-    case DW_LANG_Modula2:
-    default:
-      cu_language = language_unknown;
-      break;
-    }
-  cu_language_defn = language_def (cu_language);
-}
-
-/* Return the named attribute or NULL if not there.  */
-
-static struct attribute *
-dwarf_attr (die, name)
-     struct die_info *die;
-     unsigned int name;
-{
-  unsigned int i;
-  struct attribute *spec = NULL;
-
-  for (i = 0; i < die->num_attrs; ++i)
-    {
-      if (die->attrs[i].name == name)
-	{
-	  return &die->attrs[i];
-	}
-      if (die->attrs[i].name == DW_AT_specification
-	  || die->attrs[i].name == DW_AT_abstract_origin)
-	spec = &die->attrs[i];
-    }
-  if (spec)
-    {
-      struct die_info *ref_die =
-	follow_die_ref (dwarf2_get_ref_die_offset (spec));
-
-      if (ref_die)
-	return dwarf_attr (ref_die, name);
-    }
-    
-  return NULL;
-}
-
-/* Decode the line number information for the compilation unit whose
-   line number info is at OFFSET in the .debug_line section.
-   The compilation directory of the file is passed in COMP_DIR.  */
-
-struct filenames
-{
-  unsigned int num_files;
-  struct fileinfo
-  {
-    char *name;
-    unsigned int dir;
-    unsigned int time;
-    unsigned int size;
-  }
-  *files;
-};
-
-struct directories
-{
-  unsigned int num_dirs;
-  char **dirs;
-};
-
-static void
-dwarf_decode_lines (offset, comp_dir, abfd)
-     unsigned int offset;
-     char *comp_dir;
-     bfd *abfd;
-{
-  char *line_ptr;
-  char *line_end;
-  struct line_head lh;
-  struct cleanup *back_to;
-  unsigned int i, bytes_read;
-  char *cur_file, *cur_dir;
-  unsigned char op_code, extended_op, adj_opcode;
-
-#define FILE_ALLOC_CHUNK 5
-#define DIR_ALLOC_CHUNK 5
-
-  struct filenames files;
-  struct directories dirs;
-
-  if (dwarf_line_buffer == NULL)
-    {
-      complain (&dwarf2_missing_line_number_section);
-      return;
-    }
-
-  files.num_files = 0;
-  files.files = NULL;
-
-  dirs.num_dirs = 0;
-  dirs.dirs = NULL;
-
-  line_ptr = dwarf_line_buffer + offset;
-
-  /* read in the prologue */
-  lh.total_length = read_4_bytes (abfd, line_ptr);
-  line_ptr += 4;
-  line_end = line_ptr + lh.total_length;
-  lh.version = read_2_bytes (abfd, line_ptr);
-  line_ptr += 2;
-  lh.prologue_length = read_4_bytes (abfd, line_ptr);
-  line_ptr += 4;
-  lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
-  line_ptr += 1;
-  lh.default_is_stmt = read_1_byte (abfd, line_ptr);
-  line_ptr += 1;
-  lh.line_base = read_1_signed_byte (abfd, line_ptr);
-  line_ptr += 1;
-  lh.line_range = read_1_byte (abfd, line_ptr);
-  line_ptr += 1;
-  lh.opcode_base = read_1_byte (abfd, line_ptr);
-  line_ptr += 1;
-  lh.standard_opcode_lengths = (unsigned char *)
-    xmalloc (lh.opcode_base * sizeof (unsigned char));
-  back_to = make_cleanup ((make_cleanup_func) free_current_contents, 
-                          &lh.standard_opcode_lengths);
-
-  lh.standard_opcode_lengths[0] = 1;
-  for (i = 1; i < lh.opcode_base; ++i)
-    {
-      lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
-      line_ptr += 1;
-    }
-
-  /* Read directory table  */
-  while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
-    {
-      line_ptr += bytes_read;
-      if ((dirs.num_dirs % DIR_ALLOC_CHUNK) == 0)
-	{
-	  dirs.dirs = (char **)
-	    xrealloc (dirs.dirs,
-		      (dirs.num_dirs + DIR_ALLOC_CHUNK) * sizeof (char *));
-	  if (dirs.num_dirs == 0)
-	    make_cleanup ((make_cleanup_func) free_current_contents, &dirs.dirs);
-	}
-      dirs.dirs[dirs.num_dirs++] = cur_dir;
-    }
-  line_ptr += bytes_read;
-
-  /* Read file name table */
-  while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
-    {
-      line_ptr += bytes_read;
-      if ((files.num_files % FILE_ALLOC_CHUNK) == 0)
-	{
-	  files.files = (struct fileinfo *)
-	    xrealloc (files.files,
-		      (files.num_files + FILE_ALLOC_CHUNK)
-			* sizeof (struct fileinfo));
-	  if (files.num_files == 0)
-	    make_cleanup ((make_cleanup_func) free_current_contents, 
-                          &files.files);
-	}
-      files.files[files.num_files].name = cur_file;
-      files.files[files.num_files].dir =
-	read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-      line_ptr += bytes_read;
-      files.files[files.num_files].time =
-	read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-      line_ptr += bytes_read;
-      files.files[files.num_files].size =
-	read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-      line_ptr += bytes_read;
-      files.num_files++;
-    }
-  line_ptr += bytes_read;
-
-  /* Read the statement sequences until there's nothing left.  */
-  while (line_ptr < line_end)
-    {
-      /* state machine registers  */
-      CORE_ADDR address = 0;
-      unsigned int file = 1;
-      unsigned int line = 1;
-      unsigned int column = 0;
-      int is_stmt = lh.default_is_stmt;
-      int basic_block = 0;
-      int end_sequence = 0;
-
-      /* Start a subfile for the current file of the state machine.  */
-      if (files.num_files >= file)
-	{
-	  /* The file and directory tables are 0 based, the references
-	     are 1 based.  */
-	  dwarf2_start_subfile (files.files[file - 1].name,
-				(files.files[file - 1].dir
-				 ? dirs.dirs[files.files[file - 1].dir - 1]
-				 : comp_dir));
-	}
-
-      /* Decode the table. */
-      while (! end_sequence)
-	{
-	  op_code = read_1_byte (abfd, line_ptr);
-	  line_ptr += 1;
-	  switch (op_code)
-	    {
-	    case DW_LNS_extended_op:
-	      line_ptr += 1;	/* ignore length */
-	      extended_op = read_1_byte (abfd, line_ptr);
-	      line_ptr += 1;
-	      switch (extended_op)
-		{
-		case DW_LNE_end_sequence:
-		  end_sequence = 1;
-		  record_line (current_subfile, line, address);
-		  break;
-		case DW_LNE_set_address:
-		  address = read_address (abfd, line_ptr) + baseaddr;
-		  line_ptr += address_size;
-		  break;
-		case DW_LNE_define_file:
-		  cur_file = read_string (abfd, line_ptr, &bytes_read);
-		  line_ptr += bytes_read;
-		  if ((files.num_files % FILE_ALLOC_CHUNK) == 0)
-		    {
-		      files.files = (struct fileinfo *)
-			xrealloc (files.files,
-				  (files.num_files + FILE_ALLOC_CHUNK)
-				    * sizeof (struct fileinfo));
-		      if (files.num_files == 0)
-			make_cleanup ((make_cleanup_func) free_current_contents, 
-                                      &files.files);
-		    }
-		  files.files[files.num_files].name = cur_file;
-		  files.files[files.num_files].dir =
-		    read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-		  line_ptr += bytes_read;
-		  files.files[files.num_files].time =
-		    read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-		  line_ptr += bytes_read;
-		  files.files[files.num_files].size =
-		    read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-		  line_ptr += bytes_read;
-		  files.num_files++;
-		  break;
-		default:
-		  complain (&dwarf2_mangled_line_number_section);
-		  goto done;
-		}
-	      break;
-	    case DW_LNS_copy:
-	      record_line (current_subfile, line, address);
-	      basic_block = 0;
-	      break;
-	    case DW_LNS_advance_pc:
-	      address += lh.minimum_instruction_length
-		* read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-	      line_ptr += bytes_read;
-	      break;
-	    case DW_LNS_advance_line:
-	      line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
-	      line_ptr += bytes_read;
-	      break;
-	    case DW_LNS_set_file:
-	      /* The file and directory tables are 0 based, the references
-		 are 1 based.  */
-	      file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-	      line_ptr += bytes_read;
-	      dwarf2_start_subfile
-		(files.files[file - 1].name,
-		 (files.files[file - 1].dir
-		  ? dirs.dirs[files.files[file - 1].dir - 1]
-		  : comp_dir));
-	      break;
-	    case DW_LNS_set_column:
-	      column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
-	      line_ptr += bytes_read;
-	      break;
-	    case DW_LNS_negate_stmt:
-	      is_stmt = (!is_stmt);
-	      break;
-	    case DW_LNS_set_basic_block:
-	      basic_block = 1;
-	      break;
-	    case DW_LNS_const_add_pc:
-	      address += (255 - lh.opcode_base) / lh.line_range;
-	      break;
-	    case DW_LNS_fixed_advance_pc:
-	      address += read_2_bytes (abfd, line_ptr);
-	      line_ptr += 2;
-	      break;
-	    default:		/* special operand */
-	      adj_opcode = op_code - lh.opcode_base;
-	      address += (adj_opcode / lh.line_range)
-		* lh.minimum_instruction_length;
-	      line += lh.line_base + (adj_opcode % lh.line_range);
-	      /* append row to matrix using current values */
-	      record_line (current_subfile, line, address);
-	      basic_block = 1;
-	    }
-	}
-    }
-done:
-  do_cleanups (back_to);
-}
-
-/* Start a subfile for DWARF.  FILENAME is the name of the file and
-   DIRNAME the name of the source directory which contains FILENAME
-   or NULL if not known.
-   This routine tries to keep line numbers from identical absolute and
-   relative file names in a common subfile.
-
-   Using the `list' example from the GDB testsuite, which resides in
-   /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
-   of /srcdir/list0.c yields the following debugging information for list0.c:
-
-	DW_AT_name:		/srcdir/list0.c
-	DW_AT_comp_dir:		/compdir
-	files.files[0].name:	list0.h		
-	files.files[0].dir:	/srcdir
-	files.files[1].name:	list0.c		
-	files.files[1].dir:	/srcdir
-
-   The line number information for list0.c has to end up in a single
-   subfile, so that `break /srcdir/list0.c:1' works as expected.  */
-
-static void
-dwarf2_start_subfile (filename, dirname)
-     char *filename;
-     char *dirname;
-{
-  /* If the filename isn't absolute, try to match an existing subfile
-     with the full pathname.  */
-
-  if (*filename != '/' && dirname != NULL)
-    {
-      struct subfile *subfile;
-      char *fullname = concat (dirname, "/", filename, NULL);
-
-      for (subfile = subfiles; subfile; subfile = subfile->next)
-	{
-	  if (STREQ (subfile->name, fullname))
-	    {
-	      current_subfile = subfile;
-	      free (fullname);
-	      return;
-	    }
-	}
-      free (fullname);
-    }
-  start_subfile (filename, dirname);
-}
-
-/* Given a pointer to a DWARF information entry, figure out if we need
-   to make a symbol table entry for it, and if so, create a new entry
-   and return a pointer to it.
-   If TYPE is NULL, determine symbol type from the die, otherwise
-   used the passed type.
-  */
-
-static struct symbol *
-new_symbol (die, type, objfile)
-     struct die_info *die;
-     struct type *type;
-     struct objfile *objfile;
-{
-  struct symbol *sym = NULL;
-  char *name;
-  struct attribute *attr = NULL;
-  struct attribute *attr2 = NULL;
-  CORE_ADDR addr;
-
-  name = dwarf2_linkage_name (die);
-  if (name)
-    {
-      sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
-					     sizeof (struct symbol));
-      OBJSTAT (objfile, n_syms++);
-      memset (sym, 0, sizeof (struct symbol));
-      SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
-					&objfile->symbol_obstack);
-
-      /* Default assumptions.
-	 Use the passed type or decode it from the die.  */
-      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-      SYMBOL_CLASS (sym) = LOC_STATIC;
-      if (type != NULL)
-	SYMBOL_TYPE (sym) = type;
-      else
-	SYMBOL_TYPE (sym) = die_type (die, objfile);
-      attr = dwarf_attr (die, DW_AT_decl_line);
-      if (attr)
-	{
-	  SYMBOL_LINE (sym) = DW_UNSND (attr);
-	}
-
-      /* If this symbol is from a C++ compilation, then attempt to
-         cache the demangled form for future reference.  This is a
-         typical time versus space tradeoff, that was decided in favor
-         of time because it sped up C++ symbol lookups by a factor of
-         about 20. */
-
-      SYMBOL_LANGUAGE (sym) = cu_language;
-      SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
-      switch (die->tag)
-	{
-	case DW_TAG_label:
-	  attr = dwarf_attr (die, DW_AT_low_pc);
-	  if (attr)
-	    {
-	      SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
-	    }
-	  SYMBOL_CLASS (sym) = LOC_LABEL;
-	  break;
-	case DW_TAG_subprogram:
-	  /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
-	     finish_block.  */
-	  SYMBOL_CLASS (sym) = LOC_BLOCK;
-	  attr2 = dwarf_attr (die, DW_AT_external);
-	  if (attr2 && (DW_UNSND (attr2) != 0))
-	    {
-	      add_symbol_to_list (sym, &global_symbols);
-	    }
-	  else
-	    {
-	      add_symbol_to_list (sym, list_in_scope);
-	    }
-	  break;
-	case DW_TAG_variable:
-	  /* Compilation with minimal debug info may result in variables
-	     with missing type entries. Change the misleading `void' type
-	     to something sensible.  */
-	  if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
-	    SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
-					   TARGET_INT_BIT / HOST_CHAR_BIT, 0,
-					   "<variable, no debug info>",
-					   objfile);
-	  attr = dwarf_attr (die, DW_AT_const_value);
-	  if (attr)
-	    {
-	      dwarf2_const_value (attr, sym, objfile);
-	      attr2 = dwarf_attr (die, DW_AT_external);
-	      if (attr2 && (DW_UNSND (attr2) != 0))
-		add_symbol_to_list (sym, &global_symbols);
-	      else
-		add_symbol_to_list (sym, list_in_scope);
-	      break;
-	    }
-	  attr = dwarf_attr (die, DW_AT_location);
-	  if (attr)
-	    {
-	      attr2 = dwarf_attr (die, DW_AT_external);
-	      if (attr2 && (DW_UNSND (attr2) != 0))
-		{
-		  SYMBOL_VALUE_ADDRESS (sym) =
-		    decode_locdesc (DW_BLOCK (attr), objfile);
-		  add_symbol_to_list (sym, &global_symbols);
-
-	 	  /* In shared libraries the address of the variable
-		     in the location descriptor might still be relocatable,
-		     so its value could be zero.
-		     Enter the symbol as a LOC_UNRESOLVED symbol, if its
-		     value is zero, the address of the variable will then
-		     be determined from the minimal symbol table whenever
-		     the variable is referenced.  */
-		  if (SYMBOL_VALUE_ADDRESS (sym))
-		    {
-		      SYMBOL_VALUE_ADDRESS (sym) += baseaddr;
-		      SYMBOL_CLASS (sym) = LOC_STATIC;
-		    }
-		  else
-		    SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
-		}
-	      else
-		{
-		  SYMBOL_VALUE (sym) = addr =
-		    decode_locdesc (DW_BLOCK (attr), objfile);
-		  add_symbol_to_list (sym, list_in_scope);
-		  if (optimized_out)
-		    {
-		      SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
-		    }
-		  else if (isreg)
-		    {
-		      SYMBOL_CLASS (sym) = LOC_REGISTER;
-		    }
-		  else if (offreg)
-		    {
-		      SYMBOL_CLASS (sym) = LOC_BASEREG;
-		      SYMBOL_BASEREG (sym) = basereg;
-		    }
-		  else if (islocal)
-		    {
-		      SYMBOL_CLASS (sym) = LOC_LOCAL;
-		    }
-		  else
-		    {
-		      SYMBOL_CLASS (sym) = LOC_STATIC;
-		      SYMBOL_VALUE_ADDRESS (sym) = addr + baseaddr;
-		    }
-		}
-	    }
-	  else
-	    {
-	      /* We do not know the address of this symbol.
-		 If it is an external symbol and we have type information
-		 for it, enter the symbol as a LOC_UNRESOLVED symbol.
-		 The address of the variable will then be determined from
-		 the minimal symbol table whenever the variable is
-		 referenced.  */
-	      attr2 = dwarf_attr (die, DW_AT_external);
-	      if (attr2 && (DW_UNSND (attr2) != 0)
-		  && dwarf_attr (die, DW_AT_type) != NULL)
-		{
-		  SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
-		  add_symbol_to_list (sym, &global_symbols);
-		}
-	    }
-	  break;
-	case DW_TAG_formal_parameter:
-	  attr = dwarf_attr (die, DW_AT_location);
-	  if (attr)
-	    {
-	      SYMBOL_VALUE (sym) = decode_locdesc (DW_BLOCK (attr), objfile);
-	      if (isreg)
-		{
-		  SYMBOL_CLASS (sym) = LOC_REGPARM;
-		}
-	      else if (offreg)
-		{
-		  SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
-		  SYMBOL_BASEREG (sym) = basereg;
-		}
-	      else
-		{
-		  SYMBOL_CLASS (sym) = LOC_ARG;
-		}
-	    }
-	  attr = dwarf_attr (die, DW_AT_const_value);
-	  if (attr)
-	    {
-	      dwarf2_const_value (attr, sym, objfile);
-	    }
-	  add_symbol_to_list (sym, list_in_scope);
-	  break;
-	case DW_TAG_unspecified_parameters:
-	  /* From varargs functions; gdb doesn't seem to have any
-	     interest in this information, so just ignore it for now.
-	     (FIXME?) */
-	  break;
-	case DW_TAG_class_type:
-	case DW_TAG_structure_type:
-	case DW_TAG_union_type:
-	case DW_TAG_enumeration_type:
-	  SYMBOL_CLASS (sym) = LOC_TYPEDEF;
-	  SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
-	  add_symbol_to_list (sym, list_in_scope);
-
-	  /* The semantics of C++ state that "struct foo { ... }" also
-	     defines a typedef for "foo". Synthesize a typedef symbol so
-	     that "ptype foo" works as expected.  */
-	  if (cu_language == language_cplus)
-	    {
-	      struct symbol *typedef_sym = (struct symbol *)
-		obstack_alloc (&objfile->symbol_obstack,
-			       sizeof (struct symbol));
-	      *typedef_sym = *sym;
-	      SYMBOL_NAMESPACE (typedef_sym) = VAR_NAMESPACE;
-	      if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
-		TYPE_NAME (SYMBOL_TYPE (sym)) =
-		  obsavestring (SYMBOL_NAME (sym),
-				strlen (SYMBOL_NAME (sym)),
-				&objfile->type_obstack);
-	      add_symbol_to_list (typedef_sym, list_in_scope);
-	    }
-	  break;
-	case DW_TAG_typedef:
-	case DW_TAG_base_type:
-	  SYMBOL_CLASS (sym) = LOC_TYPEDEF;
-	  SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-	  add_symbol_to_list (sym, list_in_scope);
-	  break;
-	case DW_TAG_enumerator:
-	  attr = dwarf_attr (die, DW_AT_const_value);
-	  if (attr)
-	    {
-	      dwarf2_const_value (attr, sym, objfile);
-	    }
-	  add_symbol_to_list (sym, list_in_scope);
-	  break;
-	default:
-	  /* Not a tag we recognize.  Hopefully we aren't processing
-	     trash data, but since we must specifically ignore things
-	     we don't recognize, there is nothing else we should do at
-	     this point. */
-	  complain (&dwarf2_unsupported_tag, dwarf_tag_name (die->tag));
-	  break;
-	}
-    }
-  return (sym);
-}
-
-/* Copy constant value from an attribute to a symbol.  */
-
-static void
-dwarf2_const_value (attr, sym, objfile)
-     struct attribute *attr;
-     struct symbol *sym;
-     struct objfile *objfile;
-{
-  struct dwarf_block *blk;
-
-  switch (attr->form)
-    {
-    case DW_FORM_addr:
-      if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != (unsigned int) address_size)
-	complain (&dwarf2_const_value_length_mismatch, SYMBOL_NAME (sym),
-		  address_size, TYPE_LENGTH (SYMBOL_TYPE (sym)));
-      SYMBOL_VALUE_BYTES (sym) = (char *)
-	obstack_alloc (&objfile->symbol_obstack, address_size);
-      store_address (SYMBOL_VALUE_BYTES (sym), address_size, DW_ADDR (attr));
-      SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
-      break;
-    case DW_FORM_block1:
-    case DW_FORM_block2:
-    case DW_FORM_block4:
-    case DW_FORM_block:
-      blk = DW_BLOCK (attr);
-      if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
-	complain (&dwarf2_const_value_length_mismatch, SYMBOL_NAME (sym),
-		  blk->size, TYPE_LENGTH (SYMBOL_TYPE (sym)));
-      SYMBOL_VALUE_BYTES (sym) = (char *)
-	obstack_alloc (&objfile->symbol_obstack, blk->size);
-      memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
-      SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
-      break;
-    case DW_FORM_data2:
-    case DW_FORM_data4:
-    case DW_FORM_data8:
-    case DW_FORM_data1:
-    case DW_FORM_sdata:
-    case DW_FORM_udata:
-      SYMBOL_VALUE (sym) = DW_UNSND (attr);
-      SYMBOL_CLASS (sym) = LOC_CONST;
-      break;
-    default:
-      complain (&dwarf2_unsupported_const_value_attr,
-		dwarf_form_name (attr->form));
-      SYMBOL_VALUE (sym) = 0;
-      SYMBOL_CLASS (sym) = LOC_CONST;
-      break;
-    }
-}
-
-/* Return the type of the die in question using its DW_AT_type attribute.  */
-
-static struct type *
-die_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type;
-  struct attribute *type_attr;
-  struct die_info *type_die;
-  unsigned int ref;
-
-  type_attr = dwarf_attr (die, DW_AT_type);
-  if (!type_attr)
-    {
-      /* A missing DW_AT_type represents a void type.  */
-      return dwarf2_fundamental_type (objfile, FT_VOID);
-    }
-  else
-    {
-      ref = dwarf2_get_ref_die_offset (type_attr);
-      type_die = follow_die_ref (ref);
-      if (!type_die)
-	{
-	  error ("Dwarf Error: Cannot find referent at offset %d.", ref);
-	  return NULL;
-	}
-    }
-  type = tag_type_to_type (type_die, objfile);
-  if (!type)
-    {
-      dump_die (type_die);
-      error ("Dwarf Error: Problem turning type die at offset into gdb type.");
-    }
-  return type;
-}
-
-/* Return the containing type of the die in question using its
-   DW_AT_containing_type attribute.  */
-
-static struct type *
-die_containing_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  struct type *type = NULL;
-  struct attribute *type_attr;
-  struct die_info *type_die = NULL;
-  unsigned int ref;
-
-  type_attr = dwarf_attr (die, DW_AT_containing_type);
-  if (type_attr)
-    {
-      ref = dwarf2_get_ref_die_offset (type_attr);
-      type_die = follow_die_ref (ref);
-      if (!type_die)
-	{
-	  error ("Dwarf Error: Cannot find referent at offset %d.", ref);
-	  return NULL;
-	}
-      type = tag_type_to_type (type_die, objfile);
-    }
-  if (!type)
-    {
-      if (type_die)
-	dump_die (type_die);
-      error ("Dwarf Error: Problem turning containing type into gdb type.");
-    }
-  return type;
-}
-
-#if 0
-static struct type *
-type_at_offset (offset, objfile)
-     unsigned int offset;
-     struct objfile *objfile;
-{
-  struct die_info *die;
-  struct type *type;
-
-  die = follow_die_ref (offset);
-  if (!die)
-    {
-      error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
-      return NULL;
-    }
-  type = tag_type_to_type (die, objfile);
-  return type;
-}
-#endif
-
-static struct type *
-tag_type_to_type (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  if (die->type)
-    {
-      return die->type;
-    }
-  else
-    {
-      read_type_die (die, objfile);
-      if (!die->type)
-	{
-	  dump_die (die);
-	  error ("Dwarf Error: Cannot find type of die.");
-	}
-      return die->type;
-    }
-}
-
-static void
-read_type_die (die, objfile)
-     struct die_info *die;
-     struct objfile *objfile;
-{
-  switch (die->tag)
-    {
-    case DW_TAG_class_type:
-    case DW_TAG_structure_type:
-    case DW_TAG_union_type:
-      read_structure_scope (die, objfile);
-      break;
-    case DW_TAG_enumeration_type:
-      read_enumeration (die, objfile);
-      break;
-    case DW_TAG_subprogram:
-    case DW_TAG_subroutine_type:
-      read_subroutine_type (die, objfile);
-      break;
-    case DW_TAG_array_type:
-      read_array_type (die, objfile);
-      break;
-    case DW_TAG_pointer_type:
-      read_tag_pointer_type (die, objfile);
-      break;
-    case DW_TAG_ptr_to_member_type:
-      read_tag_ptr_to_member_type (die, objfile);
-      break;
-    case DW_TAG_reference_type:
-      read_tag_reference_type (die, objfile);
-      break;
-    case DW_TAG_const_type:
-      read_tag_const_type (die, objfile);
-      break;
-    case DW_TAG_volatile_type:
-      read_tag_volatile_type (die, objfile);
-      break;
-    case DW_TAG_string_type:
-      read_tag_string_type (die, objfile);
-      break;
-    case DW_TAG_typedef:
-      read_typedef (die, objfile);
-      break;
-    case DW_TAG_base_type:
-      read_base_type (die, objfile);
-      break;
-    default:
-      complain (&dwarf2_unexpected_tag, dwarf_tag_name (die->tag));
-      break;
-    }
-}
-
-static struct type *
-dwarf_base_type (encoding, size, objfile)
-     int encoding;
-     int size;
-     struct objfile *objfile;
-{
-  /* FIXME - this should not produce a new (struct type *)
-     every time.  It should cache base types.  */
-  struct type *type;
-  switch (encoding)
-    {
-    case DW_ATE_address:
-      type = dwarf2_fundamental_type (objfile, FT_VOID);
-      return type;
-    case DW_ATE_boolean:
-      type = dwarf2_fundamental_type (objfile, FT_BOOLEAN);
-      return type;
-    case DW_ATE_complex_float:
-      if (size == 16)
-	{
-	  type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX);
-	}
-      else
-	{
-	  type = dwarf2_fundamental_type (objfile, FT_COMPLEX);
-	}
-      return type;
-    case DW_ATE_float:
-      if (size == 8)
-	{
-	  type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT);
-	}
-      else
-	{
-	  type = dwarf2_fundamental_type (objfile, FT_FLOAT);
-	}
-      return type;
-    case DW_ATE_signed:
-      switch (size)
-	{
-	case 1:
-	  type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR);
-	  break;
-	case 2:
-	  type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT);
-	  break;
-	default:
-	case 4:
-	  type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER);
-	  break;
-	}
-      return type;
-    case DW_ATE_signed_char:
-      type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR);
-      return type;
-    case DW_ATE_unsigned:
-      switch (size)
-	{
-	case 1:
-	  type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR);
-	  break;
-	case 2:
-	  type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT);
-	  break;
-	default:
-	case 4:
-	  type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER);
-	  break;
-	}
-      return type;
-    case DW_ATE_unsigned_char:
-      type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR);
-      return type;
-    default:
-      type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER);
-      return type;
-    }
-}
-
-#if 0
-struct die_info *
-copy_die (old_die)
-     struct die_info *old_die;
-{
-  struct die_info *new_die;
-  int i, num_attrs;
-
-  new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
-  memset (new_die, 0, sizeof (struct die_info));
-
-  new_die->tag = old_die->tag;
-  new_die->has_children = old_die->has_children;
-  new_die->abbrev = old_die->abbrev;
-  new_die->offset = old_die->offset;
-  new_die->type = NULL;
-
-  num_attrs = old_die->num_attrs;
-  new_die->num_attrs = num_attrs;
-  new_die->attrs = (struct attribute *)
-    xmalloc (num_attrs * sizeof (struct attribute));
-
-  for (i = 0; i < old_die->num_attrs; ++i)
-    {
-      new_die->attrs[i].name = old_die->attrs[i].name;
-      new_die->attrs[i].form = old_die->attrs[i].form;
-      new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
-    }
-
-  new_die->next = NULL;
-  return new_die;
-}
-#endif
-
-/* Return sibling of die, NULL if no sibling.  */
-
-struct die_info *
-sibling_die (die)
-     struct die_info *die;
-{
-  int nesting_level = 0;
-
-  if (!die->has_children)
-    {
-      if (die->next && (die->next->tag == 0))
-	{
-	  return NULL;
-	}
-      else
-	{
-	  return die->next;
-	}
-    }
-  else
-    {
-      do
-	{
-	  if (die->has_children)
-	    {
-	      nesting_level++;
-	    }
-	  if (die->tag == 0)
-	    {
-	      nesting_level--;
-	    }
-	  die = die->next;
-	}
-      while (nesting_level);
-      if (die && (die->tag == 0))
-	{
-	  return NULL;
-	}
-      else
-	{
-	  return die;
-	}
-    }
-}
-
-/* Get linkage name of a die, return NULL if not found.  */
-
-static char *
-dwarf2_linkage_name (die)
-     struct die_info *die;
-{
-  struct attribute *attr;
-
-  attr = dwarf_attr (die, DW_AT_MIPS_linkage_name);
-  if (attr && DW_STRING (attr))
-    return DW_STRING (attr);
-  attr = dwarf_attr (die, DW_AT_name);
-  if (attr && DW_STRING (attr))
-    return DW_STRING (attr);
-  return NULL;
-}
-
-/* Convert a DIE tag into its string name.  */
-
-static char *
-dwarf_tag_name (tag)
-     register unsigned tag;
-{
-  switch (tag)
-    {
-    case DW_TAG_padding:
-      return "DW_TAG_padding";
-    case DW_TAG_array_type:
-      return "DW_TAG_array_type";
-    case DW_TAG_class_type:
-      return "DW_TAG_class_type";
-    case DW_TAG_entry_point:
-      return "DW_TAG_entry_point";
-    case DW_TAG_enumeration_type:
-      return "DW_TAG_enumeration_type";
-    case DW_TAG_formal_parameter:
-      return "DW_TAG_formal_parameter";
-    case DW_TAG_imported_declaration:
-      return "DW_TAG_imported_declaration";
-    case DW_TAG_label:
-      return "DW_TAG_label";
-    case DW_TAG_lexical_block:
-      return "DW_TAG_lexical_block";
-    case DW_TAG_member:
-      return "DW_TAG_member";
-    case DW_TAG_pointer_type:
-      return "DW_TAG_pointer_type";
-    case DW_TAG_reference_type:
-      return "DW_TAG_reference_type";
-    case DW_TAG_compile_unit:
-      return "DW_TAG_compile_unit";
-    case DW_TAG_string_type:
-      return "DW_TAG_string_type";
-    case DW_TAG_structure_type:
-      return "DW_TAG_structure_type";
-    case DW_TAG_subroutine_type:
-      return "DW_TAG_subroutine_type";
-    case DW_TAG_typedef:
-      return "DW_TAG_typedef";
-    case DW_TAG_union_type:
-      return "DW_TAG_union_type";
-    case DW_TAG_unspecified_parameters:
-      return "DW_TAG_unspecified_parameters";
-    case DW_TAG_variant:
-      return "DW_TAG_variant";
-    case DW_TAG_common_block:
-      return "DW_TAG_common_block";
-    case DW_TAG_common_inclusion:
-      return "DW_TAG_common_inclusion";
-    case DW_TAG_inheritance:
-      return "DW_TAG_inheritance";
-    case DW_TAG_inlined_subroutine:
-      return "DW_TAG_inlined_subroutine";
-    case DW_TAG_module:
-      return "DW_TAG_module";
-    case DW_TAG_ptr_to_member_type:
-      return "DW_TAG_ptr_to_member_type";
-    case DW_TAG_set_type:
-      return "DW_TAG_set_type";
-    case DW_TAG_subrange_type:
-      return "DW_TAG_subrange_type";
-    case DW_TAG_with_stmt:
-      return "DW_TAG_with_stmt";
-    case DW_TAG_access_declaration:
-      return "DW_TAG_access_declaration";
-    case DW_TAG_base_type:
-      return "DW_TAG_base_type";
-    case DW_TAG_catch_block:
-      return "DW_TAG_catch_block";
-    case DW_TAG_const_type:
-      return "DW_TAG_const_type";
-    case DW_TAG_constant:
-      return "DW_TAG_constant";
-    case DW_TAG_enumerator:
-      return "DW_TAG_enumerator";
-    case DW_TAG_file_type:
-      return "DW_TAG_file_type";
-    case DW_TAG_friend:
-      return "DW_TAG_friend";
-    case DW_TAG_namelist:
-      return "DW_TAG_namelist";
-    case DW_TAG_namelist_item:
-      return "DW_TAG_namelist_item";
-    case DW_TAG_packed_type:
-      return "DW_TAG_packed_type";
-    case DW_TAG_subprogram:
-      return "DW_TAG_subprogram";
-    case DW_TAG_template_type_param:
-      return "DW_TAG_template_type_param";
-    case DW_TAG_template_value_param:
-      return "DW_TAG_template_value_param";
-    case DW_TAG_thrown_type:
-      return "DW_TAG_thrown_type";
-    case DW_TAG_try_block:
-      return "DW_TAG_try_block";
-    case DW_TAG_variant_part:
-      return "DW_TAG_variant_part";
-    case DW_TAG_variable:
-      return "DW_TAG_variable";
-    case DW_TAG_volatile_type:
-      return "DW_TAG_volatile_type";
-    case DW_TAG_MIPS_loop:
-      return "DW_TAG_MIPS_loop";
-    case DW_TAG_format_label:
-      return "DW_TAG_format_label";
-    case DW_TAG_function_template:
-      return "DW_TAG_function_template";
-    case DW_TAG_class_template:
-      return "DW_TAG_class_template";
-    default:
-      return "DW_TAG_<unknown>";
-    }
-}
-
-/* Convert a DWARF attribute code into its string name.  */
-
-static char *
-dwarf_attr_name (attr)
-     register unsigned attr;
-{
-  switch (attr)
-    {
-    case DW_AT_sibling:
-      return "DW_AT_sibling";
-    case DW_AT_location:
-      return "DW_AT_location";
-    case DW_AT_name:
-      return "DW_AT_name";
-    case DW_AT_ordering:
-      return "DW_AT_ordering";
-    case DW_AT_subscr_data:
-      return "DW_AT_subscr_data";
-    case DW_AT_byte_size:
-      return "DW_AT_byte_size";
-    case DW_AT_bit_offset:
-      return "DW_AT_bit_offset";
-    case DW_AT_bit_size:
-      return "DW_AT_bit_size";
-    case DW_AT_element_list:
-      return "DW_AT_element_list";
-    case DW_AT_stmt_list:
-      return "DW_AT_stmt_list";
-    case DW_AT_low_pc:
-      return "DW_AT_low_pc";
-    case DW_AT_high_pc:
-      return "DW_AT_high_pc";
-    case DW_AT_language:
-      return "DW_AT_language";
-    case DW_AT_member:
-      return "DW_AT_member";
-    case DW_AT_discr:
-      return "DW_AT_discr";
-    case DW_AT_discr_value:
-      return "DW_AT_discr_value";
-    case DW_AT_visibility:
-      return "DW_AT_visibility";
-    case DW_AT_import:
-      return "DW_AT_import";
-    case DW_AT_string_length:
-      return "DW_AT_string_length";
-    case DW_AT_common_reference:
-      return "DW_AT_common_reference";
-    case DW_AT_comp_dir:
-      return "DW_AT_comp_dir";
-    case DW_AT_const_value:
-      return "DW_AT_const_value";
-    case DW_AT_containing_type:
-      return "DW_AT_containing_type";
-    case DW_AT_default_value:
-      return "DW_AT_default_value";
-    case DW_AT_inline:
-      return "DW_AT_inline";
-    case DW_AT_is_optional:
-      return "DW_AT_is_optional";
-    case DW_AT_lower_bound:
-      return "DW_AT_lower_bound";
-    case DW_AT_producer:
-      return "DW_AT_producer";
-    case DW_AT_prototyped:
-      return "DW_AT_prototyped";
-    case DW_AT_return_addr:
-      return "DW_AT_return_addr";
-    case DW_AT_start_scope:
-      return "DW_AT_start_scope";
-    case DW_AT_stride_size:
-      return "DW_AT_stride_size";
-    case DW_AT_upper_bound:
-      return "DW_AT_upper_bound";
-    case DW_AT_abstract_origin:
-      return "DW_AT_abstract_origin";
-    case DW_AT_accessibility:
-      return "DW_AT_accessibility";
-    case DW_AT_address_class:
-      return "DW_AT_address_class";
-    case DW_AT_artificial:
-      return "DW_AT_artificial";
-    case DW_AT_base_types:
-      return "DW_AT_base_types";
-    case DW_AT_calling_convention:
-      return "DW_AT_calling_convention";
-    case DW_AT_count:
-      return "DW_AT_count";
-    case DW_AT_data_member_location:
-      return "DW_AT_data_member_location";
-    case DW_AT_decl_column:
-      return "DW_AT_decl_column";
-    case DW_AT_decl_file:
-      return "DW_AT_decl_file";
-    case DW_AT_decl_line:
-      return "DW_AT_decl_line";
-    case DW_AT_declaration:
-      return "DW_AT_declaration";
-    case DW_AT_discr_list:
-      return "DW_AT_discr_list";
-    case DW_AT_encoding:
-      return "DW_AT_encoding";
-    case DW_AT_external:
-      return "DW_AT_external";
-    case DW_AT_frame_base:
-      return "DW_AT_frame_base";
-    case DW_AT_friend:
-      return "DW_AT_friend";
-    case DW_AT_identifier_case:
-      return "DW_AT_identifier_case";
-    case DW_AT_macro_info:
-      return "DW_AT_macro_info";
-    case DW_AT_namelist_items:
-      return "DW_AT_namelist_items";
-    case DW_AT_priority:
-      return "DW_AT_priority";
-    case DW_AT_segment:
-      return "DW_AT_segment";
-    case DW_AT_specification:
-      return "DW_AT_specification";
-    case DW_AT_static_link:
-      return "DW_AT_static_link";
-    case DW_AT_type:
-      return "DW_AT_type";
-    case DW_AT_use_location:
-      return "DW_AT_use_location";
-    case DW_AT_variable_parameter:
-      return "DW_AT_variable_parameter";
-    case DW_AT_virtuality:
-      return "DW_AT_virtuality";
-    case DW_AT_vtable_elem_location:
-      return "DW_AT_vtable_elem_location";
-
-#ifdef MIPS
-    case DW_AT_MIPS_fde:
-      return "DW_AT_MIPS_fde";
-    case DW_AT_MIPS_loop_begin:
-      return "DW_AT_MIPS_loop_begin";
-    case DW_AT_MIPS_tail_loop_begin:
-      return "DW_AT_MIPS_tail_loop_begin";
-    case DW_AT_MIPS_epilog_begin:
-      return "DW_AT_MIPS_epilog_begin";
-    case DW_AT_MIPS_loop_unroll_factor:
-      return "DW_AT_MIPS_loop_unroll_factor";
-    case DW_AT_MIPS_software_pipeline_depth:
-      return "DW_AT_MIPS_software_pipeline_depth";
-    case DW_AT_MIPS_linkage_name:
-      return "DW_AT_MIPS_linkage_name";
-#endif
-
-    case DW_AT_sf_names:
-      return "DW_AT_sf_names";
-    case DW_AT_src_info:
-      return "DW_AT_src_info";
-    case DW_AT_mac_info:
-      return "DW_AT_mac_info";
-    case DW_AT_src_coords:
-      return "DW_AT_src_coords";
-    case DW_AT_body_begin:
-      return "DW_AT_body_begin";
-    case DW_AT_body_end:
-      return "DW_AT_body_end";
-    default:
-      return "DW_AT_<unknown>";
-    }
-}
-
-/* Convert a DWARF value form code into its string name.  */
-
-static char *
-dwarf_form_name (form)
-     register unsigned form;
-{
-  switch (form)
-    {
-    case DW_FORM_addr:
-      return "DW_FORM_addr";
-    case DW_FORM_block2:
-      return "DW_FORM_block2";
-    case DW_FORM_block4:
-      return "DW_FORM_block4";
-    case DW_FORM_data2:
-      return "DW_FORM_data2";
-    case DW_FORM_data4:
-      return "DW_FORM_data4";
-    case DW_FORM_data8:
-      return "DW_FORM_data8";
-    case DW_FORM_string:
-      return "DW_FORM_string";
-    case DW_FORM_block:
-      return "DW_FORM_block";
-    case DW_FORM_block1:
-      return "DW_FORM_block1";
-    case DW_FORM_data1:
-      return "DW_FORM_data1";
-    case DW_FORM_flag:
-      return "DW_FORM_flag";
-    case DW_FORM_sdata:
-      return "DW_FORM_sdata";
-    case DW_FORM_strp:
-      return "DW_FORM_strp";
-    case DW_FORM_udata:
-      return "DW_FORM_udata";
-    case DW_FORM_ref_addr:
-      return "DW_FORM_ref_addr";
-    case DW_FORM_ref1:
-      return "DW_FORM_ref1";
-    case DW_FORM_ref2:
-      return "DW_FORM_ref2";
-    case DW_FORM_ref4:
-      return "DW_FORM_ref4";
-    case DW_FORM_ref8:
-      return "DW_FORM_ref8";
-    case DW_FORM_ref_udata:
-      return "DW_FORM_ref_udata";
-    case DW_FORM_indirect:
-      return "DW_FORM_indirect";
-    default:
-      return "DW_FORM_<unknown>";
-    }
-}
-
-/* Convert a DWARF stack opcode into its string name.  */
-
-static char *
-dwarf_stack_op_name (op)
-     register unsigned op;
-{
-  switch (op)
-    {
-    case DW_OP_addr:
-      return "DW_OP_addr";
-    case DW_OP_deref:
-      return "DW_OP_deref";
-    case DW_OP_const1u:
-      return "DW_OP_const1u";
-    case DW_OP_const1s:
-      return "DW_OP_const1s";
-    case DW_OP_const2u:
-      return "DW_OP_const2u";
-    case DW_OP_const2s:
-      return "DW_OP_const2s";
-    case DW_OP_const4u:
-      return "DW_OP_const4u";
-    case DW_OP_const4s:
-      return "DW_OP_const4s";
-    case DW_OP_const8u:
-      return "DW_OP_const8u";
-    case DW_OP_const8s:
-      return "DW_OP_const8s";
-    case DW_OP_constu:
-      return "DW_OP_constu";
-    case DW_OP_consts:
-      return "DW_OP_consts";
-    case DW_OP_dup:
-      return "DW_OP_dup";
-    case DW_OP_drop:
-      return "DW_OP_drop";
-    case DW_OP_over:
-      return "DW_OP_over";
-    case DW_OP_pick:
-      return "DW_OP_pick";
-    case DW_OP_swap:
-      return "DW_OP_swap";
-    case DW_OP_rot:
-      return "DW_OP_rot";
-    case DW_OP_xderef:
-      return "DW_OP_xderef";
-    case DW_OP_abs:
-      return "DW_OP_abs";
-    case DW_OP_and:
-      return "DW_OP_and";
-    case DW_OP_div:
-      return "DW_OP_div";
-    case DW_OP_minus:
-      return "DW_OP_minus";
-    case DW_OP_mod:
-      return "DW_OP_mod";
-    case DW_OP_mul:
-      return "DW_OP_mul";
-    case DW_OP_neg:
-      return "DW_OP_neg";
-    case DW_OP_not:
-      return "DW_OP_not";
-    case DW_OP_or:
-      return "DW_OP_or";
-    case DW_OP_plus:
-      return "DW_OP_plus";
-    case DW_OP_plus_uconst:
-      return "DW_OP_plus_uconst";
-    case DW_OP_shl:
-      return "DW_OP_shl";
-    case DW_OP_shr:
-      return "DW_OP_shr";
-    case DW_OP_shra:
-      return "DW_OP_shra";
-    case DW_OP_xor:
-      return "DW_OP_xor";
-    case DW_OP_bra:
-      return "DW_OP_bra";
-    case DW_OP_eq:
-      return "DW_OP_eq";
-    case DW_OP_ge:
-      return "DW_OP_ge";
-    case DW_OP_gt:
-      return "DW_OP_gt";
-    case DW_OP_le:
-      return "DW_OP_le";
-    case DW_OP_lt:
-      return "DW_OP_lt";
-    case DW_OP_ne:
-      return "DW_OP_ne";
-    case DW_OP_skip:
-      return "DW_OP_skip";
-    case DW_OP_lit0:
-      return "DW_OP_lit0";
-    case DW_OP_lit1:
-      return "DW_OP_lit1";
-    case DW_OP_lit2:
-      return "DW_OP_lit2";
-    case DW_OP_lit3:
-      return "DW_OP_lit3";
-    case DW_OP_lit4:
-      return "DW_OP_lit4";
-    case DW_OP_lit5:
-      return "DW_OP_lit5";
-    case DW_OP_lit6:
-      return "DW_OP_lit6";
-    case DW_OP_lit7:
-      return "DW_OP_lit7";
-    case DW_OP_lit8:
-      return "DW_OP_lit8";
-    case DW_OP_lit9:
-      return "DW_OP_lit9";
-    case DW_OP_lit10:
-      return "DW_OP_lit10";
-    case DW_OP_lit11:
-      return "DW_OP_lit11";
-    case DW_OP_lit12:
-      return "DW_OP_lit12";
-    case DW_OP_lit13:
-      return "DW_OP_lit13";
-    case DW_OP_lit14:
-      return "DW_OP_lit14";
-    case DW_OP_lit15:
-      return "DW_OP_lit15";
-    case DW_OP_lit16:
-      return "DW_OP_lit16";
-    case DW_OP_lit17:
-      return "DW_OP_lit17";
-    case DW_OP_lit18:
-      return "DW_OP_lit18";
-    case DW_OP_lit19:
-      return "DW_OP_lit19";
-    case DW_OP_lit20:
-      return "DW_OP_lit20";
-    case DW_OP_lit21:
-      return "DW_OP_lit21";
-    case DW_OP_lit22:
-      return "DW_OP_lit22";
-    case DW_OP_lit23:
-      return "DW_OP_lit23";
-    case DW_OP_lit24:
-      return "DW_OP_lit24";
-    case DW_OP_lit25:
-      return "DW_OP_lit25";
-    case DW_OP_lit26:
-      return "DW_OP_lit26";
-    case DW_OP_lit27:
-      return "DW_OP_lit27";
-    case DW_OP_lit28:
-      return "DW_OP_lit28";
-    case DW_OP_lit29:
-      return "DW_OP_lit29";
-    case DW_OP_lit30:
-      return "DW_OP_lit30";
-    case DW_OP_lit31:
-      return "DW_OP_lit31";
-    case DW_OP_reg0:
-      return "DW_OP_reg0";
-    case DW_OP_reg1:
-      return "DW_OP_reg1";
-    case DW_OP_reg2:
-      return "DW_OP_reg2";
-    case DW_OP_reg3:
-      return "DW_OP_reg3";
-    case DW_OP_reg4:
-      return "DW_OP_reg4";
-    case DW_OP_reg5:
-      return "DW_OP_reg5";
-    case DW_OP_reg6:
-      return "DW_OP_reg6";
-    case DW_OP_reg7:
-      return "DW_OP_reg7";
-    case DW_OP_reg8:
-      return "DW_OP_reg8";
-    case DW_OP_reg9:
-      return "DW_OP_reg9";
-    case DW_OP_reg10:
-      return "DW_OP_reg10";
-    case DW_OP_reg11:
-      return "DW_OP_reg11";
-    case DW_OP_reg12:
-      return "DW_OP_reg12";
-    case DW_OP_reg13:
-      return "DW_OP_reg13";
-    case DW_OP_reg14:
-      return "DW_OP_reg14";
-    case DW_OP_reg15:
-      return "DW_OP_reg15";
-    case DW_OP_reg16:
-      return "DW_OP_reg16";
-    case DW_OP_reg17:
-      return "DW_OP_reg17";
-    case DW_OP_reg18:
-      return "DW_OP_reg18";
-    case DW_OP_reg19:
-      return "DW_OP_reg19";
-    case DW_OP_reg20:
-      return "DW_OP_reg20";
-    case DW_OP_reg21:
-      return "DW_OP_reg21";
-    case DW_OP_reg22:
-      return "DW_OP_reg22";
-    case DW_OP_reg23:
-      return "DW_OP_reg23";
-    case DW_OP_reg24:
-      return "DW_OP_reg24";
-    case DW_OP_reg25:
-      return "DW_OP_reg25";
-    case DW_OP_reg26:
-      return "DW_OP_reg26";
-    case DW_OP_reg27:
-      return "DW_OP_reg27";
-    case DW_OP_reg28:
-      return "DW_OP_reg28";
-    case DW_OP_reg29:
-      return "DW_OP_reg29";
-    case DW_OP_reg30:
-      return "DW_OP_reg30";
-    case DW_OP_reg31:
-      return "DW_OP_reg31";
-    case DW_OP_breg0:
-      return "DW_OP_breg0";
-    case DW_OP_breg1:
-      return "DW_OP_breg1";
-    case DW_OP_breg2:
-      return "DW_OP_breg2";
-    case DW_OP_breg3:
-      return "DW_OP_breg3";
-    case DW_OP_breg4:
-      return "DW_OP_breg4";
-    case DW_OP_breg5:
-      return "DW_OP_breg5";
-    case DW_OP_breg6:
-      return "DW_OP_breg6";
-    case DW_OP_breg7:
-      return "DW_OP_breg7";
-    case DW_OP_breg8:
-      return "DW_OP_breg8";
-    case DW_OP_breg9:
-      return "DW_OP_breg9";
-    case DW_OP_breg10:
-      return "DW_OP_breg10";
-    case DW_OP_breg11:
-      return "DW_OP_breg11";
-    case DW_OP_breg12:
-      return "DW_OP_breg12";
-    case DW_OP_breg13:
-      return "DW_OP_breg13";
-    case DW_OP_breg14:
-      return "DW_OP_breg14";
-    case DW_OP_breg15:
-      return "DW_OP_breg15";
-    case DW_OP_breg16:
-      return "DW_OP_breg16";
-    case DW_OP_breg17:
-      return "DW_OP_breg17";
-    case DW_OP_breg18:
-      return "DW_OP_breg18";
-    case DW_OP_breg19:
-      return "DW_OP_breg19";
-    case DW_OP_breg20:
-      return "DW_OP_breg20";
-    case DW_OP_breg21:
-      return "DW_OP_breg21";
-    case DW_OP_breg22:
-      return "DW_OP_breg22";
-    case DW_OP_breg23:
-      return "DW_OP_breg23";
-    case DW_OP_breg24:
-      return "DW_OP_breg24";
-    case DW_OP_breg25:
-      return "DW_OP_breg25";
-    case DW_OP_breg26:
-      return "DW_OP_breg26";
-    case DW_OP_breg27:
-      return "DW_OP_breg27";
-    case DW_OP_breg28:
-      return "DW_OP_breg28";
-    case DW_OP_breg29:
-      return "DW_OP_breg29";
-    case DW_OP_breg30:
-      return "DW_OP_breg30";
-    case DW_OP_breg31:
-      return "DW_OP_breg31";
-    case DW_OP_regx:
-      return "DW_OP_regx";
-    case DW_OP_fbreg:
-      return "DW_OP_fbreg";
-    case DW_OP_bregx:
-      return "DW_OP_bregx";
-    case DW_OP_piece:
-      return "DW_OP_piece";
-    case DW_OP_deref_size:
-      return "DW_OP_deref_size";
-    case DW_OP_xderef_size:
-      return "DW_OP_xderef_size";
-    case DW_OP_nop:
-      return "DW_OP_nop";
-    default:
-      return "OP_<unknown>";
-    }
-}
-
-static char *
-dwarf_bool_name (mybool)
-     unsigned mybool;
-{
-  if (mybool)
-    return "TRUE";
-  else
-    return "FALSE";
-}
-
-/* Convert a DWARF type code into its string name.  */
-
-static char *
-dwarf_type_encoding_name (enc)
-     register unsigned enc;
-{
-  switch (enc)
-    {
-    case DW_ATE_address:
-      return "DW_ATE_address";
-    case DW_ATE_boolean:
-      return "DW_ATE_boolean";
-    case DW_ATE_complex_float:
-      return "DW_ATE_complex_float";
-    case DW_ATE_float:
-      return "DW_ATE_float";
-    case DW_ATE_signed:
-      return "DW_ATE_signed";
-    case DW_ATE_signed_char:
-      return "DW_ATE_signed_char";
-    case DW_ATE_unsigned:
-      return "DW_ATE_unsigned";
-    case DW_ATE_unsigned_char:
-      return "DW_ATE_unsigned_char";
-    default:
-      return "DW_ATE_<unknown>";
-    }
-}
-
-/* Convert a DWARF call frame info operation to its string name. */
-
-#if 0
-static char *
-dwarf_cfi_name (cfi_opc)
-     register unsigned cfi_opc;
-{
-  switch (cfi_opc)
-    {
-    case DW_CFA_advance_loc:
-      return "DW_CFA_advance_loc";
-    case DW_CFA_offset:
-      return "DW_CFA_offset";
-    case DW_CFA_restore:
-      return "DW_CFA_restore";
-    case DW_CFA_nop:
-      return "DW_CFA_nop";
-    case DW_CFA_set_loc:
-      return "DW_CFA_set_loc";
-    case DW_CFA_advance_loc1:
-      return "DW_CFA_advance_loc1";
-    case DW_CFA_advance_loc2:
-      return "DW_CFA_advance_loc2";
-    case DW_CFA_advance_loc4:
-      return "DW_CFA_advance_loc4";
-    case DW_CFA_offset_extended:
-      return "DW_CFA_offset_extended";
-    case DW_CFA_restore_extended:
-      return "DW_CFA_restore_extended";
-    case DW_CFA_undefined:
-      return "DW_CFA_undefined";
-    case DW_CFA_same_value:
-      return "DW_CFA_same_value";
-    case DW_CFA_register:
-      return "DW_CFA_register";
-    case DW_CFA_remember_state:
-      return "DW_CFA_remember_state";
-    case DW_CFA_restore_state:
-      return "DW_CFA_restore_state";
-    case DW_CFA_def_cfa:
-      return "DW_CFA_def_cfa";
-    case DW_CFA_def_cfa_register:
-      return "DW_CFA_def_cfa_register";
-    case DW_CFA_def_cfa_offset:
-      return "DW_CFA_def_cfa_offset";
-      /* SGI/MIPS specific */
-    case DW_CFA_MIPS_advance_loc8:
-      return "DW_CFA_MIPS_advance_loc8";
-    default:
-      return "DW_CFA_<unknown>";
-    }
-}
-#endif
-
-void
-dump_die (die)
-     struct die_info *die;
-{
-  unsigned int i;
-
-  fprintf (stderr, "Die: %s (abbrev = %d, offset = %d)\n",
-	   dwarf_tag_name (die->tag), die->abbrev, die->offset);
-  fprintf (stderr, "\thas children: %s\n",
-	   dwarf_bool_name (die->has_children));
-
-  fprintf (stderr, "\tattributes:\n");
-  for (i = 0; i < die->num_attrs; ++i)
-    {
-      fprintf (stderr, "\t\t%s (%s) ",
-	       dwarf_attr_name (die->attrs[i].name),
-	       dwarf_form_name (die->attrs[i].form));
-      switch (die->attrs[i].form)
-	{
-	case DW_FORM_ref_addr:
-	case DW_FORM_addr:
-	  fprintf (stderr, "address: ");
-	  print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
-	  break;
-	case DW_FORM_block2:
-	case DW_FORM_block4:
-	case DW_FORM_block:
-	case DW_FORM_block1:
-	  fprintf (stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
-	  break;
-	case DW_FORM_data1:
-	case DW_FORM_data2:
-	case DW_FORM_data4:
-	case DW_FORM_ref1:
-	case DW_FORM_ref2:
-	case DW_FORM_ref4:
-	case DW_FORM_udata:
-	case DW_FORM_sdata:
-	  fprintf (stderr, "constant: %d", DW_UNSND (&die->attrs[i]));
-	  break;
-	case DW_FORM_string:
-	  fprintf (stderr, "string: \"%s\"",
-		   DW_STRING (&die->attrs[i])
-		     ? DW_STRING (&die->attrs[i]) : "");
-	  break;
-	case DW_FORM_flag:
-	  if (DW_UNSND (&die->attrs[i]))
-	    fprintf (stderr, "flag: TRUE");
-	  else
-	    fprintf (stderr, "flag: FALSE");
-	  break;
-	case DW_FORM_strp:	/* we do not support separate string
-				   section yet */
-	case DW_FORM_indirect:	/* we do not handle indirect yet */
-	case DW_FORM_data8:	/* we do not have 64 bit quantities */
-	default:
-	  fprintf (stderr, "unsupported attribute form: %d.",
-			   die->attrs[i].form);
-	}
-      fprintf (stderr, "\n");
-    }
-}
-
-void
-dump_die_list (die)
-     struct die_info *die;
-{
-  while (die)
-    {
-      dump_die (die);
-      die = die->next;
-    }
-}
-
-void
-store_in_ref_table (offset, die)
-     unsigned int offset;
-     struct die_info *die;
-{
-  int h;
-  struct die_info *old;
-
-  h = (offset % REF_HASH_SIZE);
-  old = die_ref_table[h];
-  die->next_ref = old;
-  die_ref_table[h] = die;
-}
-
-
-static void
-dwarf2_empty_die_ref_table ()
-{
-  memset (die_ref_table, 0, sizeof (die_ref_table));
-}
-
-static unsigned int
-dwarf2_get_ref_die_offset (attr)
-     struct attribute *attr;
-{
-  unsigned int result = 0;
-
-  switch (attr->form)
-    {
-    case DW_FORM_ref_addr:
-      result = DW_ADDR (attr);
-      break;
-    case DW_FORM_ref1:
-    case DW_FORM_ref2:
-    case DW_FORM_ref4:
-    case DW_FORM_ref_udata:
-      result = cu_header_offset + DW_UNSND (attr);
-      break;
-    default:
-      complain (&dwarf2_unsupported_die_ref_attr, dwarf_form_name (attr->form));
-    }
-  return result;
-}
-
-struct die_info *
-follow_die_ref (offset)
-     unsigned int offset;
-{
-  struct die_info *die;
-  int h;
-
-  h = (offset % REF_HASH_SIZE);
-  die = die_ref_table[h];
-  while (die)
-    {
-      if (die->offset == offset)
-	{
-	  return die;
-	}
-      die = die->next_ref;
-    }
-  return NULL;
-}
-
-static struct type *
-dwarf2_fundamental_type (objfile, typeid)
-     struct objfile *objfile;
-     int typeid;
-{
-  if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
-    {
-      error ("Dwarf Error: internal error - invalid fundamental type id %d.",
-	     typeid);
-    }
-
-  /* Look for this particular type in the fundamental type vector.  If
-     one is not found, create and install one appropriate for the
-     current language and the current target machine. */
-
-  if (ftypes[typeid] == NULL)
-    {
-      ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);
-    }
-
-  return (ftypes[typeid]);
-}
-
-/* Decode simple location descriptions.
-   Given a pointer to a dwarf block that defines a location, compute
-   the location and return the value.
-
-   FIXME: This is a kludge until we figure out a better
-   way to handle the location descriptions.
-   Gdb's design does not mesh well with the DWARF2 notion of a location
-   computing interpreter, which is a shame because the flexibility goes unused.
-   FIXME: Implement more operations as necessary.
-
-   A location description containing no operations indicates that the
-   object is optimized out. The global optimized_out flag is set for
-   those, the return value is meaningless.
-
-   When the result is a register number, the global isreg flag is set,
-   otherwise it is cleared.
-
-   When the result is a base register offset, the global offreg flag is set
-   and the register number is returned in basereg, otherwise it is cleared.
-
-   When the DW_OP_fbreg operation is encountered without a corresponding
-   DW_AT_frame_base attribute, the global islocal flag is set.
-   Hopefully the machine dependent code knows how to set up a virtual
-   frame pointer for the local references.
- 
-   Note that stack[0] is unused except as a default error return.
-   Note that stack overflow is not yet handled.  */
-
-static CORE_ADDR
-decode_locdesc (blk, objfile)
-     struct dwarf_block *blk;
-     struct objfile *objfile;
-{
-  int i;
-  int size = blk->size;
-  char *data = blk->data;
-  CORE_ADDR stack[64];
-  int stacki;
-  unsigned int bytes_read, unsnd;
-  unsigned char op;
-
-  i = 0;
-  stacki = 0;
-  stack[stacki] = 0;
-  isreg = 0;
-  offreg = 0;
-  islocal = 0;
-  optimized_out = 1;
-
-  while (i < size)
-    {
-      optimized_out = 0;
-      op = data[i++];
-      switch (op)
-	{
-	case DW_OP_reg0:
-	case DW_OP_reg1:
-	case DW_OP_reg2:
-	case DW_OP_reg3:
-	case DW_OP_reg4:
-	case DW_OP_reg5:
-	case DW_OP_reg6:
-	case DW_OP_reg7:
-	case DW_OP_reg8:
-	case DW_OP_reg9:
-	case DW_OP_reg10:
-	case DW_OP_reg11:
-	case DW_OP_reg12:
-	case DW_OP_reg13:
-	case DW_OP_reg14:
-	case DW_OP_reg15:
-	case DW_OP_reg16:
-	case DW_OP_reg17:
-	case DW_OP_reg18:
-	case DW_OP_reg19:
-	case DW_OP_reg20:
-	case DW_OP_reg21:
-	case DW_OP_reg22:
-	case DW_OP_reg23:
-	case DW_OP_reg24:
-	case DW_OP_reg25:
-	case DW_OP_reg26:
-	case DW_OP_reg27:
-	case DW_OP_reg28:
-	case DW_OP_reg29:
-	case DW_OP_reg30:
-	case DW_OP_reg31:
-	  isreg = 1;
-	  stack[++stacki] = op - DW_OP_reg0;
-	  break;
-
-	case DW_OP_regx:
-	  isreg = 1;
-	  unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
-	  i += bytes_read;
-#if defined(HARRIS_TARGET) && defined(_M88K)
-	  /* The Harris 88110 gdb ports have long kept their special reg
-	     numbers between their gp-regs and their x-regs.  This is
-	     not how our dwarf is generated.  Punt. */
-	  unsnd += 6;
-#endif
-	  stack[++stacki] = unsnd;
-	  break;
-
-	case DW_OP_breg0:
-	case DW_OP_breg1:
-	case DW_OP_breg2:
-	case DW_OP_breg3:
-	case DW_OP_breg4:
-	case DW_OP_breg5:
-	case DW_OP_breg6:
-	case DW_OP_breg7:
-	case DW_OP_breg8:
-	case DW_OP_breg9:
-	case DW_OP_breg10:
-	case DW_OP_breg11:
-	case DW_OP_breg12:
-	case DW_OP_breg13:
-	case DW_OP_breg14:
-	case DW_OP_breg15:
-	case DW_OP_breg16:
-	case DW_OP_breg17:
-	case DW_OP_breg18:
-	case DW_OP_breg19:
-	case DW_OP_breg20:
-	case DW_OP_breg21:
-	case DW_OP_breg22:
-	case DW_OP_breg23:
-	case DW_OP_breg24:
-	case DW_OP_breg25:
-	case DW_OP_breg26:
-	case DW_OP_breg27:
-	case DW_OP_breg28:
-	case DW_OP_breg29:
-	case DW_OP_breg30:
-	case DW_OP_breg31:
-	  offreg = 1;
-	  basereg = op - DW_OP_breg0;
-	  stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
-	  i += bytes_read;
-	  break;
-
-	case DW_OP_fbreg:
-	  stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
-	  i += bytes_read;
-	  if (frame_base_reg >= 0)
-	    {
-	      offreg = 1;
-	      basereg = frame_base_reg;
-	      stack[stacki] += frame_base_offset;
-	    }
-	  else
-	    {
-	      complain (&dwarf2_missing_at_frame_base);
-	      islocal = 1;
-	    }
-	  break;
-
-	case DW_OP_addr:
-	  stack[++stacki] = read_address (objfile->obfd, &data[i]);
-	  i += address_size;
-	  break;
-
-	case DW_OP_const1u:
-	  stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
-	  i += 1;
-	  break;
-
-	case DW_OP_const1s:
-	  stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
-	  i += 1;
-	  break;
-
-	case DW_OP_const2u:
-	  stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
-	  i += 2;
-	  break;
-
-	case DW_OP_const2s:
-	  stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
-	  i += 2;
-	  break;
-
-	case DW_OP_const4u:
-	  stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
-	  i += 4;
-	  break;
-
-	case DW_OP_const4s:
-	  stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
-	  i += 4;
-	  break;
-
-	case DW_OP_constu:
-	  stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
-							 &bytes_read);
-	  i += bytes_read;
-	  break;
-
-	case DW_OP_consts:
-	  stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
-	  i += bytes_read;
-	  break;
-
-	case DW_OP_plus:
-	  stack[stacki - 1] += stack[stacki];
-	  stacki--;
-	  break;
-
-	case DW_OP_plus_uconst:
-	  stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
-	  i += bytes_read;
-	  break;
-
-	case DW_OP_minus:
-	  stack[stacki - 1] = stack[stacki] - stack[stacki - 1];
-	  stacki--;
-	  break;
-
-	default:
-	  complain (&dwarf2_unsupported_stack_op, dwarf_stack_op_name(op));
-	  return (stack[stacki]);
-	}
-    }
-  return (stack[stacki]);
-}
-
-/* memory allocation interface */
-
-/* ARGSUSED */
-static void
-dwarf2_free_tmp_obstack (ignore)
-     PTR ignore;
-{
-  obstack_free (&dwarf2_tmp_obstack, NULL);
-}
-
-static struct dwarf_block *
-dwarf_alloc_block ()
-{
-  struct dwarf_block *blk;
-
-  blk = (struct dwarf_block *)
-    obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct dwarf_block));
-  return (blk);
-}
-
-static struct abbrev_info *
-dwarf_alloc_abbrev ()
-{
-  struct abbrev_info *abbrev;
-
-  abbrev = (struct abbrev_info *) xmalloc (sizeof (struct abbrev_info));
-  memset (abbrev, 0, sizeof (struct abbrev_info));
-  return (abbrev);
-}
-
-static struct die_info *
-dwarf_alloc_die ()
-{
-  struct die_info *die;
-
-  die = (struct die_info *) xmalloc (sizeof (struct die_info));
-  memset (die, 0, sizeof (struct die_info));
-  return (die);
-}