gdb/dwarf2read.c

   1 /* DWARF 2 debugging format support for GDB.
   2    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3    2004
   4    Free Software Foundation, Inc.
   5
   6    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
   7    Inc.  with support from Florida State University (under contract
   8    with the Ada Joint Program Office), and Silicon Graphics, Inc.
   9    Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
  10    based on Fred Fish's (Cygnus Support) implementation of DWARF 1
  11    support in dwarfread.c
  12
  13    This file is part of GDB.
  14
  15    This program is free software; you can redistribute it and/or modify
  16    it under the terms of the GNU General Public License as published by
  17    the Free Software Foundation; either version 2 of the License, or (at
  18    your option) any later version.
  19
  20    This program is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program; if not, write to the Free Software
  27    Foundation, Inc., 59 Temple Place - Suite 330,
  28    Boston, MA 02111-1307, USA.  */
  29
  30 #include "defs.h"
  31 #include "bfd.h"
  32 #include "symtab.h"
  33 #include "gdbtypes.h"
  34 #include "objfiles.h"
  35 #include "elf/dwarf2.h"
  36 #include "buildsym.h"
  37 #include "demangle.h"
  38 #include "expression.h"
  39 #include "filenames.h"  /* for DOSish file names */
  40 #include "macrotab.h"
  41 #include "language.h"
  42 #include "complaints.h"
  43 #include "bcache.h"
  44 #include "dwarf2expr.h"
  45 #include "dwarf2loc.h"
  46 #include "cp-support.h"
  47 #include "hashtab.h"
  48
  49 #include <fcntl.h>
  50 #include "gdb_string.h"
  51 #include "gdb_assert.h"
  52 #include <sys/types.h>
  53
  54 /* A note on memory usage for this file.
  55
  56    At the present time, this code reads the debug info sections into
  57    the objfile's objfile_obstack.  A definite improvement for startup
  58    time, on platforms which do not emit relocations for debug
  59    sections, would be to use mmap instead.  The object's complete
  60    debug information is loaded into memory, partly to simplify
  61    absolute DIE references.
  62
  63    Whether using obstacks or mmap, the sections should remain loaded
  64    until the objfile is released, and pointers into the section data
  65    can be used for any other data associated to the objfile (symbol
  66    names, type names, location expressions to name a few).  */
  67
  68 #ifndef DWARF2_REG_TO_REGNUM
  69 #define DWARF2_REG_TO_REGNUM(REG) (REG)
  70 #endif
  71
  72 #if 0
  73 /* .debug_info header for a compilation unit
  74    Because of alignment constraints, this structure has padding and cannot
  75    be mapped directly onto the beginning of the .debug_info section.  */
  76 typedef struct comp_unit_header
  77   {
  78     unsigned int length;        /* length of the .debug_info
  79                                    contribution */
  80     unsigned short version;     /* version number -- 2 for DWARF
  81                                    version 2 */
  82     unsigned int abbrev_offset; /* offset into .debug_abbrev section */
  83     unsigned char addr_size;    /* byte size of an address -- 4 */
  84   }
  85 _COMP_UNIT_HEADER;
  86 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
  87 #endif
  88
  89 /* .debug_pubnames header
  90    Because of alignment constraints, this structure has padding and cannot
  91    be mapped directly onto the beginning of the .debug_info section.  */
  92 typedef struct pubnames_header
  93   {
  94     unsigned int length;        /* length of the .debug_pubnames
  95                                    contribution  */
  96     unsigned char version;      /* version number -- 2 for DWARF
  97                                    version 2 */
  98     unsigned int info_offset;   /* offset into .debug_info section */
  99     unsigned int info_size;     /* byte size of .debug_info section
 100                                    portion */
 101   }
 102 _PUBNAMES_HEADER;
 103 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
 104
 105 /* .debug_pubnames header
 106    Because of alignment constraints, this structure has padding and cannot
 107    be mapped directly onto the beginning of the .debug_info section.  */
 108 typedef struct aranges_header
 109   {
 110     unsigned int length;        /* byte len of the .debug_aranges
 111                                    contribution */
 112     unsigned short version;     /* version number -- 2 for DWARF
 113                                    version 2 */
 114     unsigned int info_offset;   /* offset into .debug_info section */
 115     unsigned char addr_size;    /* byte size of an address */
 116     unsigned char seg_size;     /* byte size of segment descriptor */
 117   }
 118 _ARANGES_HEADER;
 119 #define _ACTUAL_ARANGES_HEADER_SIZE 12
 120
 121 /* .debug_line statement program prologue
 122    Because of alignment constraints, this structure has padding and cannot
 123    be mapped directly onto the beginning of the .debug_info section.  */
 124 typedef struct statement_prologue
 125   {
 126     unsigned int total_length;  /* byte length of the statement
 127                                    information */
 128     unsigned short version;     /* version number -- 2 for DWARF
 129                                    version 2 */
 130     unsigned int prologue_length;       /* # bytes between prologue &
 131                                            stmt program */
 132     unsigned char minimum_instruction_length;   /* byte size of
 133                                                    smallest instr */
 134     unsigned char default_is_stmt;      /* initial value of is_stmt
 135                                            register */
 136     char line_base;
 137     unsigned char line_range;
 138     unsigned char opcode_base;  /* number assigned to first special
 139                                    opcode */
 140     unsigned char *standard_opcode_lengths;
 141   }
 142 _STATEMENT_PROLOGUE;
 143
 144 static const struct objfile_data *dwarf2_objfile_data_key;
 145
 146 struct dwarf2_per_objfile
 147 {
 148   /* Sizes of debugging sections.  */
 149   unsigned int info_size;
 150   unsigned int abbrev_size;
 151   unsigned int line_size;
 152   unsigned int pubnames_size;
 153   unsigned int aranges_size;
 154   unsigned int loc_size;
 155   unsigned int macinfo_size;
 156   unsigned int str_size;
 157   unsigned int ranges_size;
 158   unsigned int frame_size;
 159   unsigned int eh_frame_size;
 160
 161   /* Loaded data from the sections.  */
 162   char *info_buffer;
 163   char *abbrev_buffer;
 164   char *line_buffer;
 165   char *str_buffer;
 166   char *macinfo_buffer;
 167   char *ranges_buffer;
 168   char *loc_buffer;
 169 };
 170
 171 static struct dwarf2_per_objfile *dwarf2_per_objfile;
 172
 173 static asection *dwarf_info_section;
 174 static asection *dwarf_abbrev_section;
 175 static asection *dwarf_line_section;
 176 static asection *dwarf_pubnames_section;
 177 static asection *dwarf_aranges_section;
 178 static asection *dwarf_loc_section;
 179 static asection *dwarf_macinfo_section;
 180 static asection *dwarf_str_section;
 181 static asection *dwarf_ranges_section;
 182 asection *dwarf_frame_section;
 183 asection *dwarf_eh_frame_section;
 184
 185 /* names of the debugging sections */
 186
 187 #define INFO_SECTION     ".debug_info"
 188 #define ABBREV_SECTION   ".debug_abbrev"
 189 #define LINE_SECTION     ".debug_line"
 190 #define PUBNAMES_SECTION ".debug_pubnames"
 191 #define ARANGES_SECTION  ".debug_aranges"
 192 #define LOC_SECTION      ".debug_loc"
 193 #define MACINFO_SECTION  ".debug_macinfo"
 194 #define STR_SECTION      ".debug_str"
 195 #define RANGES_SECTION   ".debug_ranges"
 196 #define FRAME_SECTION    ".debug_frame"
 197 #define EH_FRAME_SECTION ".eh_frame"
 198
 199 /* local data types */
 200
 201 /* We hold several abbreviation tables in memory at the same time. */
 202 #ifndef ABBREV_HASH_SIZE
 203 #define ABBREV_HASH_SIZE 121
 204 #endif
 205
 206 /* The data in a compilation unit header, after target2host
 207    translation, looks like this.  */
 208 struct comp_unit_head
 209   {
 210     unsigned long length;
 211     short version;
 212     unsigned int abbrev_offset;
 213     unsigned char addr_size;
 214     unsigned char signed_addr_p;
 215     unsigned int offset_size;   /* size of file offsets; either 4 or 8 */
 216     unsigned int initial_length_size; /* size of the length field; either
 217                                          4 or 12 */
 218
 219     /* Offset to the first byte of this compilation unit header in the
 220      * .debug_info section, for resolving relative reference dies. */
 221
 222     unsigned int offset;
 223
 224     /* Pointer to this compilation unit header in the .debug_info
 225      * section */
 226
 227     char *cu_head_ptr;
 228
 229     /* Pointer to the first die of this compilatio unit.  This will
 230      * be the first byte following the compilation unit header. */
 231
 232     char *first_die_ptr;
 233
 234     /* Pointer to the next compilation unit header in the program. */
 235
 236     struct comp_unit_head *next;
 237
 238     /* Base address of this compilation unit.  */
 239
 240     CORE_ADDR base_address;
 241
 242     /* Non-zero if base_address has been set.  */
 243
 244     int base_known;
 245   };
 246
 247 /* Internal state when decoding a particular compilation unit.  */
 248 struct dwarf2_cu
 249 {
 250   /* The objfile containing this compilation unit.  */
 251   struct objfile *objfile;
 252
 253   /* The header of the compilation unit.
 254
 255      FIXME drow/2003-11-10: Some of the things from the comp_unit_head
 256      should logically be moved to the dwarf2_cu structure.  */
 257   struct comp_unit_head header;
 258
 259   struct function_range *first_fn, *last_fn, *cached_fn;
 260
 261   /* The language we are debugging.  */
 262   enum language language;
 263   const struct language_defn *language_defn;
 264
 265   /* The generic symbol table building routines have separate lists for
 266      file scope symbols and all all other scopes (local scopes).  So
 267      we need to select the right one to pass to add_symbol_to_list().
 268      We do it by keeping a pointer to the correct list in list_in_scope.
 269
 270      FIXME: The original dwarf code just treated the file scope as the
 271      first local scope, and all other local scopes as nested local
 272      scopes, and worked fine.  Check to see if we really need to
 273      distinguish these in buildsym.c.  */
 274   struct pending **list_in_scope;
 275
 276   /* Maintain an array of referenced fundamental types for the current
 277      compilation unit being read.  For DWARF version 1, we have to construct
 278      the fundamental types on the fly, since no information about the
 279      fundamental types is supplied.  Each such fundamental type is created by
 280      calling a language dependent routine to create the type, and then a
 281      pointer to that type is then placed in the array at the index specified
 282      by it's FT_<TYPENAME> value.  The array has a fixed size set by the
 283      FT_NUM_MEMBERS compile time constant, which is the number of predefined
 284      fundamental types gdb knows how to construct.  */
 285   struct type *ftypes[FT_NUM_MEMBERS];  /* Fundamental types */
 286
 287   /* DWARF abbreviation table associated with this compilation unit.  */
 288   struct abbrev_info **dwarf2_abbrevs;
 289
 290   /* Storage for the abbrev table.  */
 291   struct obstack abbrev_obstack;
 292
 293   /* Hash table holding all the loaded partial DIEs.  */
 294   htab_t partial_dies;
 295
 296   /* Storage for things with the same lifetime as this read-in compilation
 297      unit, including partial DIEs.  */
 298   struct obstack comp_unit_obstack;
 299
 300   /* This flag will be set if this compilation unit includes any
 301      DW_TAG_namespace DIEs.  If we know that there are explicit
 302      DIEs for namespaces, we don't need to try to infer them
 303      from mangled names.  */
 304   unsigned int has_namespace_info : 1;
 305 };
 306
 307 /* The line number information for a compilation unit (found in the
 308    .debug_line section) begins with a "statement program header",
 309    which contains the following information.  */
 310 struct line_header
 311 {
 312   unsigned int total_length;
 313   unsigned short version;
 314   unsigned int header_length;
 315   unsigned char minimum_instruction_length;
 316   unsigned char default_is_stmt;
 317   int line_base;
 318   unsigned char line_range;
 319   unsigned char opcode_base;
 320
 321   /* standard_opcode_lengths[i] is the number of operands for the
 322      standard opcode whose value is i.  This means that
 323      standard_opcode_lengths[0] is unused, and the last meaningful
 324      element is standard_opcode_lengths[opcode_base - 1].  */
 325   unsigned char *standard_opcode_lengths;
 326
 327   /* The include_directories table.  NOTE!  These strings are not
 328      allocated with xmalloc; instead, they are pointers into
 329      debug_line_buffer.  If you try to free them, `free' will get
 330      indigestion.  */
 331   unsigned int num_include_dirs, include_dirs_size;
 332   char **include_dirs;
 333
 334   /* The file_names table.  NOTE!  These strings are not allocated
 335      with xmalloc; instead, they are pointers into debug_line_buffer.
 336      Don't try to free them directly.  */
 337   unsigned int num_file_names, file_names_size;
 338   struct file_entry
 339   {
 340     char *name;
 341     unsigned int dir_index;
 342     unsigned int mod_time;
 343     unsigned int length;
 344     int included_p; /* Non-zero if referenced by the Line Number Program.  */
 345   } *file_names;
 346
 347   /* The start and end of the statement program following this
 348      header.  These point into dwarf2_per_objfile->line_buffer.  */
 349   char *statement_program_start, *statement_program_end;
 350 };
 351
 352 /* When we construct a partial symbol table entry we only
 353    need this much information. */
 354 struct partial_die_info
 355   {
 356     /* Offset of this DIE.  */
 357     unsigned int offset;
 358
 359     /* DWARF-2 tag for this DIE.  */
 360     ENUM_BITFIELD(dwarf_tag) tag : 16;
 361
 362     /* Language code associated with this DIE.  This is only used
 363        for the compilation unit DIE.  */
 364     unsigned int language : 8;
 365
 366     /* Assorted flags describing the data found in this DIE.  */
 367     unsigned int has_children : 1;
 368     unsigned int is_external : 1;
 369     unsigned int is_declaration : 1;
 370     unsigned int has_type : 1;
 371     unsigned int has_specification : 1;
 372     unsigned int has_stmt_list : 1;
 373     unsigned int has_pc_info : 1;
 374
 375     /* Flag set if the SCOPE field of this structure has been
 376        computed.  */
 377     unsigned int scope_set : 1;
 378
 379     /* The name of this DIE.  Normally the value of DW_AT_name, but
 380        sometimes DW_TAG_MIPS_linkage_name or a string computed in some
 381        other fashion.  */
 382     char *name;
 383     char *dirname;
 384
 385     /* The scope to prepend to our children.  This is generally
 386        allocated on the comp_unit_obstack, so will disappear
 387        when this compilation unit leaves the cache.  */
 388     char *scope;
 389
 390     /* The location description associated with this DIE, if any.  */
 391     struct dwarf_block *locdesc;
 392
 393     /* If HAS_PC_INFO, the PC range associated with this DIE.  */
 394     CORE_ADDR lowpc;
 395     CORE_ADDR highpc;
 396
 397     /* Pointer into the info_buffer pointing at the target of
 398        DW_AT_sibling, if any.  */
 399     char *sibling;
 400
 401     /* If HAS_SPECIFICATION, the offset of the DIE referred to by
 402        DW_AT_specification (or DW_AT_abstract_origin or
 403        DW_AT_extension).  */
 404     unsigned int spec_offset;
 405
 406     /* If HAS_STMT_LIST, the offset of the Line Number Information data.  */
 407     unsigned int line_offset;
 408
 409     /* Pointers to this DIE's parent, first child, and next sibling,
 410        if any.  */
 411     struct partial_die_info *die_parent, *die_child, *die_sibling;
 412   };
 413
 414 /* This data structure holds the information of an abbrev. */
 415 struct abbrev_info
 416   {
 417     unsigned int number;        /* number identifying abbrev */
 418     enum dwarf_tag tag;         /* dwarf tag */
 419     unsigned short has_children;                /* boolean */
 420     unsigned short num_attrs;   /* number of attributes */
 421     struct attr_abbrev *attrs;  /* an array of attribute descriptions */
 422     struct abbrev_info *next;   /* next in chain */
 423   };
 424
 425 struct attr_abbrev
 426   {
 427     enum dwarf_attribute name;
 428     enum dwarf_form form;
 429   };
 430
 431 /* This data structure holds a complete die structure. */
 432 struct die_info
 433   {
 434     enum dwarf_tag tag;         /* Tag indicating type of die */
 435     unsigned int abbrev;        /* Abbrev number */
 436     unsigned int offset;        /* Offset in .debug_info section */
 437     unsigned int num_attrs;     /* Number of attributes */
 438     struct attribute *attrs;    /* An array of attributes */
 439     struct die_info *next_ref;  /* Next die in ref hash table */
 440
 441     /* The dies in a compilation unit form an n-ary tree.  PARENT
 442        points to this die's parent; CHILD points to the first child of
 443        this node; and all the children of a given node are chained
 444        together via their SIBLING fields, terminated by a die whose
 445        tag is zero.  */
 446     struct die_info *child;     /* Its first child, if any.  */
 447     struct die_info *sibling;   /* Its next sibling, if any.  */
 448     struct die_info *parent;    /* Its parent, if any.  */
 449
 450     struct type *type;          /* Cached type information */
 451   };
 452
 453 /* Attributes have a name and a value */
 454 struct attribute
 455   {
 456     enum dwarf_attribute name;
 457     enum dwarf_form form;
 458     union
 459       {
 460         char *str;
 461         struct dwarf_block *blk;
 462         unsigned long unsnd;
 463         long int snd;
 464         CORE_ADDR addr;
 465       }
 466     u;
 467   };
 468
 469 struct function_range
 470 {
 471   const char *name;
 472   CORE_ADDR lowpc, highpc;
 473   int seen_line;
 474   struct function_range *next;
 475 };
 476
 477 /* Get at parts of an attribute structure */
 478
 479 #define DW_STRING(attr)    ((attr)->u.str)
 480 #define DW_UNSND(attr)     ((attr)->u.unsnd)
 481 #define DW_BLOCK(attr)     ((attr)->u.blk)
 482 #define DW_SND(attr)       ((attr)->u.snd)
 483 #define DW_ADDR(attr)      ((attr)->u.addr)
 484
 485 /* Blocks are a bunch of untyped bytes. */
 486 struct dwarf_block
 487   {
 488     unsigned int size;
 489     char *data;
 490   };
 491
 492 #ifndef ATTR_ALLOC_CHUNK
 493 #define ATTR_ALLOC_CHUNK 4
 494 #endif
 495
 496 /* A hash table of die offsets for following references.  */
 497 #ifndef REF_HASH_SIZE
 498 #define REF_HASH_SIZE 1021
 499 #endif
 500
 501 static struct die_info *die_ref_table[REF_HASH_SIZE];
 502
 503 /* Allocate fields for structs, unions and enums in this size.  */
 504 #ifndef DW_FIELD_ALLOC_CHUNK
 505 #define DW_FIELD_ALLOC_CHUNK 4
 506 #endif
 507
 508 /* A zeroed version of a partial die for initialization purposes.  */
 509 static struct partial_die_info zeroed_partial_die;
 510
 511 /* FIXME: decode_locdesc sets these variables to describe the location
 512    to the caller.  These ought to be a structure or something.   If
 513    none of the flags are set, the object lives at the address returned
 514    by decode_locdesc.  */
 515
 516 static int isreg;               /* Object lives in register.
 517                                    decode_locdesc's return value is
 518                                    the register number.  */
 519
 520 /* We put a pointer to this structure in the read_symtab_private field
 521    of the psymtab.  */
 522
 523 struct dwarf2_pinfo
 524   {
 525     /* Offset in .debug_info for this compilation unit. */
 526
 527     unsigned long dwarf_info_offset;
 528   };
 529
 530 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
 531 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
 532
 533 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
 534    but this would require a corresponding change in unpack_field_as_long
 535    and friends.  */
 536 static int bits_per_byte = 8;
 537
 538 /* The routines that read and process dies for a C struct or C++ class
 539    pass lists of data member fields and lists of member function fields
 540    in an instance of a field_info structure, as defined below.  */
 541 struct field_info
 542   {
 543     /* List of data member and baseclasses fields. */
 544     struct nextfield
 545       {
 546         struct nextfield *next;
 547         int accessibility;
 548         int virtuality;
 549         struct field field;
 550       }
 551      *fields;
 552
 553     /* Number of fields.  */
 554     int nfields;
 555
 556     /* Number of baseclasses.  */
 557     int nbaseclasses;
 558
 559     /* Set if the accesibility of one of the fields is not public.  */
 560     int non_public_fields;
 561
 562     /* Member function fields array, entries are allocated in the order they
 563        are encountered in the object file.  */
 564     struct nextfnfield
 565       {
 566         struct nextfnfield *next;
 567         struct fn_field fnfield;
 568       }
 569      *fnfields;
 570
 571     /* Member function fieldlist array, contains name of possibly overloaded
 572        member function, number of overloaded member functions and a pointer
 573        to the head of the member function field chain.  */
 574     struct fnfieldlist
 575       {
 576         char *name;
 577         int length;
 578         struct nextfnfield *head;
 579       }
 580      *fnfieldlists;
 581
 582     /* Number of entries in the fnfieldlists array.  */
 583     int nfnfields;
 584   };
 585
 586 /* Various complaints about symbol reading that don't abort the process */
 587
 588 static void
 589 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
 590 {
 591   complaint (&symfile_complaints,
 592              "statement list doesn't fit in .debug_line section");
 593 }
 594
 595 static void
 596 dwarf2_complex_location_expr_complaint (void)
 597 {
 598   complaint (&symfile_complaints, "location expression too complex");
 599 }
 600
 601 static void
 602 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
 603                                               int arg3)
 604 {
 605   complaint (&symfile_complaints,
 606              "const value length mismatch for '%s', got %d, expected %d", arg1,
 607              arg2, arg3);
 608 }
 609
 610 static void
 611 dwarf2_macros_too_long_complaint (void)
 612 {
 613   complaint (&symfile_complaints,
 614              "macro info runs off end of `.debug_macinfo' section");
 615 }
 616
 617 static void
 618 dwarf2_macro_malformed_definition_complaint (const char *arg1)
 619 {
 620   complaint (&symfile_complaints,
 621              "macro debug info contains a malformed macro definition:\n`%s'",
 622              arg1);
 623 }
 624
 625 static void
 626 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
 627 {
 628   complaint (&symfile_complaints,
 629              "invalid attribute class or form for '%s' in '%s'", arg1, arg2);
 630 }
 631
 632 /* local function prototypes */
 633
 634 static void dwarf2_locate_sections (bfd *, asection *, void *);
 635
 636 #if 0
 637 static void dwarf2_build_psymtabs_easy (struct objfile *, int);
 638 #endif
 639
 640 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
 641                                            struct objfile *);
 642
 643 static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,
 644                                            struct partial_die_info *,
 645                                            struct partial_symtab *);
 646
 647 static void dwarf2_build_psymtabs_hard (struct objfile *, int);
 648
 649 static void scan_partial_symbols (struct partial_die_info *,
 650                                   CORE_ADDR *, CORE_ADDR *,
 651                                   struct dwarf2_cu *);
 652
 653 static void add_partial_symbol (struct partial_die_info *,
 654                                 struct dwarf2_cu *);
 655
 656 static int pdi_needs_namespace (enum dwarf_tag tag);
 657
 658 static void add_partial_namespace (struct partial_die_info *pdi,
 659                                    CORE_ADDR *lowpc, CORE_ADDR *highpc,
 660                                    struct dwarf2_cu *cu);
 661
 662 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
 663                                      struct dwarf2_cu *cu);
 664
 665 static char *locate_pdi_sibling (struct partial_die_info *orig_pdi,
 666                                  char *info_ptr,
 667                                  bfd *abfd,
 668                                  struct dwarf2_cu *cu);
 669
 670 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
 671
 672 static void psymtab_to_symtab_1 (struct partial_symtab *);
 673
 674 char *dwarf2_read_section (struct objfile *, asection *);
 675
 676 static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
 677
 678 static void dwarf2_free_abbrev_table (void *);
 679
 680 static struct abbrev_info *peek_die_abbrev (char *, int *, struct dwarf2_cu *);
 681
 682 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
 683                                                  struct dwarf2_cu *);
 684
 685 static struct partial_die_info *load_partial_dies (bfd *, char *, int,
 686                                                    struct dwarf2_cu *);
 687
 688 static char *read_partial_die (struct partial_die_info *,
 689                                struct abbrev_info *abbrev, unsigned int,
 690                                bfd *, char *, struct dwarf2_cu *);
 691
 692 static struct partial_die_info *find_partial_die (unsigned long,
 693                                                   struct dwarf2_cu *,
 694                                                   struct dwarf2_cu **);
 695
 696 static void fixup_partial_die (struct partial_die_info *,
 697                                struct dwarf2_cu *);
 698
 699 static char *read_full_die (struct die_info **, bfd *, char *,
 700                             struct dwarf2_cu *, int *);
 701
 702 static char *read_attribute (struct attribute *, struct attr_abbrev *,
 703                              bfd *, char *, struct dwarf2_cu *);
 704
 705 static char *read_attribute_value (struct attribute *, unsigned,
 706                              bfd *, char *, struct dwarf2_cu *);
 707
 708 static unsigned int read_1_byte (bfd *, char *);
 709
 710 static int read_1_signed_byte (bfd *, char *);
 711
 712 static unsigned int read_2_bytes (bfd *, char *);
 713
 714 static unsigned int read_4_bytes (bfd *, char *);
 715
 716 static unsigned long read_8_bytes (bfd *, char *);
 717
 718 static CORE_ADDR read_address (bfd *, char *ptr, struct dwarf2_cu *,
 719                                int *bytes_read);
 720
 721 static LONGEST read_initial_length (bfd *, char *,
 722                                     struct comp_unit_head *, int *bytes_read);
 723
 724 static LONGEST read_offset (bfd *, char *, const struct comp_unit_head *,
 725                             int *bytes_read);
 726
 727 static char *read_n_bytes (bfd *, char *, unsigned int);
 728
 729 static char *read_string (bfd *, char *, unsigned int *);
 730
 731 static char *read_indirect_string (bfd *, char *, const struct comp_unit_head *,
 732                                    unsigned int *);
 733
 734 static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *);
 735
 736 static long read_signed_leb128 (bfd *, char *, unsigned int *);
 737
 738 static char *skip_leb128 (bfd *, char *);
 739
 740 static void set_cu_language (unsigned int, struct dwarf2_cu *);
 741
 742 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
 743                                       struct dwarf2_cu *);
 744
 745 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
 746                                struct dwarf2_cu *cu);
 747
 748 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
 749
 750 static struct die_info *die_specification (struct die_info *die,
 751                                            struct dwarf2_cu *);
 752
 753 static void free_line_header (struct line_header *lh);
 754
 755 static void add_file_name (struct line_header *, char *, unsigned int,
 756                            unsigned int, unsigned int);
 757
 758 static struct line_header *(dwarf_decode_line_header
 759                             (unsigned int offset,
 760                              bfd *abfd, struct dwarf2_cu *cu));
 761
 762 static void dwarf_decode_lines (struct line_header *, char *, bfd *,
 763                                 struct dwarf2_cu *, struct partial_symtab *);
 764
 765 static void dwarf2_start_subfile (char *, char *);
 766
 767 static struct symbol *new_symbol (struct die_info *, struct type *,
 768                                   struct dwarf2_cu *);
 769
 770 static void dwarf2_const_value (struct attribute *, struct symbol *,
 771                                 struct dwarf2_cu *);
 772
 773 static void dwarf2_const_value_data (struct attribute *attr,
 774                                      struct symbol *sym,
 775                                      int bits);
 776
 777 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
 778
 779 static struct type *die_containing_type (struct die_info *,
 780                                          struct dwarf2_cu *);
 781
 782 #if 0
 783 static struct type *type_at_offset (unsigned int, struct objfile *);
 784 #endif
 785
 786 static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
 787
 788 static void read_type_die (struct die_info *, struct dwarf2_cu *);
 789
 790 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
 791
 792 static char *typename_concat (const char *prefix, const char *suffix);
 793
 794 static void read_typedef (struct die_info *, struct dwarf2_cu *);
 795
 796 static void read_base_type (struct die_info *, struct dwarf2_cu *);
 797
 798 static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu);
 799
 800 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
 801
 802 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
 803
 804 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
 805
 806 static int dwarf2_get_pc_bounds (struct die_info *,
 807                                  CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *);
 808
 809 static void get_scope_pc_bounds (struct die_info *,
 810                                  CORE_ADDR *, CORE_ADDR *,
 811                                  struct dwarf2_cu *);
 812
 813 static void dwarf2_add_field (struct field_info *, struct die_info *,
 814                               struct dwarf2_cu *);
 815
 816 static void dwarf2_attach_fields_to_type (struct field_info *,
 817                                           struct type *, struct dwarf2_cu *);
 818
 819 static void dwarf2_add_member_fn (struct field_info *,
 820                                   struct die_info *, struct type *,
 821                                   struct dwarf2_cu *);
 822
 823 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
 824                                              struct type *, struct dwarf2_cu *);
 825
 826 static void read_structure_type (struct die_info *, struct dwarf2_cu *);
 827
 828 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
 829
 830 static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu);
 831
 832 static void read_common_block (struct die_info *, struct dwarf2_cu *);
 833
 834 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
 835
 836 static const char *namespace_name (struct die_info *die,
 837                                    int *is_anonymous, struct dwarf2_cu *);
 838
 839 static void read_enumeration_type (struct die_info *, struct dwarf2_cu *);
 840
 841 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
 842
 843 static struct type *dwarf_base_type (int, int, struct dwarf2_cu *);
 844
 845 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
 846
 847 static void read_array_type (struct die_info *, struct dwarf2_cu *);
 848
 849 static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *);
 850
 851 static void read_tag_ptr_to_member_type (struct die_info *,
 852                                          struct dwarf2_cu *);
 853
 854 static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *);
 855
 856 static void read_tag_const_type (struct die_info *, struct dwarf2_cu *);
 857
 858 static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *);
 859
 860 static void read_tag_string_type (struct die_info *, struct dwarf2_cu *);
 861
 862 static void read_subroutine_type (struct die_info *, struct dwarf2_cu *);
 863
 864 static struct die_info *read_comp_unit (char *, bfd *, struct dwarf2_cu *);
 865
 866 static struct die_info *read_die_and_children (char *info_ptr, bfd *abfd,
 867                                                struct dwarf2_cu *,
 868                                                char **new_info_ptr,
 869                                                struct die_info *parent);
 870
 871 static struct die_info *read_die_and_siblings (char *info_ptr, bfd *abfd,
 872                                                struct dwarf2_cu *,
 873                                                char **new_info_ptr,
 874                                                struct die_info *parent);
 875
 876 static void free_die_list (struct die_info *);
 877
 878 static struct cleanup *make_cleanup_free_die_list (struct die_info *);
 879
 880 static void process_die (struct die_info *, struct dwarf2_cu *);
 881
 882 static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
 883
 884 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
 885
 886 static struct die_info *dwarf2_extension (struct die_info *die,
 887                                           struct dwarf2_cu *);
 888
 889 static char *dwarf_tag_name (unsigned int);
 890
 891 static char *dwarf_attr_name (unsigned int);
 892
 893 static char *dwarf_form_name (unsigned int);
 894
 895 static char *dwarf_stack_op_name (unsigned int);
 896
 897 static char *dwarf_bool_name (unsigned int);
 898
 899 static char *dwarf_type_encoding_name (unsigned int);
 900
 901 #if 0
 902 static char *dwarf_cfi_name (unsigned int);
 903
 904 struct die_info *copy_die (struct die_info *);
 905 #endif
 906
 907 static struct die_info *sibling_die (struct die_info *);
 908
 909 static void dump_die (struct die_info *);
 910
 911 static void dump_die_list (struct die_info *);
 912
 913 static void store_in_ref_table (unsigned int, struct die_info *);
 914
 915 static void dwarf2_empty_hash_tables (void);
 916
 917 static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
 918                                                struct dwarf2_cu *);
 919
 920 static int dwarf2_get_attr_constant_value (struct attribute *, int);
 921
 922 static struct die_info *follow_die_ref (unsigned int);
 923
 924 static struct type *dwarf2_fundamental_type (struct objfile *, int,
 925                                              struct dwarf2_cu *);
 926
 927 /* memory allocation interface */
 928
 929 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
 930
 931 static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
 932
 933 static struct die_info *dwarf_alloc_die (void);
 934
 935 static void initialize_cu_func_list (struct dwarf2_cu *);
 936
 937 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
 938                                  struct dwarf2_cu *);
 939
 940 static void dwarf_decode_macros (struct line_header *, unsigned int,
 941                                  char *, bfd *, struct dwarf2_cu *);
 942
 943 static int attr_form_is_block (struct attribute *);
 944
 945 static void
 946 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
 947                              struct dwarf2_cu *cu);
 948
 949 static char *skip_one_die (char *info_ptr, struct abbrev_info *abbrev,
 950                            struct dwarf2_cu *cu);
 951
 952 static void free_stack_comp_unit (void *);
 953
 954 static void *hashtab_obstack_allocate (void *data, size_t size, size_t count);
 955
 956 static void dummy_obstack_deallocate (void *object, void *data);
 957
 958 static hashval_t partial_die_hash (const void *item);
 959
 960 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
 961
 962 /* Try to locate the sections we need for DWARF 2 debugging
 963    information and return true if we have enough to do something.  */
 964
 965 int
 966 dwarf2_has_info (struct objfile *objfile)
 967 {
 968   struct dwarf2_per_objfile *data;
 969
 970   /* Initialize per-objfile state.  */
 971   data = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
 972   memset (data, 0, sizeof (*data));
 973   set_objfile_data (objfile, dwarf2_objfile_data_key, data);
 974   dwarf2_per_objfile = data;
 975
 976   dwarf_info_section = 0;
 977   dwarf_abbrev_section = 0;
 978   dwarf_line_section = 0;
 979   dwarf_str_section = 0;
 980   dwarf_macinfo_section = 0;
 981   dwarf_frame_section = 0;
 982   dwarf_eh_frame_section = 0;
 983   dwarf_ranges_section = 0;
 984   dwarf_loc_section = 0;
 985
 986   bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL);
 987   return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL);
 988 }
 989
 990 /* This function is mapped across the sections and remembers the
 991    offset and size of each of the debugging sections we are interested
 992    in.  */
 993
 994 static void
 995 dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr)
 996 {
 997   if (strcmp (sectp->name, INFO_SECTION) == 0)
 998     {
 999       dwarf2_per_objfile->info_size = bfd_get_section_size (sectp);
1000       dwarf_info_section = sectp;
1001     }
1002   else if (strcmp (sectp->name, ABBREV_SECTION) == 0)
1003     {
1004       dwarf2_per_objfile->abbrev_size = bfd_get_section_size (sectp);
1005       dwarf_abbrev_section = sectp;
1006     }
1007   else if (strcmp (sectp->name, LINE_SECTION) == 0)
1008     {
1009       dwarf2_per_objfile->line_size = bfd_get_section_size (sectp);
1010       dwarf_line_section = sectp;
1011     }
1012   else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0)
1013     {
1014       dwarf2_per_objfile->pubnames_size = bfd_get_section_size (sectp);
1015       dwarf_pubnames_section = sectp;
1016     }
1017   else if (strcmp (sectp->name, ARANGES_SECTION) == 0)
1018     {
1019       dwarf2_per_objfile->aranges_size = bfd_get_section_size (sectp);
1020       dwarf_aranges_section = sectp;
1021     }
1022   else if (strcmp (sectp->name, LOC_SECTION) == 0)
1023     {
1024       dwarf2_per_objfile->loc_size = bfd_get_section_size (sectp);
1025       dwarf_loc_section = sectp;
1026     }
1027   else if (strcmp (sectp->name, MACINFO_SECTION) == 0)
1028     {
1029       dwarf2_per_objfile->macinfo_size = bfd_get_section_size (sectp);
1030       dwarf_macinfo_section = sectp;
1031     }
1032   else if (strcmp (sectp->name, STR_SECTION) == 0)
1033     {
1034       dwarf2_per_objfile->str_size = bfd_get_section_size (sectp);
1035       dwarf_str_section = sectp;
1036     }
1037   else if (strcmp (sectp->name, FRAME_SECTION) == 0)
1038     {
1039       dwarf2_per_objfile->frame_size = bfd_get_section_size (sectp);
1040       dwarf_frame_section = sectp;
1041     }
1042   else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0)
1043     {
1044       flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1045       if (aflag & SEC_HAS_CONTENTS)
1046         {
1047           dwarf2_per_objfile->eh_frame_size = bfd_get_section_size (sectp);
1048           dwarf_eh_frame_section = sectp;
1049         }
1050     }
1051   else if (strcmp (sectp->name, RANGES_SECTION) == 0)
1052     {
1053       dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp);
1054       dwarf_ranges_section = sectp;
1055     }
1056 }
1057
1058 /* Build a partial symbol table.  */
1059
1060 void
1061 dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1062 {
1063   /* We definitely need the .debug_info and .debug_abbrev sections */
1064
1065   dwarf2_per_objfile->info_buffer = dwarf2_read_section (objfile, dwarf_info_section);
1066   dwarf2_per_objfile->abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section);
1067
1068   if (dwarf_line_section)
1069     dwarf2_per_objfile->line_buffer = dwarf2_read_section (objfile, dwarf_line_section);
1070   else
1071     dwarf2_per_objfile->line_buffer = NULL;
1072
1073   if (dwarf_str_section)
1074     dwarf2_per_objfile->str_buffer = dwarf2_read_section (objfile, dwarf_str_section);
1075   else
1076     dwarf2_per_objfile->str_buffer = NULL;
1077
1078   if (dwarf_macinfo_section)
1079     dwarf2_per_objfile->macinfo_buffer = dwarf2_read_section (objfile,
1080                                                 dwarf_macinfo_section);
1081   else
1082     dwarf2_per_objfile->macinfo_buffer = NULL;
1083
1084   if (dwarf_ranges_section)
1085     dwarf2_per_objfile->ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section);
1086   else
1087     dwarf2_per_objfile->ranges_buffer = NULL;
1088
1089   if (dwarf_loc_section)
1090     dwarf2_per_objfile->loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section);
1091   else
1092     dwarf2_per_objfile->loc_buffer = NULL;
1093
1094   if (mainline
1095       || (objfile->global_psymbols.size == 0
1096           && objfile->static_psymbols.size == 0))
1097     {
1098       init_psymbol_list (objfile, 1024);
1099     }
1100
1101 #if 0
1102   if (dwarf_aranges_offset && dwarf_pubnames_offset)
1103     {
1104       /* Things are significantly easier if we have .debug_aranges and
1105          .debug_pubnames sections */
1106
1107       dwarf2_build_psymtabs_easy (objfile, mainline);
1108     }
1109   else
1110 #endif
1111     /* only test this case for now */
1112     {
1113       /* In this case we have to work a bit harder */
1114       dwarf2_build_psymtabs_hard (objfile, mainline);
1115     }
1116 }
1117
1118 #if 0
1119 /* Build the partial symbol table from the information in the
1120    .debug_pubnames and .debug_aranges sections.  */
1121
1122 static void
1123 dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1124 {
1125   bfd *abfd = objfile->obfd;
1126   char *aranges_buffer, *pubnames_buffer;
1127   char *aranges_ptr, *pubnames_ptr;
1128   unsigned int entry_length, version, info_offset, info_size;
1129
1130   pubnames_buffer = dwarf2_read_section (objfile,
1131                                          dwarf_pubnames_section);
1132   pubnames_ptr = pubnames_buffer;
1133   while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames_size)
1134     {
1135       struct comp_unit_head cu_header;
1136       int bytes_read;
1137
1138       entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1139                                          &bytes_read);
1140       pubnames_ptr += bytes_read;
1141       version = read_1_byte (abfd, pubnames_ptr);
1142       pubnames_ptr += 1;
1143       info_offset = read_4_bytes (abfd, pubnames_ptr);
1144       pubnames_ptr += 4;
1145       info_size = read_4_bytes (abfd, pubnames_ptr);
1146       pubnames_ptr += 4;
1147     }
1148
1149   aranges_buffer = dwarf2_read_section (objfile,
1150                                         dwarf_aranges_section);
1151
1152 }
1153 #endif
1154
1155 /* Read in the comp unit header information from the debug_info at
1156    info_ptr. */
1157
1158 static char *
1159 read_comp_unit_head (struct comp_unit_head *cu_header,
1160                      char *info_ptr, bfd *abfd)
1161 {
1162   int signed_addr;
1163   int bytes_read;
1164   cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1165                                            &bytes_read);
1166   info_ptr += bytes_read;
1167   cu_header->version = read_2_bytes (abfd, info_ptr);
1168   info_ptr += 2;
1169   cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1170                                           &bytes_read);
1171   info_ptr += bytes_read;
1172   cu_header->addr_size = read_1_byte (abfd, info_ptr);
1173   info_ptr += 1;
1174   signed_addr = bfd_get_sign_extend_vma (abfd);
1175   if (signed_addr < 0)
1176     internal_error (__FILE__, __LINE__,
1177                     "read_comp_unit_head: dwarf from non elf file");
1178   cu_header->signed_addr_p = signed_addr;
1179   return info_ptr;
1180 }
1181
1182 static char *
1183 partial_read_comp_unit_head (struct comp_unit_head *header, char *info_ptr,
1184                              bfd *abfd)
1185 {
1186   char *beg_of_comp_unit = info_ptr;
1187
1188   info_ptr = read_comp_unit_head (header, info_ptr, abfd);
1189
1190   if (header->version != 2)
1191     error ("Dwarf Error: wrong version in compilation unit header "
1192            "(is %d, should be %d) [in module %s]", header->version,
1193            2, bfd_get_filename (abfd));
1194
1195   if (header->abbrev_offset >= dwarf2_per_objfile->abbrev_size)
1196     error ("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1197            "(offset 0x%lx + 6) [in module %s]",
1198            (long) header->abbrev_offset,
1199            (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1200            bfd_get_filename (abfd));
1201
1202   if (beg_of_comp_unit + header->length + header->initial_length_size
1203       > dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size)
1204     error ("Dwarf Error: bad length (0x%lx) in compilation unit header "
1205            "(offset 0x%lx + 0) [in module %s]",
1206            (long) header->length,
1207            (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer),
1208            bfd_get_filename (abfd));
1209
1210   return info_ptr;
1211 }
1212
1213 /* Allocate a new partial symtab for file named NAME and mark this new
1214    partial symtab as being an include of PST.  */
1215
1216 static void
1217 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
1218                                struct objfile *objfile)
1219 {
1220   struct partial_symtab *subpst = allocate_psymtab (name, objfile);
1221
1222   subpst->section_offsets = pst->section_offsets;
1223   subpst->textlow = 0;
1224   subpst->texthigh = 0;
1225
1226   subpst->dependencies = (struct partial_symtab **)
1227     obstack_alloc (&objfile->objfile_obstack,
1228                    sizeof (struct partial_symtab *));
1229   subpst->dependencies[0] = pst;
1230   subpst->number_of_dependencies = 1;
1231
1232   subpst->globals_offset = 0;
1233   subpst->n_global_syms = 0;
1234   subpst->statics_offset = 0;
1235   subpst->n_static_syms = 0;
1236   subpst->symtab = NULL;
1237   subpst->read_symtab = pst->read_symtab;
1238   subpst->readin = 0;
1239
1240   /* No private part is necessary for include psymtabs.  This property
1241      can be used to differentiate between such include psymtabs and
1242      the regular ones.  If it ever happens that a regular psymtab can
1243      legitimally have a NULL private part, then we'll have to add a
1244      dedicated field for that in the dwarf2_pinfo structure.  */
1245   subpst->read_symtab_private = NULL;
1246 }
1247
1248 /* Read the Line Number Program data and extract the list of files
1249    included by the source file represented by PST.  Build an include
1250    partial symtab for each of these included files.
1251
1252    This procedure assumes that there *is* a Line Number Program in
1253    the given CU.  Callers should check that PDI->HAS_STMT_LIST is set
1254    before calling this procedure.  */
1255
1256 static void
1257 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
1258                                struct partial_die_info *pdi,
1259                                struct partial_symtab *pst)
1260 {
1261   struct objfile *objfile = cu->objfile;
1262   bfd *abfd = objfile->obfd;
1263   struct line_header *lh;
1264
1265   lh = dwarf_decode_line_header (pdi->line_offset, abfd, cu);
1266   if (lh == NULL)
1267     return;  /* No linetable, so no includes.  */
1268
1269   dwarf_decode_lines (lh, NULL, abfd, cu, pst);
1270
1271   free_line_header (lh);
1272 }
1273
1274
1275 /* Build the partial symbol table by doing a quick pass through the
1276    .debug_info and .debug_abbrev sections.  */
1277
1278 static void
1279 dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1280 {
1281   /* Instead of reading this into a big buffer, we should probably use
1282      mmap()  on architectures that support it. (FIXME) */
1283   bfd *abfd = objfile->obfd;
1284   char *info_ptr;
1285   char *beg_of_comp_unit;
1286   struct partial_die_info comp_unit_die;
1287   struct partial_symtab *pst;
1288   CORE_ADDR lowpc, highpc, baseaddr;
1289
1290   info_ptr = dwarf2_per_objfile->info_buffer;
1291
1292   /* Since the objects we're extracting from .debug_info vary in
1293      length, only the individual functions to extract them (like
1294      read_comp_unit_head and load_partial_die) can really know whether
1295      the buffer is large enough to hold another complete object.
1296
1297      At the moment, they don't actually check that.  If .debug_info
1298      holds just one extra byte after the last compilation unit's dies,
1299      then read_comp_unit_head will happily read off the end of the
1300      buffer.  read_partial_die is similarly casual.  Those functions
1301      should be fixed.
1302
1303      For this loop condition, simply checking whether there's any data
1304      left at all should be sufficient.  */
1305   while (info_ptr < (dwarf2_per_objfile->info_buffer
1306                      + dwarf2_per_objfile->info_size))
1307     {
1308       struct cleanup *back_to_inner;
1309       struct dwarf2_cu cu;
1310       struct abbrev_info *abbrev;
1311       unsigned int bytes_read;
1312       struct dwarf2_per_cu_data *this_cu;
1313
1314       beg_of_comp_unit = info_ptr;
1315
1316       memset (&cu, 0, sizeof (cu));
1317
1318       obstack_init (&cu.comp_unit_obstack);
1319
1320       back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
1321
1322       cu.objfile = objfile;
1323       info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr, abfd);
1324
1325       /* Complete the cu_header */
1326       cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1327       cu.header.first_die_ptr = info_ptr;
1328       cu.header.cu_head_ptr = beg_of_comp_unit;
1329
1330       cu.list_in_scope = &file_symbols;
1331
1332       cu.partial_dies = NULL;
1333
1334       /* Read the abbrevs for this compilation unit into a table */
1335       dwarf2_read_abbrevs (abfd, &cu);
1336       make_cleanup (dwarf2_free_abbrev_table, &cu);
1337
1338       /* Read the compilation unit die */
1339       abbrev = peek_die_abbrev (info_ptr, &bytes_read, &cu);
1340       info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
1341                                    abfd, info_ptr, &cu);
1342
1343       /* Set the language we're debugging */
1344       set_cu_language (comp_unit_die.language, &cu);
1345
1346       /* Allocate a new partial symbol table structure */
1347       pst = start_psymtab_common (objfile, objfile->section_offsets,
1348                                   comp_unit_die.name ? comp_unit_die.name : "",
1349                                   comp_unit_die.lowpc,
1350                                   objfile->global_psymbols.next,
1351                                   objfile->static_psymbols.next);
1352
1353           if (comp_unit_die.dirname)
1354         pst->dirname = xstrdup (comp_unit_die.dirname);
1355
1356       pst->read_symtab_private = (char *)
1357         obstack_alloc (&objfile->objfile_obstack, sizeof (struct dwarf2_pinfo));
1358       DWARF_INFO_OFFSET (pst) = beg_of_comp_unit - dwarf2_per_objfile->info_buffer;
1359       baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1360
1361       /* Store the function that reads in the rest of the symbol table */
1362       pst->read_symtab = dwarf2_psymtab_to_symtab;
1363
1364       /* Check if comp unit has_children.
1365          If so, read the rest of the partial symbols from this comp unit.
1366          If not, there's no more debug_info for this comp unit. */
1367       if (comp_unit_die.has_children)
1368         {
1369           struct partial_die_info *first_die;
1370
1371           lowpc = ((CORE_ADDR) -1);
1372           highpc = ((CORE_ADDR) 0);
1373
1374           first_die = load_partial_dies (abfd, info_ptr, 1, &cu);
1375
1376           scan_partial_symbols (first_die, &lowpc, &highpc, &cu);
1377
1378           /* If we didn't find a lowpc, set it to highpc to avoid
1379              complaints from `maint check'.  */
1380           if (lowpc == ((CORE_ADDR) -1))
1381             lowpc = highpc;
1382
1383           /* If the compilation unit didn't have an explicit address range,
1384              then use the information extracted from its child dies.  */
1385           if (! comp_unit_die.has_pc_info)
1386             {
1387               comp_unit_die.lowpc = lowpc;
1388               comp_unit_die.highpc = highpc;
1389             }
1390         }
1391       pst->textlow = comp_unit_die.lowpc + baseaddr;
1392       pst->texthigh = comp_unit_die.highpc + baseaddr;
1393
1394       pst->n_global_syms = objfile->global_psymbols.next -
1395         (objfile->global_psymbols.list + pst->globals_offset);
1396       pst->n_static_syms = objfile->static_psymbols.next -
1397         (objfile->static_psymbols.list + pst->statics_offset);
1398       sort_pst_symbols (pst);
1399
1400       /* If there is already a psymtab or symtab for a file of this
1401          name, remove it. (If there is a symtab, more drastic things
1402          also happen.) This happens in VxWorks.  */
1403       free_named_symtabs (pst->filename);
1404
1405       if (comp_unit_die.has_stmt_list)
1406         {
1407           /* Get the list of files included in the current compilation unit,
1408              and build a psymtab for each of them.  */
1409           dwarf2_build_include_psymtabs (&cu, &comp_unit_die, pst);
1410         }
1411
1412       info_ptr = beg_of_comp_unit + cu.header.length
1413                                   + cu.header.initial_length_size;
1414
1415       do_cleanups (back_to_inner);
1416     }
1417 }
1418
1419 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1420    Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1421    in CU.  */
1422
1423 static void
1424 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
1425                       CORE_ADDR *highpc, struct dwarf2_cu *cu)
1426 {
1427   struct objfile *objfile = cu->objfile;
1428   bfd *abfd = objfile->obfd;
1429   struct partial_die_info *pdi;
1430
1431   /* Now, march along the PDI's, descending into ones which have
1432      interesting children but skipping the children of the other ones,
1433      until we reach the end of the compilation unit.  */
1434
1435   pdi = first_die;
1436
1437   while (pdi != NULL)
1438     {
1439       fixup_partial_die (pdi, cu);
1440
1441       /* Anonymous namespaces have no name but have interesting
1442          children, so we need to look at them.  Ditto for anonymous
1443          enums.  */
1444
1445       if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
1446           || pdi->tag == DW_TAG_enumeration_type)
1447         {
1448           switch (pdi->tag)
1449             {
1450             case DW_TAG_subprogram:
1451               if (pdi->has_pc_info)
1452                 {
1453                   if (pdi->lowpc < *lowpc)
1454                     {
1455                       *lowpc = pdi->lowpc;
1456                     }
1457                   if (pdi->highpc > *highpc)
1458                     {
1459                       *highpc = pdi->highpc;
1460                     }
1461                   if (!pdi->is_declaration)
1462                     {
1463                       add_partial_symbol (pdi, cu);
1464                     }
1465                 }
1466               break;
1467             case DW_TAG_variable:
1468             case DW_TAG_typedef:
1469             case DW_TAG_union_type:
1470               if (!pdi->is_declaration)
1471                 {
1472                   add_partial_symbol (pdi, cu);
1473                 }
1474               break;
1475             case DW_TAG_class_type:
1476             case DW_TAG_structure_type:
1477               if (!pdi->is_declaration)
1478                 {
1479                   add_partial_symbol (pdi, cu);
1480                 }
1481               break;
1482             case DW_TAG_enumeration_type:
1483               if (!pdi->is_declaration)
1484                 add_partial_enumeration (pdi, cu);
1485               break;
1486             case DW_TAG_base_type:
1487             case DW_TAG_subrange_type:
1488               /* File scope base type definitions are added to the partial
1489                  symbol table.  */
1490               add_partial_symbol (pdi, cu);
1491               break;
1492             case DW_TAG_namespace:
1493               add_partial_namespace (pdi, lowpc, highpc, cu);
1494               break;
1495             default:
1496               break;
1497             }
1498         }
1499
1500       /* If the die has a sibling, skip to the sibling.  */
1501
1502       pdi = pdi->die_sibling;
1503     }
1504 }
1505
1506 /* Functions used to compute the fully scoped name of a partial DIE.
1507
1508    Normally, this is simple.  For C++, the parent DIE's fully scoped
1509    name is concatenated with "::" and the partial DIE's name.
1510    Enumerators are an exception; they use the scope of their parent
1511    enumeration type, i.e. the name of the enumeration type is not
1512    prepended to the enumerator.
1513
1514    There are two complexities.  One is DW_AT_specification; in this
1515    case "parent" means the parent of the target of the specification,
1516    instead of the direct parent of the DIE.  The other is compilers
1517    which do not emit DW_TAG_namespace; in this case we try to guess
1518    the fully qualified name of structure types from their members'
1519    linkage names.  This must be done using the DIE's children rather
1520    than the children of any DW_AT_specification target.  We only need
1521    to do this for structures at the top level, i.e. if the target of
1522    any DW_AT_specification (if any; otherwise the DIE itself) does not
1523    have a parent.  */
1524
1525 /* Compute the scope prefix associated with PDI's parent, in
1526    compilation unit CU.  The result will be allocated on CU's
1527    comp_unit_obstack, or a copy of the already allocated PDI->NAME
1528    field.  NULL is returned if no prefix is necessary.  */
1529 static char *
1530 partial_die_parent_scope (struct partial_die_info *pdi,
1531                           struct dwarf2_cu *cu)
1532 {
1533   char *grandparent_scope;
1534   struct partial_die_info *parent, *real_pdi;
1535   struct dwarf2_cu *spec_cu;
1536
1537   /* We need to look at our parent DIE; if we have a DW_AT_specification,
1538      then this means the parent of the specification DIE.  */
1539
1540   real_pdi = pdi;
1541   spec_cu = cu;
1542   while (real_pdi->has_specification)
1543     real_pdi = find_partial_die (real_pdi->spec_offset, spec_cu, &spec_cu);
1544
1545   parent = real_pdi->die_parent;
1546   if (parent == NULL)
1547     return NULL;
1548
1549   if (parent->scope_set)
1550     return parent->scope;
1551
1552   fixup_partial_die (parent, cu);
1553
1554   grandparent_scope = partial_die_parent_scope (parent, spec_cu);
1555
1556   if (parent->tag == DW_TAG_namespace
1557       || parent->tag == DW_TAG_structure_type
1558       || parent->tag == DW_TAG_class_type
1559       || parent->tag == DW_TAG_union_type)
1560     {
1561       if (grandparent_scope == NULL)
1562         parent->scope = parent->name;
1563       else
1564         parent->scope = obconcat (&cu->comp_unit_obstack, grandparent_scope,
1565                                   "::", parent->name);
1566     }
1567   else if (parent->tag == DW_TAG_enumeration_type)
1568     /* Enumerators should not get the name of the enumeration as a prefix.  */
1569     parent->scope = grandparent_scope;
1570   else
1571     {
1572       /* FIXME drow/2004-04-01: What should we be doing with
1573          function-local names?  For partial symbols, we should probably be
1574          ignoring them.  */
1575       complaint (&symfile_complaints,
1576                  "unhandled containing DIE tag %d for DIE at %d",
1577                  parent->tag, pdi->offset);
1578       parent->scope = grandparent_scope;
1579     }
1580
1581   parent->scope_set = 1;
1582   return parent->scope;
1583 }
1584
1585 /* Return the fully scoped name associated with PDI, from compilation unit
1586    CU.  The result will be allocated with malloc.  */
1587 static char *
1588 partial_die_full_name (struct partial_die_info *pdi,
1589                        struct dwarf2_cu *cu)
1590 {
1591   char *parent_scope;
1592
1593   parent_scope = partial_die_parent_scope (pdi, cu);
1594   if (parent_scope == NULL)
1595     return NULL;
1596   else
1597     return concat (parent_scope, "::", pdi->name, NULL);
1598 }
1599
1600 static void
1601 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
1602 {
1603   struct objfile *objfile = cu->objfile;
1604   CORE_ADDR addr = 0;
1605   char *actual_name;
1606   const char *my_prefix;
1607   const struct partial_symbol *psym = NULL;
1608   CORE_ADDR baseaddr;
1609   int built_actual_name = 0;
1610
1611   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1612
1613   actual_name = NULL;
1614
1615   if (pdi_needs_namespace (pdi->tag))
1616     {
1617       actual_name = partial_die_full_name (pdi, cu);
1618       if (actual_name)
1619         built_actual_name = 1;
1620     }
1621
1622   if (actual_name == NULL)
1623     actual_name = pdi->name;
1624
1625   switch (pdi->tag)
1626     {
1627     case DW_TAG_subprogram:
1628       if (pdi->is_external)
1629         {
1630           /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1631              mst_text, objfile); */
1632           psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1633                                       VAR_DOMAIN, LOC_BLOCK,
1634                                       &objfile->global_psymbols,
1635                                       0, pdi->lowpc + baseaddr,
1636                                       cu->language, objfile);
1637         }
1638       else
1639         {
1640           /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1641              mst_file_text, objfile); */
1642           psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1643                                       VAR_DOMAIN, LOC_BLOCK,
1644                                       &objfile->static_psymbols,
1645                                       0, pdi->lowpc + baseaddr,
1646                                       cu->language, objfile);
1647         }
1648       break;
1649     case DW_TAG_variable:
1650       if (pdi->is_external)
1651         {
1652           /* Global Variable.
1653              Don't enter into the minimal symbol tables as there is
1654              a minimal symbol table entry from the ELF symbols already.
1655              Enter into partial symbol table if it has a location
1656              descriptor or a type.
1657              If the location descriptor is missing, new_symbol will create
1658              a LOC_UNRESOLVED symbol, the address of the variable will then
1659              be determined from the minimal symbol table whenever the variable
1660              is referenced.
1661              The address for the partial symbol table entry is not
1662              used by GDB, but it comes in handy for debugging partial symbol
1663              table building.  */
1664
1665           if (pdi->locdesc)
1666             addr = decode_locdesc (pdi->locdesc, cu);
1667           if (pdi->locdesc || pdi->has_type)
1668             psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1669                                         VAR_DOMAIN, LOC_STATIC,
1670                                         &objfile->global_psymbols,
1671                                         0, addr + baseaddr,
1672                                         cu->language, objfile);
1673         }
1674       else
1675         {
1676           /* Static Variable. Skip symbols without location descriptors.  */
1677           if (pdi->locdesc == NULL)
1678             return;
1679           addr = decode_locdesc (pdi->locdesc, cu);
1680           /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1681              mst_file_data, objfile); */
1682           psym = add_psymbol_to_list (actual_name, strlen (actual_name),
1683                                       VAR_DOMAIN, LOC_STATIC,
1684                                       &objfile->static_psymbols,
1685                                       0, addr + baseaddr,
1686                                       cu->language, objfile);
1687         }
1688       break;
1689     case DW_TAG_typedef:
1690     case DW_TAG_base_type:
1691     case DW_TAG_subrange_type:
1692       add_psymbol_to_list (actual_name, strlen (actual_name),
1693                            VAR_DOMAIN, LOC_TYPEDEF,
1694                            &objfile->static_psymbols,
1695                            0, (CORE_ADDR) 0, cu->language, objfile);
1696       break;
1697     case DW_TAG_namespace:
1698       add_psymbol_to_list (actual_name, strlen (actual_name),
1699                            VAR_DOMAIN, LOC_TYPEDEF,
1700                            &objfile->global_psymbols,
1701                            0, (CORE_ADDR) 0, cu->language, objfile);
1702       break;
1703     case DW_TAG_class_type:
1704     case DW_TAG_structure_type:
1705     case DW_TAG_union_type:
1706     case DW_TAG_enumeration_type:
1707       /* Skip aggregate types without children, these are external
1708          references.  */
1709       /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1710          static vs. global.  */
1711       if (pdi->has_children == 0)
1712         return;
1713       add_psymbol_to_list (actual_name, strlen (actual_name),
1714                            STRUCT_DOMAIN, LOC_TYPEDEF,
1715                            cu->language == language_cplus
1716                            ? &objfile->global_psymbols
1717                            : &objfile->static_psymbols,
1718                            0, (CORE_ADDR) 0, cu->language, objfile);
1719
1720       if (cu->language == language_cplus)
1721         {
1722           /* For C++, these implicitly act as typedefs as well. */
1723           add_psymbol_to_list (actual_name, strlen (actual_name),
1724                                VAR_DOMAIN, LOC_TYPEDEF,
1725                                &objfile->global_psymbols,
1726                                0, (CORE_ADDR) 0, cu->language, objfile);
1727         }
1728       break;
1729     case DW_TAG_enumerator:
1730       add_psymbol_to_list (actual_name, strlen (actual_name),
1731                            VAR_DOMAIN, LOC_CONST,
1732                            cu->language == language_cplus
1733                            ? &objfile->global_psymbols
1734                            : &objfile->static_psymbols,
1735                            0, (CORE_ADDR) 0, cu->language, objfile);
1736       break;
1737     default:
1738       break;
1739     }
1740
1741   /* Check to see if we should scan the name for possible namespace
1742      info.  Only do this if this is C++, if we don't have namespace
1743      debugging info in the file, if the psym is of an appropriate type
1744      (otherwise we'll have psym == NULL), and if we actually had a
1745      mangled name to begin with.  */
1746
1747   /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
1748      cases which do not set PSYM above?  */
1749
1750   if (cu->language == language_cplus
1751       && cu->has_namespace_info == 0
1752       && psym != NULL
1753       && SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
1754     cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym),
1755                                          objfile);
1756
1757   if (built_actual_name)
1758     xfree (actual_name);
1759 }
1760
1761 /* Determine whether a die of type TAG living in a C++ class or
1762    namespace needs to have the name of the scope prepended to the
1763    name listed in the die.  */
1764
1765 static int
1766 pdi_needs_namespace (enum dwarf_tag tag)
1767 {
1768   switch (tag)
1769     {
1770     case DW_TAG_namespace:
1771     case DW_TAG_typedef:
1772     case DW_TAG_class_type:
1773     case DW_TAG_structure_type:
1774     case DW_TAG_union_type:
1775     case DW_TAG_enumeration_type:
1776     case DW_TAG_enumerator:
1777       return 1;
1778     default:
1779       return 0;
1780     }
1781 }
1782
1783 /* Read a partial die corresponding to a namespace; also, add a symbol
1784    corresponding to that namespace to the symbol table.  NAMESPACE is
1785    the name of the enclosing namespace.  */
1786
1787 static void
1788 add_partial_namespace (struct partial_die_info *pdi,
1789                        CORE_ADDR *lowpc, CORE_ADDR *highpc,
1790                        struct dwarf2_cu *cu)
1791 {
1792   struct objfile *objfile = cu->objfile;
1793
1794   /* Add a symbol for the namespace.  */
1795
1796   add_partial_symbol (pdi, cu);
1797
1798   /* Now scan partial symbols in that namespace.  */
1799
1800   if (pdi->has_children)
1801     scan_partial_symbols (pdi->die_child, lowpc, highpc, cu);
1802 }
1803
1804 /* See if we can figure out if the class lives in a namespace.  We do
1805    this by looking for a member function; its demangled name will
1806    contain namespace info, if there is any.  */
1807
1808 static void
1809 guess_structure_name (struct partial_die_info *struct_pdi,
1810                       struct dwarf2_cu *cu)
1811 {
1812   if (cu->language == language_cplus
1813       && cu->has_namespace_info == 0
1814       && struct_pdi->has_children)
1815     {
1816       /* NOTE: carlton/2003-10-07: Getting the info this way changes
1817          what template types look like, because the demangler
1818          frequently doesn't give the same name as the debug info.  We
1819          could fix this by only using the demangled name to get the
1820          prefix (but see comment in read_structure_type).  */
1821
1822       struct partial_die_info *child_pdi = struct_pdi->die_child;
1823       struct partial_die_info *real_pdi;
1824       struct dwarf2_cu *spec_cu;
1825
1826       /* If this DIE (this DIE's specification, if any) has a parent, then
1827          we should not do this.  We'll prepend the parent's fully qualified
1828          name when we create the partial symbol.  */
1829
1830       real_pdi = struct_pdi;
1831       spec_cu = cu;
1832       while (real_pdi->has_specification)
1833         real_pdi = find_partial_die (real_pdi->spec_offset, spec_cu, &spec_cu);
1834
1835       if (real_pdi->die_parent != NULL)
1836         return;
1837
1838       while (child_pdi != NULL)
1839         {
1840           if (child_pdi->tag == DW_TAG_subprogram)
1841             {
1842               char *actual_class_name
1843                 = class_name_from_physname (child_pdi->name);
1844               if (actual_class_name != NULL)
1845                 {
1846                   struct_pdi->name
1847                     = obsavestring (actual_class_name,
1848                                     strlen (actual_class_name),
1849                                     &cu->comp_unit_obstack);
1850                   xfree (actual_class_name);
1851                 }
1852               break;
1853             }
1854
1855           child_pdi = child_pdi->die_sibling;
1856         }
1857     }
1858 }
1859
1860 /* Read a partial die corresponding to an enumeration type.  */
1861
1862 static void
1863 add_partial_enumeration (struct partial_die_info *enum_pdi,
1864                          struct dwarf2_cu *cu)
1865 {
1866   struct objfile *objfile = cu->objfile;
1867   bfd *abfd = objfile->obfd;
1868   struct partial_die_info *pdi;
1869
1870   if (enum_pdi->name != NULL)
1871     add_partial_symbol (enum_pdi, cu);
1872
1873   pdi = enum_pdi->die_child;
1874   while (pdi)
1875     {
1876       if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
1877         complaint (&symfile_complaints, "malformed enumerator DIE ignored");
1878       else
1879         add_partial_symbol (pdi, cu);
1880       pdi = pdi->die_sibling;
1881     }
1882 }
1883
1884 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
1885    Return the corresponding abbrev, or NULL if the number is zero (indicating
1886    an empty DIE).  In either case *BYTES_READ will be set to the length of
1887    the initial number.  */
1888
1889 static struct abbrev_info *
1890 peek_die_abbrev (char *info_ptr, int *bytes_read, struct dwarf2_cu *cu)
1891 {
1892   bfd *abfd = cu->objfile->obfd;
1893   unsigned int abbrev_number;
1894   struct abbrev_info *abbrev;
1895
1896   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
1897
1898   if (abbrev_number == 0)
1899     return NULL;
1900
1901   abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
1902   if (!abbrev)
1903     {
1904       error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number,
1905                       bfd_get_filename (abfd));
1906     }
1907
1908   return abbrev;
1909 }
1910
1911 /* Scan the debug information for CU starting at INFO_PTR.  Returns a
1912    pointer to the end of a series of DIEs, terminated by an empty
1913    DIE.  Any children of the skipped DIEs will also be skipped.  */
1914
1915 static char *
1916 skip_children (char *info_ptr, struct dwarf2_cu *cu)
1917 {
1918   struct abbrev_info *abbrev;
1919   unsigned int bytes_read;
1920
1921   while (1)
1922     {
1923       abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
1924       if (abbrev == NULL)
1925         return info_ptr + bytes_read;
1926       else
1927         info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
1928     }
1929 }
1930
1931 /* Scan the debug information for CU starting at INFO_PTR.  INFO_PTR
1932    should point just after the initial uleb128 of a DIE, and the
1933    abbrev corresponding to that skipped uleb128 should be passed in
1934    ABBREV.  Returns a pointer to this DIE's sibling, skipping any
1935    children.  */
1936
1937 static char *
1938 skip_one_die (char *info_ptr, struct abbrev_info *abbrev,
1939               struct dwarf2_cu *cu)
1940 {
1941   unsigned int bytes_read;
1942   struct attribute attr;
1943   bfd *abfd = cu->objfile->obfd;
1944   unsigned int form, i;
1945
1946   for (i = 0; i < abbrev->num_attrs; i++)
1947     {
1948       /* The only abbrev we care about is DW_AT_sibling.  */
1949       if (abbrev->attrs[i].name == DW_AT_sibling)
1950         {
1951           read_attribute (&attr, &abbrev->attrs[i],
1952                           abfd, info_ptr, cu);
1953           if (attr.form == DW_FORM_ref_addr)
1954             complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling");
1955           else
1956             return dwarf2_per_objfile->info_buffer
1957               + dwarf2_get_ref_die_offset (&attr, cu);
1958         }
1959
1960       /* If it isn't DW_AT_sibling, skip this attribute.  */
1961       form = abbrev->attrs[i].form;
1962     skip_attribute:
1963       switch (form)
1964         {
1965         case DW_FORM_addr:
1966         case DW_FORM_ref_addr:
1967           info_ptr += cu->header.addr_size;
1968           break;
1969         case DW_FORM_data1:
1970         case DW_FORM_ref1:
1971         case DW_FORM_flag:
1972           info_ptr += 1;
1973           break;
1974         case DW_FORM_data2:
1975         case DW_FORM_ref2:
1976           info_ptr += 2;
1977           break;
1978         case DW_FORM_data4:
1979         case DW_FORM_ref4:
1980           info_ptr += 4;
1981           break;
1982         case DW_FORM_data8:
1983         case DW_FORM_ref8:
1984           info_ptr += 8;
1985           break;
1986         case DW_FORM_string:
1987           read_string (abfd, info_ptr, &bytes_read);
1988           info_ptr += bytes_read;
1989           break;
1990         case DW_FORM_strp:
1991           info_ptr += cu->header.offset_size;
1992           break;
1993         case DW_FORM_block:
1994           info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1995           info_ptr += bytes_read;
1996           break;
1997         case DW_FORM_block1:
1998           info_ptr += 1 + read_1_byte (abfd, info_ptr);
1999           break;
2000         case DW_FORM_block2:
2001           info_ptr += 2 + read_2_bytes (abfd, info_ptr);
2002           break;
2003         case DW_FORM_block4:
2004           info_ptr += 4 + read_4_bytes (abfd, info_ptr);
2005           break;
2006         case DW_FORM_sdata:
2007         case DW_FORM_udata:
2008         case DW_FORM_ref_udata:
2009           info_ptr = skip_leb128 (abfd, info_ptr);
2010           break;
2011         case DW_FORM_indirect:
2012           form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2013           info_ptr += bytes_read;
2014           /* We need to continue parsing from here, so just go back to
2015              the top.  */
2016           goto skip_attribute;
2017
2018         default:
2019           error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
2020                  dwarf_form_name (form),
2021                  bfd_get_filename (abfd));
2022         }
2023     }
2024
2025   if (abbrev->has_children)
2026     return skip_children (info_ptr, cu);
2027   else
2028     return info_ptr;
2029 }
2030
2031 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2032    the next DIE after ORIG_PDI.  */
2033
2034 static char *
2035 locate_pdi_sibling (struct partial_die_info *orig_pdi, char *info_ptr,
2036                     bfd *abfd, struct dwarf2_cu *cu)
2037 {
2038   /* Do we know the sibling already?  */
2039
2040   if (orig_pdi->sibling)
2041     return orig_pdi->sibling;
2042
2043   /* Are there any children to deal with?  */
2044
2045   if (!orig_pdi->has_children)
2046     return info_ptr;
2047
2048   /* Skip the children the long way.  */
2049
2050   return skip_children (info_ptr, cu);
2051 }
2052
2053 /* Expand this partial symbol table into a full symbol table.  */
2054
2055 static void
2056 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
2057 {
2058   /* FIXME: This is barely more than a stub.  */
2059   if (pst != NULL)
2060     {
2061       if (pst->readin)
2062         {
2063           warning ("bug: psymtab for %s is already read in.", pst->filename);
2064         }
2065       else
2066         {
2067           if (info_verbose)
2068             {
2069               printf_filtered ("Reading in symbols for %s...", pst->filename);
2070               gdb_flush (gdb_stdout);
2071             }
2072
2073           psymtab_to_symtab_1 (pst);
2074
2075           /* Finish up the debug error message.  */
2076           if (info_verbose)
2077             printf_filtered ("done.\n");
2078         }
2079     }
2080 }
2081
2082 static void
2083 psymtab_to_symtab_1 (struct partial_symtab *pst)
2084 {
2085   struct objfile *objfile = pst->objfile;
2086   bfd *abfd = objfile->obfd;
2087   struct dwarf2_cu cu;
2088   struct die_info *dies;
2089   unsigned long offset;
2090   CORE_ADDR lowpc, highpc;
2091   struct die_info *child_die;
2092   char *info_ptr;
2093   struct symtab *symtab;
2094   struct cleanup *back_to;
2095   struct attribute *attr;
2096   CORE_ADDR baseaddr;
2097   int i;
2098
2099   for (i = 0; i < pst->number_of_dependencies; i++)
2100     if (!pst->dependencies[i]->readin)
2101       {
2102         /* Inform about additional files that need to be read in.  */
2103         if (info_verbose)
2104           {
2105             fputs_filtered (" ", gdb_stdout);
2106             wrap_here ("");
2107             fputs_filtered ("and ", gdb_stdout);
2108             wrap_here ("");
2109             printf_filtered ("%s...", pst->dependencies[i]->filename);
2110             wrap_here ("");     /* Flush output */
2111             gdb_flush (gdb_stdout);
2112           }
2113         psymtab_to_symtab_1 (pst->dependencies[i]);
2114       }
2115
2116   if (pst->read_symtab_private == NULL)
2117     {
2118       /* It's an include file, no symbols to read for it.
2119          Everything is in the parent symtab.  */
2120       pst->readin = 1;
2121       return;
2122     }
2123
2124   dwarf2_per_objfile = objfile_data (pst->objfile, dwarf2_objfile_data_key);
2125
2126   /* Set local variables from the partial symbol table info.  */
2127   offset = DWARF_INFO_OFFSET (pst);
2128
2129   info_ptr = dwarf2_per_objfile->info_buffer + offset;
2130   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2131
2132   /* We're in the global namespace.  */
2133   processing_current_prefix = "";
2134
2135   obstack_init (&cu.comp_unit_obstack);
2136   back_to = make_cleanup (free_stack_comp_unit, &cu);
2137
2138   buildsym_init ();
2139   make_cleanup (really_free_pendings, NULL);
2140
2141   cu.objfile = objfile;
2142
2143   /* read in the comp_unit header  */
2144   info_ptr = read_comp_unit_head (&cu.header, info_ptr, abfd);
2145
2146   /* Read the abbrevs for this compilation unit  */
2147   dwarf2_read_abbrevs (abfd, &cu);
2148   make_cleanup (dwarf2_free_abbrev_table, &cu);
2149
2150   cu.header.offset = offset;
2151
2152   cu.list_in_scope = &file_symbols;
2153
2154   dies = read_comp_unit (info_ptr, abfd, &cu);
2155
2156   make_cleanup_free_die_list (dies);
2157
2158   /* Find the base address of the compilation unit for range lists and
2159      location lists.  It will normally be specified by DW_AT_low_pc.
2160      In DWARF-3 draft 4, the base address could be overridden by
2161      DW_AT_entry_pc.  It's been removed, but GCC still uses this for
2162      compilation units with discontinuous ranges.  */
2163
2164   cu.header.base_known = 0;
2165   cu.header.base_address = 0;
2166
2167   attr = dwarf2_attr (dies, DW_AT_entry_pc, &cu);
2168   if (attr)
2169     {
2170       cu.header.base_address = DW_ADDR (attr);
2171       cu.header.base_known = 1;
2172     }
2173   else
2174     {
2175       attr = dwarf2_attr (dies, DW_AT_low_pc, &cu);
2176       if (attr)
2177         {
2178           cu.header.base_address = DW_ADDR (attr);
2179           cu.header.base_known = 1;
2180         }
2181     }
2182
2183   /* Do line number decoding in read_file_scope () */
2184   process_die (dies, &cu);
2185
2186   /* Some compilers don't define a DW_AT_high_pc attribute for the
2187      compilation unit.  If the DW_AT_high_pc is missing, synthesize
2188      it, by scanning the DIE's below the compilation unit.  */
2189   get_scope_pc_bounds (dies, &lowpc, &highpc, &cu);
2190
2191   symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
2192
2193   /* Set symtab language to language from DW_AT_language.
2194      If the compilation is from a C file generated by language preprocessors,
2195      do not set the language if it was already deduced by start_subfile.  */
2196   if (symtab != NULL
2197       && !(cu.language == language_c && symtab->language != language_c))
2198     {
2199       symtab->language = cu.language;
2200     }
2201   pst->symtab = symtab;
2202   pst->readin = 1;
2203
2204   do_cleanups (back_to);
2205 }
2206
2207 /* Process a die and its children.  */
2208
2209 static void
2210 process_die (struct die_info *die, struct dwarf2_cu *cu)
2211 {
2212   switch (die->tag)
2213     {
2214     case DW_TAG_padding:
2215       break;
2216     case DW_TAG_compile_unit:
2217       read_file_scope (die, cu);
2218       break;
2219     case DW_TAG_subprogram:
2220       read_subroutine_type (die, cu);
2221       read_func_scope (die, cu);
2222       break;
2223     case DW_TAG_inlined_subroutine:
2224       /* FIXME:  These are ignored for now.
2225          They could be used to set breakpoints on all inlined instances
2226          of a function and make GDB `next' properly over inlined functions.  */
2227       break;
2228     case DW_TAG_lexical_block:
2229     case DW_TAG_try_block:
2230     case DW_TAG_catch_block:
2231       read_lexical_block_scope (die, cu);
2232       break;
2233     case DW_TAG_class_type:
2234     case DW_TAG_structure_type:
2235     case DW_TAG_union_type:
2236       read_structure_type (die, cu);
2237       process_structure_scope (die, cu);
2238       break;
2239     case DW_TAG_enumeration_type:
2240       read_enumeration_type (die, cu);
2241       process_enumeration_scope (die, cu);
2242       break;
2243
2244     /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2245        a symbol or process any children.  Therefore it doesn't do anything
2246        that won't be done on-demand by read_type_die.  */
2247     case DW_TAG_subroutine_type:
2248       read_subroutine_type (die, cu);
2249       break;
2250     case DW_TAG_array_type:
2251       read_array_type (die, cu);
2252       break;
2253     case DW_TAG_pointer_type:
2254       read_tag_pointer_type (die, cu);
2255       break;
2256     case DW_TAG_ptr_to_member_type:
2257       read_tag_ptr_to_member_type (die, cu);
2258       break;
2259     case DW_TAG_reference_type:
2260       read_tag_reference_type (die, cu);
2261       break;
2262     case DW_TAG_string_type:
2263       read_tag_string_type (die, cu);
2264       break;
2265     /* END FIXME */
2266
2267     case DW_TAG_base_type:
2268       read_base_type (die, cu);
2269       /* Add a typedef symbol for the type definition, if it has a
2270          DW_AT_name.  */
2271       new_symbol (die, die->type, cu);
2272       break;
2273     case DW_TAG_subrange_type:
2274       read_subrange_type (die, cu);
2275       /* Add a typedef symbol for the type definition, if it has a
2276          DW_AT_name.  */
2277       new_symbol (die, die->type, cu);
2278       break;
2279     case DW_TAG_common_block:
2280       read_common_block (die, cu);
2281       break;
2282     case DW_TAG_common_inclusion:
2283       break;
2284     case DW_TAG_namespace:
2285       processing_has_namespace_info = 1;
2286       read_namespace (die, cu);
2287       break;
2288     case DW_TAG_imported_declaration:
2289     case DW_TAG_imported_module:
2290       /* FIXME: carlton/2002-10-16: Eventually, we should use the
2291          information contained in these.  DW_TAG_imported_declaration
2292          dies shouldn't have children; DW_TAG_imported_module dies
2293          shouldn't in the C++ case, but conceivably could in the
2294          Fortran case, so we'll have to replace this gdb_assert if
2295          Fortran compilers start generating that info.  */
2296       processing_has_namespace_info = 1;
2297       gdb_assert (die->child == NULL);
2298       break;
2299     default:
2300       new_symbol (die, NULL, cu);
2301       break;
2302     }
2303 }
2304
2305 static void
2306 initialize_cu_func_list (struct dwarf2_cu *cu)
2307 {
2308   cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
2309 }
2310
2311 static void
2312 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
2313 {
2314   struct objfile *objfile = cu->objfile;
2315   struct comp_unit_head *cu_header = &cu->header;
2316   struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2317   CORE_ADDR lowpc = ((CORE_ADDR) -1);
2318   CORE_ADDR highpc = ((CORE_ADDR) 0);
2319   struct attribute *attr;
2320   char *name = "<unknown>";
2321   char *comp_dir = NULL;
2322   struct die_info *child_die;
2323   bfd *abfd = objfile->obfd;
2324   struct line_header *line_header = 0;
2325   CORE_ADDR baseaddr;
2326
2327   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2328
2329   get_scope_pc_bounds (die, &lowpc, &highpc, cu);
2330
2331   /* If we didn't find a lowpc, set it to highpc to avoid complaints
2332      from finish_block.  */
2333   if (lowpc == ((CORE_ADDR) -1))
2334     lowpc = highpc;
2335   lowpc += baseaddr;
2336   highpc += baseaddr;
2337
2338   attr = dwarf2_attr (die, DW_AT_name, cu);
2339   if (attr)
2340     {
2341       name = DW_STRING (attr);
2342     }
2343   attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
2344   if (attr)
2345     {
2346       comp_dir = DW_STRING (attr);
2347       if (comp_dir)
2348         {
2349           /* Irix 6.2 native cc prepends <machine>.: to the compilation
2350              directory, get rid of it.  */
2351           char *cp = strchr (comp_dir, ':');
2352
2353           if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2354             comp_dir = cp + 1;
2355         }
2356     }
2357
2358   attr = dwarf2_attr (die, DW_AT_language, cu);
2359   if (attr)
2360     {
2361       set_cu_language (DW_UNSND (attr), cu);
2362     }
2363
2364   /* We assume that we're processing GCC output. */
2365   processing_gcc_compilation = 2;
2366 #if 0
2367   /* FIXME:Do something here.  */
2368   if (dip->at_producer != NULL)
2369     {
2370       handle_producer (dip->at_producer);
2371     }
2372 #endif
2373
2374   /* The compilation unit may be in a different language or objfile,
2375      zero out all remembered fundamental types.  */
2376   memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
2377
2378   start_symtab (name, comp_dir, lowpc);
2379   record_debugformat ("DWARF 2");
2380
2381   initialize_cu_func_list (cu);
2382
2383   /* Process all dies in compilation unit.  */
2384   if (die->child != NULL)
2385     {
2386       child_die = die->child;
2387       while (child_die && child_die->tag)
2388         {
2389           process_die (child_die, cu);
2390           child_die = sibling_die (child_die);
2391         }
2392     }
2393
2394   /* Decode line number information if present.  */
2395   attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
2396   if (attr)
2397     {
2398       unsigned int line_offset = DW_UNSND (attr);
2399       line_header = dwarf_decode_line_header (line_offset, abfd, cu);
2400       if (line_header)
2401         {
2402           make_cleanup ((make_cleanup_ftype *) free_line_header,
2403                         (void *) line_header);
2404           dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL);
2405         }
2406     }
2407
2408   /* Decode macro information, if present.  Dwarf 2 macro information
2409      refers to information in the line number info statement program
2410      header, so we can only read it if we've read the header
2411      successfully.  */
2412   attr = dwarf2_attr (die, DW_AT_macro_info, cu);
2413   if (attr && line_header)
2414     {
2415       unsigned int macro_offset = DW_UNSND (attr);
2416       dwarf_decode_macros (line_header, macro_offset,
2417                            comp_dir, abfd, cu);
2418     }
2419   do_cleanups (back_to);
2420 }
2421
2422 static void
2423 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
2424                      struct dwarf2_cu *cu)
2425 {
2426   struct function_range *thisfn;
2427
2428   thisfn = (struct function_range *)
2429     obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range));
2430   thisfn->name = name;
2431   thisfn->lowpc = lowpc;
2432   thisfn->highpc = highpc;
2433   thisfn->seen_line = 0;
2434   thisfn->next = NULL;
2435
2436   if (cu->last_fn == NULL)
2437       cu->first_fn = thisfn;
2438   else
2439       cu->last_fn->next = thisfn;
2440
2441   cu->last_fn = thisfn;
2442 }
2443
2444 static void
2445 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
2446 {
2447   struct objfile *objfile = cu->objfile;
2448   struct context_stack *new;
2449   CORE_ADDR lowpc;
2450   CORE_ADDR highpc;
2451   struct die_info *child_die;
2452   struct attribute *attr;
2453   char *name;
2454   const char *previous_prefix = processing_current_prefix;
2455   struct cleanup *back_to = NULL;
2456   CORE_ADDR baseaddr;
2457
2458   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2459
2460   name = dwarf2_linkage_name (die, cu);
2461
2462   /* Ignore functions with missing or empty names and functions with
2463      missing or invalid low and high pc attributes.  */
2464   if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2465     return;
2466
2467   if (cu->language == language_cplus)
2468     {
2469       struct die_info *spec_die = die_specification (die, cu);
2470
2471       /* NOTE: carlton/2004-01-23: We have to be careful in the
2472          presence of DW_AT_specification.  For example, with GCC 3.4,
2473          given the code
2474
2475            namespace N {
2476              void foo() {
2477                // Definition of N::foo.
2478              }
2479            }
2480
2481          then we'll have a tree of DIEs like this:
2482
2483          1: DW_TAG_compile_unit
2484            2: DW_TAG_namespace        // N
2485              3: DW_TAG_subprogram     // declaration of N::foo
2486            4: DW_TAG_subprogram       // definition of N::foo
2487                 DW_AT_specification   // refers to die #3
2488
2489          Thus, when processing die #4, we have to pretend that we're
2490          in the context of its DW_AT_specification, namely the contex
2491          of die #3.  */
2492
2493       if (spec_die != NULL)
2494         {
2495           char *specification_prefix = determine_prefix (spec_die, cu);
2496           processing_current_prefix = specification_prefix;
2497           back_to = make_cleanup (xfree, specification_prefix);
2498         }
2499     }
2500
2501   lowpc += baseaddr;
2502   highpc += baseaddr;
2503
2504   /* Record the function range for dwarf_decode_lines.  */
2505   add_to_cu_func_list (name, lowpc, highpc, cu);
2506
2507   if (objfile->ei.entry_point >= lowpc &&
2508       objfile->ei.entry_point < highpc)
2509     {
2510       objfile->ei.entry_func_lowpc = lowpc;
2511       objfile->ei.entry_func_highpc = highpc;
2512     }
2513
2514   new = push_context (0, lowpc);
2515   new->name = new_symbol (die, die->type, cu);
2516
2517   /* If there is a location expression for DW_AT_frame_base, record
2518      it.  */
2519   attr = dwarf2_attr (die, DW_AT_frame_base, cu);
2520   if (attr)
2521     /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2522        expression is being recorded directly in the function's symbol
2523        and not in a separate frame-base object.  I guess this hack is
2524        to avoid adding some sort of frame-base adjunct/annex to the
2525        function's symbol :-(.  The problem with doing this is that it
2526        results in a function symbol with a location expression that
2527        has nothing to do with the location of the function, ouch!  The
2528        relationship should be: a function's symbol has-a frame base; a
2529        frame-base has-a location expression.  */
2530     dwarf2_symbol_mark_computed (attr, new->name, cu);
2531
2532   cu->list_in_scope = &local_symbols;
2533
2534   if (die->child != NULL)
2535     {
2536       child_die = die->child;
2537       while (child_die && child_die->tag)
2538         {
2539           process_die (child_die, cu);
2540           child_die = sibling_die (child_die);
2541         }
2542     }
2543
2544   new = pop_context ();
2545   /* Make a block for the local symbols within.  */
2546   finish_block (new->name, &local_symbols, new->old_blocks,
2547                 lowpc, highpc, objfile);
2548
2549   /* In C++, we can have functions nested inside functions (e.g., when
2550      a function declares a class that has methods).  This means that
2551      when we finish processing a function scope, we may need to go
2552      back to building a containing block's symbol lists.  */
2553   local_symbols = new->locals;
2554   param_symbols = new->params;
2555
2556   /* If we've finished processing a top-level function, subsequent
2557      symbols go in the file symbol list.  */
2558   if (outermost_context_p ())
2559     cu->list_in_scope = &file_symbols;
2560
2561   processing_current_prefix = previous_prefix;
2562   if (back_to != NULL)
2563     do_cleanups (back_to);
2564 }
2565
2566 /* Process all the DIES contained within a lexical block scope.  Start
2567    a new scope, process the dies, and then close the scope.  */
2568
2569 static void
2570 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
2571 {
2572   struct objfile *objfile = cu->objfile;
2573   struct context_stack *new;
2574   CORE_ADDR lowpc, highpc;
2575   struct die_info *child_die;
2576   CORE_ADDR baseaddr;
2577
2578   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2579
2580   /* Ignore blocks with missing or invalid low and high pc attributes.  */
2581   /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2582      as multiple lexical blocks?  Handling children in a sane way would
2583      be nasty.  Might be easier to properly extend generic blocks to
2584      describe ranges.  */
2585   if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
2586     return;
2587   lowpc += baseaddr;
2588   highpc += baseaddr;
2589
2590   push_context (0, lowpc);
2591   if (die->child != NULL)
2592     {
2593       child_die = die->child;
2594       while (child_die && child_die->tag)
2595         {
2596           process_die (child_die, cu);
2597           child_die = sibling_die (child_die);
2598         }
2599     }
2600   new = pop_context ();
2601
2602   if (local_symbols != NULL)
2603     {
2604       finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
2605                     highpc, objfile);
2606     }
2607   local_symbols = new->locals;
2608 }
2609
2610 /* Get low and high pc attributes from a die.  Return 1 if the attributes
2611    are present and valid, otherwise, return 0.  Return -1 if the range is
2612    discontinuous, i.e. derived from DW_AT_ranges information.  */
2613 static int
2614 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
2615                       CORE_ADDR *highpc, struct dwarf2_cu *cu)
2616 {
2617   struct objfile *objfile = cu->objfile;
2618   struct comp_unit_head *cu_header = &cu->header;
2619   struct attribute *attr;
2620   bfd *obfd = objfile->obfd;
2621   CORE_ADDR low = 0;
2622   CORE_ADDR high = 0;
2623   int ret = 0;
2624
2625   attr = dwarf2_attr (die, DW_AT_high_pc, cu);
2626   if (attr)
2627     {
2628       high = DW_ADDR (attr);
2629       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
2630       if (attr)
2631         low = DW_ADDR (attr);
2632       else
2633         /* Found high w/o low attribute.  */
2634         return 0;
2635
2636       /* Found consecutive range of addresses.  */
2637       ret = 1;
2638     }
2639   else
2640     {
2641       attr = dwarf2_attr (die, DW_AT_ranges, cu);
2642       if (attr != NULL)
2643         {
2644           unsigned int addr_size = cu_header->addr_size;
2645           CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
2646           /* Value of the DW_AT_ranges attribute is the offset in the
2647              .debug_ranges section.  */
2648           unsigned int offset = DW_UNSND (attr);
2649           /* Base address selection entry.  */
2650           CORE_ADDR base;
2651           int found_base;
2652           int dummy;
2653           char *buffer;
2654           CORE_ADDR marker;
2655           int low_set;
2656
2657           found_base = cu_header->base_known;
2658           base = cu_header->base_address;
2659
2660           if (offset >= dwarf2_per_objfile->ranges_size)
2661             {
2662               complaint (&symfile_complaints,
2663                          "Offset %d out of bounds for DW_AT_ranges attribute",
2664                          offset);
2665               return 0;
2666             }
2667           buffer = dwarf2_per_objfile->ranges_buffer + offset;
2668
2669           /* Read in the largest possible address.  */
2670           marker = read_address (obfd, buffer, cu, &dummy);
2671           if ((marker & mask) == mask)
2672             {
2673               /* If we found the largest possible address, then
2674                  read the base address.  */
2675               base = read_address (obfd, buffer + addr_size, cu, &dummy);
2676               buffer += 2 * addr_size;
2677               offset += 2 * addr_size;
2678               found_base = 1;
2679             }
2680
2681           low_set = 0;
2682
2683           while (1)
2684             {
2685               CORE_ADDR range_beginning, range_end;
2686
2687               range_beginning = read_address (obfd, buffer, cu, &dummy);
2688               buffer += addr_size;
2689               range_end = read_address (obfd, buffer, cu, &dummy);
2690               buffer += addr_size;
2691               offset += 2 * addr_size;
2692
2693               /* An end of list marker is a pair of zero addresses.  */
2694               if (range_beginning == 0 && range_end == 0)
2695                 /* Found the end of list entry.  */
2696                 break;
2697
2698               /* Each base address selection entry is a pair of 2 values.
2699                  The first is the largest possible address, the second is
2700                  the base address.  Check for a base address here.  */
2701               if ((range_beginning & mask) == mask)
2702                 {
2703                   /* If we found the largest possible address, then
2704                      read the base address.  */
2705                   base = read_address (obfd, buffer + addr_size, cu, &dummy);
2706                   found_base = 1;
2707                   continue;
2708                 }
2709
2710               if (!found_base)
2711                 {
2712                   /* We have no valid base address for the ranges
2713                      data.  */
2714                   complaint (&symfile_complaints,
2715                              "Invalid .debug_ranges data (no base address)");
2716                   return 0;
2717                 }
2718
2719               range_beginning += base;
2720               range_end += base;
2721
2722               /* FIXME: This is recording everything as a low-high
2723                  segment of consecutive addresses.  We should have a
2724                  data structure for discontiguous block ranges
2725                  instead.  */
2726               if (! low_set)
2727                 {
2728                   low = range_beginning;
2729                   high = range_end;
2730                   low_set = 1;
2731                 }
2732               else
2733                 {
2734                   if (range_beginning < low)
2735                     low = range_beginning;
2736                   if (range_end > high)
2737                     high = range_end;
2738                 }
2739             }
2740
2741           if (! low_set)
2742             /* If the first entry is an end-of-list marker, the range
2743                describes an empty scope, i.e. no instructions.  */
2744             return 0;
2745
2746           ret = -1;
2747         }
2748     }
2749
2750   if (high < low)
2751     return 0;
2752
2753   /* When using the GNU linker, .gnu.linkonce. sections are used to
2754      eliminate duplicate copies of functions and vtables and such.
2755      The linker will arbitrarily choose one and discard the others.
2756      The AT_*_pc values for such functions refer to local labels in
2757      these sections.  If the section from that file was discarded, the
2758      labels are not in the output, so the relocs get a value of 0.
2759      If this is a discarded function, mark the pc bounds as invalid,
2760      so that GDB will ignore it.  */
2761   if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0)
2762     return 0;
2763
2764   *lowpc = low;
2765   *highpc = high;
2766   return ret;
2767 }
2768
2769 /* Get the low and high pc's represented by the scope DIE, and store
2770    them in *LOWPC and *HIGHPC.  If the correct values can't be
2771    determined, set *LOWPC to -1 and *HIGHPC to 0.  */
2772
2773 static void
2774 get_scope_pc_bounds (struct die_info *die,
2775                      CORE_ADDR *lowpc, CORE_ADDR *highpc,
2776                      struct dwarf2_cu *cu)
2777 {
2778   CORE_ADDR best_low = (CORE_ADDR) -1;
2779   CORE_ADDR best_high = (CORE_ADDR) 0;
2780   CORE_ADDR current_low, current_high;
2781
2782   if (dwarf2_get_pc_bounds (die, &current_low, &current_high, cu))
2783     {
2784       best_low = current_low;
2785       best_high = current_high;
2786     }
2787   else
2788     {
2789       struct die_info *child = die->child;
2790
2791       while (child && child->tag)
2792         {
2793           switch (child->tag) {
2794           case DW_TAG_subprogram:
2795             if (dwarf2_get_pc_bounds (child, &current_low, &current_high, cu))
2796               {
2797                 best_low = min (best_low, current_low);
2798                 best_high = max (best_high, current_high);
2799               }
2800             break;
2801           case DW_TAG_namespace:
2802             /* FIXME: carlton/2004-01-16: Should we do this for
2803                DW_TAG_class_type/DW_TAG_structure_type, too?  I think
2804                that current GCC's always emit the DIEs corresponding
2805                to definitions of methods of classes as children of a
2806                DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
2807                the DIEs giving the declarations, which could be
2808                anywhere).  But I don't see any reason why the
2809                standards says that they have to be there.  */
2810             get_scope_pc_bounds (child, &current_low, &current_high, cu);
2811
2812             if (current_low != ((CORE_ADDR) -1))
2813               {
2814                 best_low = min (best_low, current_low);
2815                 best_high = max (best_high, current_high);
2816               }
2817             break;
2818           default:
2819             /* Ignore. */
2820             break;
2821           }
2822
2823           child = sibling_die (child);
2824         }
2825     }
2826
2827   *lowpc = best_low;
2828   *highpc = best_high;
2829 }
2830
2831 /* Add an aggregate field to the field list.  */
2832
2833 static void
2834 dwarf2_add_field (struct field_info *fip, struct die_info *die,
2835                   struct dwarf2_cu *cu)
2836 {
2837   struct objfile *objfile = cu->objfile;
2838   struct nextfield *new_field;
2839   struct attribute *attr;
2840   struct field *fp;
2841   char *fieldname = "";
2842
2843   /* Allocate a new field list entry and link it in.  */
2844   new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
2845   make_cleanup (xfree, new_field);
2846   memset (new_field, 0, sizeof (struct nextfield));
2847   new_field->next = fip->fields;
2848   fip->fields = new_field;
2849   fip->nfields++;
2850
2851   /* Handle accessibility and virtuality of field.
2852      The default accessibility for members is public, the default
2853      accessibility for inheritance is private.  */
2854   if (die->tag != DW_TAG_inheritance)
2855     new_field->accessibility = DW_ACCESS_public;
2856   else
2857     new_field->accessibility = DW_ACCESS_private;
2858   new_field->virtuality = DW_VIRTUALITY_none;
2859
2860   attr = dwarf2_attr (die, DW_AT_accessibility, cu);
2861   if (attr)
2862     new_field->accessibility = DW_UNSND (attr);
2863   if (new_field->accessibility != DW_ACCESS_public)
2864     fip->non_public_fields = 1;
2865   attr = dwarf2_attr (die, DW_AT_virtuality, cu);
2866   if (attr)
2867     new_field->virtuality = DW_UNSND (attr);
2868
2869   fp = &new_field->field;
2870
2871   if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
2872     {
2873       /* Data member other than a C++ static data member.  */
2874
2875       /* Get type of field.  */
2876       fp->type = die_type (die, cu);
2877
2878       FIELD_STATIC_KIND (*fp) = 0;
2879
2880       /* Get bit size of field (zero if none).  */
2881       attr = dwarf2_attr (die, DW_AT_bit_size, cu);
2882       if (attr)
2883         {
2884           FIELD_BITSIZE (*fp) = DW_UNSND (attr);
2885         }
2886       else
2887         {
2888           FIELD_BITSIZE (*fp) = 0;
2889         }
2890
2891       /* Get bit offset of field.  */
2892       attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
2893       if (attr)
2894         {
2895           FIELD_BITPOS (*fp) =
2896             decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte;
2897         }
2898       else
2899         FIELD_BITPOS (*fp) = 0;
2900       attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
2901       if (attr)
2902         {
2903           if (BITS_BIG_ENDIAN)
2904             {
2905               /* For big endian bits, the DW_AT_bit_offset gives the
2906                  additional bit offset from the MSB of the containing
2907                  anonymous object to the MSB of the field.  We don't
2908                  have to do anything special since we don't need to
2909                  know the size of the anonymous object.  */
2910               FIELD_BITPOS (*fp) += DW_UNSND (attr);
2911             }
2912           else
2913             {
2914               /* For little endian bits, compute the bit offset to the
2915                  MSB of the anonymous object, subtract off the number of
2916                  bits from the MSB of the field to the MSB of the
2917                  object, and then subtract off the number of bits of
2918                  the field itself.  The result is the bit offset of
2919                  the LSB of the field.  */
2920               int anonymous_size;
2921               int bit_offset = DW_UNSND (attr);
2922
2923               attr = dwarf2_attr (die, DW_AT_byte_size, cu);
2924               if (attr)
2925                 {
2926                   /* The size of the anonymous object containing
2927                      the bit field is explicit, so use the
2928                      indicated size (in bytes).  */
2929                   anonymous_size = DW_UNSND (attr);
2930                 }
2931               else
2932                 {
2933                   /* The size of the anonymous object containing
2934                      the bit field must be inferred from the type
2935                      attribute of the data member containing the
2936                      bit field.  */
2937                   anonymous_size = TYPE_LENGTH (fp->type);
2938                 }
2939               FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
2940                 - bit_offset - FIELD_BITSIZE (*fp);
2941             }
2942         }
2943
2944       /* Get name of field.  */
2945       attr = dwarf2_attr (die, DW_AT_name, cu);
2946       if (attr && DW_STRING (attr))
2947         fieldname = DW_STRING (attr);
2948
2949       /* The name is already allocated along with this objfile, so we don't
2950          need to duplicate it for the type.  */
2951       fp->name = fieldname;
2952
2953       /* Change accessibility for artificial fields (e.g. virtual table
2954          pointer or virtual base class pointer) to private.  */
2955       if (dwarf2_attr (die, DW_AT_artificial, cu))
2956         {
2957           new_field->accessibility = DW_ACCESS_private;
2958           fip->non_public_fields = 1;
2959         }
2960     }
2961   else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
2962     {
2963       /* C++ static member.  */
2964
2965       /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2966          is a declaration, but all versions of G++ as of this writing
2967          (so through at least 3.2.1) incorrectly generate
2968          DW_TAG_variable tags.  */
2969
2970       char *physname;
2971
2972       /* Get name of field.  */
2973       attr = dwarf2_attr (die, DW_AT_name, cu);
2974       if (attr && DW_STRING (attr))
2975         fieldname = DW_STRING (attr);
2976       else
2977         return;
2978
2979       /* Get physical name.  */
2980       physname = dwarf2_linkage_name (die, cu);
2981
2982       /* The name is already allocated along with this objfile, so we don't
2983          need to duplicate it for the type.  */
2984       SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
2985       FIELD_TYPE (*fp) = die_type (die, cu);
2986       FIELD_NAME (*fp) = fieldname;
2987     }
2988   else if (die->tag == DW_TAG_inheritance)
2989     {
2990       /* C++ base class field.  */
2991       attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
2992       if (attr)
2993         FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
2994                               * bits_per_byte);
2995       FIELD_BITSIZE (*fp) = 0;
2996       FIELD_STATIC_KIND (*fp) = 0;
2997       FIELD_TYPE (*fp) = die_type (die, cu);
2998       FIELD_NAME (*fp) = type_name_no_tag (fp->type);
2999       fip->nbaseclasses++;
3000     }
3001 }
3002
3003 /* Create the vector of fields, and attach it to the type.  */
3004
3005 static void
3006 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
3007                               struct dwarf2_cu *cu)
3008 {
3009   int nfields = fip->nfields;
3010
3011   /* Record the field count, allocate space for the array of fields,
3012      and create blank accessibility bitfields if necessary.  */
3013   TYPE_NFIELDS (type) = nfields;
3014   TYPE_FIELDS (type) = (struct field *)
3015     TYPE_ALLOC (type, sizeof (struct field) * nfields);
3016   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3017
3018   if (fip->non_public_fields)
3019     {
3020       ALLOCATE_CPLUS_STRUCT_TYPE (type);
3021
3022       TYPE_FIELD_PRIVATE_BITS (type) =
3023         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3024       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3025
3026       TYPE_FIELD_PROTECTED_BITS (type) =
3027         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3028       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3029
3030       TYPE_FIELD_IGNORE_BITS (type) =
3031         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3032       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3033     }
3034
3035   /* If the type has baseclasses, allocate and clear a bit vector for
3036      TYPE_FIELD_VIRTUAL_BITS.  */
3037   if (fip->nbaseclasses)
3038     {
3039       int num_bytes = B_BYTES (fip->nbaseclasses);
3040       char *pointer;
3041
3042       ALLOCATE_CPLUS_STRUCT_TYPE (type);
3043       pointer = (char *) TYPE_ALLOC (type, num_bytes);
3044       TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
3045       B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
3046       TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
3047     }
3048
3049   /* Copy the saved-up fields into the field vector.  Start from the head
3050      of the list, adding to the tail of the field array, so that they end
3051      up in the same order in the array in which they were added to the list.  */
3052   while (nfields-- > 0)
3053     {
3054       TYPE_FIELD (type, nfields) = fip->fields->field;
3055       switch (fip->fields->accessibility)
3056         {
3057         case DW_ACCESS_private:
3058           SET_TYPE_FIELD_PRIVATE (type, nfields);
3059           break;
3060
3061         case DW_ACCESS_protected:
3062           SET_TYPE_FIELD_PROTECTED (type, nfields);
3063           break;
3064
3065         case DW_ACCESS_public:
3066           break;
3067
3068         default:
3069           /* Unknown accessibility.  Complain and treat it as public.  */
3070           {
3071             complaint (&symfile_complaints, "unsupported accessibility %d",
3072                        fip->fields->accessibility);
3073           }
3074           break;
3075         }
3076       if (nfields < fip->nbaseclasses)
3077         {
3078           switch (fip->fields->virtuality)
3079             {
3080             case DW_VIRTUALITY_virtual:
3081             case DW_VIRTUALITY_pure_virtual:
3082               SET_TYPE_FIELD_VIRTUAL (type, nfields);
3083               break;
3084             }
3085         }
3086       fip->fields = fip->fields->next;
3087     }
3088 }
3089
3090 /* Add a member function to the proper fieldlist.  */
3091
3092 static void
3093 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
3094                       struct type *type, struct dwarf2_cu *cu)
3095 {
3096   struct objfile *objfile = cu->objfile;
3097   struct attribute *attr;
3098   struct fnfieldlist *flp;
3099   int i;
3100   struct fn_field *fnp;
3101   char *fieldname;
3102   char *physname;
3103   struct nextfnfield *new_fnfield;
3104
3105   /* Get name of member function.  */
3106   attr = dwarf2_attr (die, DW_AT_name, cu);
3107   if (attr && DW_STRING (attr))
3108     fieldname = DW_STRING (attr);
3109   else
3110     return;
3111
3112   /* Get the mangled name.  */
3113   physname = dwarf2_linkage_name (die, cu);
3114
3115   /* Look up member function name in fieldlist.  */
3116   for (i = 0; i < fip->nfnfields; i++)
3117     {
3118       if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
3119         break;
3120     }
3121
3122   /* Create new list element if necessary.  */
3123   if (i < fip->nfnfields)
3124     flp = &fip->fnfieldlists[i];
3125   else
3126     {
3127       if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
3128         {
3129           fip->fnfieldlists = (struct fnfieldlist *)
3130             xrealloc (fip->fnfieldlists,
3131                       (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
3132                       * sizeof (struct fnfieldlist));
3133           if (fip->nfnfields == 0)
3134             make_cleanup (free_current_contents, &fip->fnfieldlists);
3135         }
3136       flp = &fip->fnfieldlists[fip->nfnfields];
3137       flp->name = fieldname;
3138       flp->length = 0;
3139       flp->head = NULL;
3140       fip->nfnfields++;
3141     }
3142
3143   /* Create a new member function field and chain it to the field list
3144      entry. */
3145   new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
3146   make_cleanup (xfree, new_fnfield);
3147   memset (new_fnfield, 0, sizeof (struct nextfnfield));
3148   new_fnfield->next = flp->head;
3149   flp->head = new_fnfield;
3150   flp->length++;
3151
3152   /* Fill in the member function field info.  */
3153   fnp = &new_fnfield->fnfield;
3154   /* The name is already allocated along with this objfile, so we don't
3155      need to duplicate it for the type.  */
3156   fnp->physname = physname ? physname : "";
3157   fnp->type = alloc_type (objfile);
3158   if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
3159     {
3160       int nparams = TYPE_NFIELDS (die->type);
3161
3162       /* TYPE is the domain of this method, and DIE->TYPE is the type
3163            of the method itself (TYPE_CODE_METHOD).  */
3164       smash_to_method_type (fnp->type, type,
3165                             TYPE_TARGET_TYPE (die->type),
3166                             TYPE_FIELDS (die->type),
3167                             TYPE_NFIELDS (die->type),
3168                             TYPE_VARARGS (die->type));
3169
3170       /* Handle static member functions.
3171          Dwarf2 has no clean way to discern C++ static and non-static
3172          member functions. G++ helps GDB by marking the first
3173          parameter for non-static member functions (which is the
3174          this pointer) as artificial. We obtain this information
3175          from read_subroutine_type via TYPE_FIELD_ARTIFICIAL.  */
3176       if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
3177         fnp->voffset = VOFFSET_STATIC;
3178     }
3179   else
3180     complaint (&symfile_complaints, "member function type missing for '%s'",
3181                physname);
3182
3183   /* Get fcontext from DW_AT_containing_type if present.  */
3184   if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3185     fnp->fcontext = die_containing_type (die, cu);
3186
3187   /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3188      and is_volatile is irrelevant, as it is needed by gdb_mangle_name only.  */
3189
3190   /* Get accessibility.  */
3191   attr = dwarf2_attr (die, DW_AT_accessibility, cu);
3192   if (attr)
3193     {
3194       switch (DW_UNSND (attr))
3195         {
3196         case DW_ACCESS_private:
3197           fnp->is_private = 1;
3198           break;
3199         case DW_ACCESS_protected:
3200           fnp->is_protected = 1;
3201           break;
3202         }
3203     }
3204
3205   /* Check for artificial methods.  */
3206   attr = dwarf2_attr (die, DW_AT_artificial, cu);
3207   if (attr && DW_UNSND (attr) != 0)
3208     fnp->is_artificial = 1;
3209
3210   /* Get index in virtual function table if it is a virtual member function.  */
3211   attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
3212   if (attr)
3213     {
3214       /* Support the .debug_loc offsets */
3215       if (attr_form_is_block (attr))
3216         {
3217           fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
3218         }
3219       else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3220         {
3221           dwarf2_complex_location_expr_complaint ();
3222         }
3223       else
3224         {
3225           dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3226                                                  fieldname);
3227         }
3228    }
3229 }
3230
3231 /* Create the vector of member function fields, and attach it to the type.  */
3232
3233 static void
3234 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
3235                                  struct dwarf2_cu *cu)
3236 {
3237   struct fnfieldlist *flp;
3238   int total_length = 0;
3239   int i;
3240
3241   ALLOCATE_CPLUS_STRUCT_TYPE (type);
3242   TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
3243     TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
3244
3245   for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
3246     {
3247       struct nextfnfield *nfp = flp->head;
3248       struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
3249       int k;
3250
3251       TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
3252       TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
3253       fn_flp->fn_fields = (struct fn_field *)
3254         TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
3255       for (k = flp->length; (k--, nfp); nfp = nfp->next)
3256         fn_flp->fn_fields[k] = nfp->fnfield;
3257
3258       total_length += flp->length;
3259     }
3260
3261   TYPE_NFN_FIELDS (type) = fip->nfnfields;
3262   TYPE_NFN_FIELDS_TOTAL (type) = total_length;
3263 }
3264
3265 /* Called when we find the DIE that starts a structure or union scope
3266    (definition) to process all dies that define the members of the
3267    structure or union.
3268
3269    NOTE: we need to call struct_type regardless of whether or not the
3270    DIE has an at_name attribute, since it might be an anonymous
3271    structure or union.  This gets the type entered into our set of
3272    user defined types.
3273
3274    However, if the structure is incomplete (an opaque struct/union)
3275    then suppress creating a symbol table entry for it since gdb only
3276    wants to find the one with the complete definition.  Note that if
3277    it is complete, we just call new_symbol, which does it's own
3278    checking about whether the struct/union is anonymous or not (and
3279    suppresses creating a symbol table entry itself).  */
3280
3281 static void
3282 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
3283 {
3284   struct objfile *objfile = cu->objfile;
3285   struct type *type;
3286   struct attribute *attr;
3287   const char *previous_prefix = processing_current_prefix;
3288   struct cleanup *back_to = NULL;
3289
3290   if (die->type)
3291     return;
3292
3293   type = alloc_type (objfile);
3294
3295   INIT_CPLUS_SPECIFIC (type);
3296   attr = dwarf2_attr (die, DW_AT_name, cu);
3297   if (attr && DW_STRING (attr))
3298     {
3299       if (cu->language == language_cplus)
3300         {
3301           char *new_prefix = determine_class_name (die, cu);
3302           TYPE_TAG_NAME (type) = obsavestring (new_prefix,
3303                                                strlen (new_prefix),
3304                                                &objfile->objfile_obstack);
3305           back_to = make_cleanup (xfree, new_prefix);
3306           processing_current_prefix = new_prefix;
3307         }
3308       else
3309         {
3310           /* The name is already allocated along with this objfile, so
3311              we don't need to duplicate it for the type.  */
3312           TYPE_TAG_NAME (type) = DW_STRING (attr);
3313         }
3314     }
3315
3316   if (die->tag == DW_TAG_structure_type)
3317     {
3318       TYPE_CODE (type) = TYPE_CODE_STRUCT;
3319     }
3320   else if (die->tag == DW_TAG_union_type)
3321     {
3322       TYPE_CODE (type) = TYPE_CODE_UNION;
3323     }
3324   else
3325     {
3326       /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3327          in gdbtypes.h.  */
3328       TYPE_CODE (type) = TYPE_CODE_CLASS;
3329     }
3330
3331   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3332   if (attr)
3333     {
3334       TYPE_LENGTH (type) = DW_UNSND (attr);
3335     }
3336   else
3337     {
3338       TYPE_LENGTH (type) = 0;
3339     }
3340
3341   if (die_is_declaration (die, cu))
3342     TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
3343
3344   /* We need to add the type field to the die immediately so we don't
3345      infinitely recurse when dealing with pointers to the structure
3346      type within the structure itself. */
3347   die->type = type;
3348
3349   if (die->child != NULL && ! die_is_declaration (die, cu))
3350     {
3351       struct field_info fi;
3352       struct die_info *child_die;
3353       struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
3354
3355       memset (&fi, 0, sizeof (struct field_info));
3356
3357       child_die = die->child;
3358
3359       while (child_die && child_die->tag)
3360         {
3361           if (child_die->tag == DW_TAG_member
3362               || child_die->tag == DW_TAG_variable)
3363             {
3364               /* NOTE: carlton/2002-11-05: A C++ static data member
3365                  should be a DW_TAG_member that is a declaration, but
3366                  all versions of G++ as of this writing (so through at
3367                  least 3.2.1) incorrectly generate DW_TAG_variable
3368                  tags for them instead.  */
3369               dwarf2_add_field (&fi, child_die, cu);
3370             }
3371           else if (child_die->tag == DW_TAG_subprogram)
3372             {
3373               /* C++ member function. */
3374               read_type_die (child_die, cu);
3375               dwarf2_add_member_fn (&fi, child_die, type, cu);
3376             }
3377           else if (child_die->tag == DW_TAG_inheritance)
3378             {
3379               /* C++ base class field.  */
3380               dwarf2_add_field (&fi, child_die, cu);
3381             }
3382           child_die = sibling_die (child_die);
3383         }
3384
3385       /* Attach fields and member functions to the type.  */
3386       if (fi.nfields)
3387         dwarf2_attach_fields_to_type (&fi, type, cu);
3388       if (fi.nfnfields)
3389         {
3390           dwarf2_attach_fn_fields_to_type (&fi, type, cu);
3391
3392           /* Get the type which refers to the base class (possibly this
3393              class itself) which contains the vtable pointer for the current
3394              class from the DW_AT_containing_type attribute.  */
3395
3396           if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
3397             {
3398               struct type *t = die_containing_type (die, cu);
3399
3400               TYPE_VPTR_BASETYPE (type) = t;
3401               if (type == t)
3402                 {
3403                   static const char vptr_name[] =
3404                   {'_', 'v', 'p', 't', 'r', '\0'};
3405                   int i;
3406
3407                   /* Our own class provides vtbl ptr.  */
3408                   for (i = TYPE_NFIELDS (t) - 1;
3409                        i >= TYPE_N_BASECLASSES (t);
3410                        --i)
3411                     {
3412                       char *fieldname = TYPE_FIELD_NAME (t, i);
3413
3414                       if ((strncmp (fieldname, vptr_name,
3415                                     strlen (vptr_name) - 1)
3416                            == 0)
3417                           && is_cplus_marker (fieldname[strlen (vptr_name)]))
3418                         {
3419                           TYPE_VPTR_FIELDNO (type) = i;
3420                           break;
3421                         }
3422                     }
3423
3424                   /* Complain if virtual function table field not found.  */
3425                   if (i < TYPE_N_BASECLASSES (t))
3426                     complaint (&symfile_complaints,
3427                                "virtual function table pointer not found when defining class '%s'",
3428                                TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
3429                                "");
3430                 }
3431               else
3432                 {
3433                   TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3434                 }
3435             }
3436         }
3437
3438       do_cleanups (back_to);
3439     }
3440
3441   processing_current_prefix = previous_prefix;
3442   if (back_to != NULL)
3443     do_cleanups (back_to);
3444 }
3445
3446 static void
3447 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
3448 {
3449   struct objfile *objfile = cu->objfile;
3450   const char *previous_prefix = processing_current_prefix;
3451   struct die_info *child_die = die->child;
3452
3453   if (TYPE_TAG_NAME (die->type) != NULL)
3454     processing_current_prefix = TYPE_TAG_NAME (die->type);
3455
3456   /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3457      snapshots) has been known to create a die giving a declaration
3458      for a class that has, as a child, a die giving a definition for a
3459      nested class.  So we have to process our children even if the
3460      current die is a declaration.  Normally, of course, a declaration
3461      won't have any children at all.  */
3462
3463   while (child_die != NULL && child_die->tag)
3464     {
3465       if (child_die->tag == DW_TAG_member
3466           || child_die->tag == DW_TAG_variable
3467           || child_die->tag == DW_TAG_inheritance)
3468         {
3469           /* Do nothing.  */
3470         }
3471       else
3472         process_die (child_die, cu);
3473
3474       child_die = sibling_die (child_die);
3475     }
3476
3477   if (die->child != NULL && ! die_is_declaration (die, cu))
3478     new_symbol (die, die->type, cu);
3479
3480   processing_current_prefix = previous_prefix;
3481 }
3482
3483 /* Given a DW_AT_enumeration_type die, set its type.  We do not
3484    complete the type's fields yet, or create any symbols.  */
3485
3486 static void
3487 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
3488 {
3489   struct objfile *objfile = cu->objfile;
3490   struct type *type;
3491   struct attribute *attr;
3492
3493   if (die->type)
3494     return;
3495
3496   type = alloc_type (objfile);
3497
3498   TYPE_CODE (type) = TYPE_CODE_ENUM;
3499   attr = dwarf2_attr (die, DW_AT_name, cu);
3500   if (attr && DW_STRING (attr))
3501     {
3502       char *name = DW_STRING (attr);
3503
3504       if (processing_has_namespace_info)
3505         {
3506           TYPE_TAG_NAME (type) = obconcat (&objfile->objfile_obstack,
3507                                            processing_current_prefix,
3508                                            processing_current_prefix[0] == '\0'
3509                                            ? "" : "::",
3510                                            name);
3511         }
3512       else
3513         {
3514           /* The name is already allocated along with this objfile, so
3515              we don't need to duplicate it for the type.  */
3516           TYPE_TAG_NAME (type) = name;
3517         }
3518     }
3519
3520   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3521   if (attr)
3522     {
3523       TYPE_LENGTH (type) = DW_UNSND (attr);
3524     }
3525   else
3526     {
3527       TYPE_LENGTH (type) = 0;
3528     }
3529
3530   die->type = type;
3531 }
3532
3533 /* Determine the name of the type represented by DIE, which should be
3534    a named C++ compound type.  Return the name in question; the caller
3535    is responsible for xfree()'ing it.  */
3536
3537 static char *
3538 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
3539 {
3540   struct cleanup *back_to = NULL;
3541   struct die_info *spec_die = die_specification (die, cu);
3542   char *new_prefix = NULL;
3543
3544   /* If this is the definition of a class that is declared by another
3545      die, then processing_current_prefix may not be accurate; see
3546      read_func_scope for a similar example.  */
3547   if (spec_die != NULL)
3548     {
3549       char *specification_prefix = determine_prefix (spec_die, cu);
3550       processing_current_prefix = specification_prefix;
3551       back_to = make_cleanup (xfree, specification_prefix);
3552     }
3553
3554   /* If we don't have namespace debug info, guess the name by trying
3555      to demangle the names of members, just like we did in
3556      guess_structure_name.  */
3557   if (!processing_has_namespace_info)
3558     {
3559       struct die_info *child;
3560
3561       for (child = die->child;
3562            child != NULL && child->tag != 0;
3563            child = sibling_die (child))
3564         {
3565           if (child->tag == DW_TAG_subprogram)
3566             {
3567               new_prefix = class_name_from_physname (dwarf2_linkage_name
3568                                                      (child, cu));
3569
3570               if (new_prefix != NULL)
3571                 break;
3572             }
3573         }
3574     }
3575
3576   if (new_prefix == NULL)
3577     {
3578       const char *name = dwarf2_name (die, cu);
3579       new_prefix = typename_concat (processing_current_prefix,
3580                                     name ? name : "<<anonymous>>");
3581     }
3582
3583   if (back_to != NULL)
3584     do_cleanups (back_to);
3585
3586   return new_prefix;
3587 }
3588
3589 /* Given a pointer to a die which begins an enumeration, process all
3590    the dies that define the members of the enumeration, and create the
3591    symbol for the enumeration type.
3592
3593    NOTE: We reverse the order of the element list.  */
3594
3595 static void
3596 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
3597 {
3598   struct objfile *objfile = cu->objfile;
3599   struct die_info *child_die;
3600   struct field *fields;
3601   struct attribute *attr;
3602   struct symbol *sym;
3603   int num_fields;
3604   int unsigned_enum = 1;
3605
3606   num_fields = 0;
3607   fields = NULL;
3608   if (die->child != NULL)
3609     {
3610       child_die = die->child;
3611       while (child_die && child_die->tag)
3612         {
3613           if (child_die->tag != DW_TAG_enumerator)
3614             {
3615               process_die (child_die, cu);
3616             }
3617           else
3618             {
3619               attr = dwarf2_attr (child_die, DW_AT_name, cu);
3620               if (attr)
3621                 {
3622                   sym = new_symbol (child_die, die->type, cu);
3623                   if (SYMBOL_VALUE (sym) < 0)
3624                     unsigned_enum = 0;
3625
3626                   if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
3627                     {
3628                       fields = (struct field *)
3629                         xrealloc (fields,
3630                                   (num_fields + DW_FIELD_ALLOC_CHUNK)
3631                                   * sizeof (struct field));
3632                     }
3633
3634                   FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
3635                   FIELD_TYPE (fields[num_fields]) = NULL;
3636                   FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
3637                   FIELD_BITSIZE (fields[num_fields]) = 0;
3638                   FIELD_STATIC_KIND (fields[num_fields]) = 0;
3639
3640                   num_fields++;
3641                 }
3642             }
3643
3644           child_die = sibling_die (child_die);
3645         }
3646
3647       if (num_fields)
3648         {
3649           TYPE_NFIELDS (die->type) = num_fields;
3650           TYPE_FIELDS (die->type) = (struct field *)
3651             TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
3652           memcpy (TYPE_FIELDS (die->type), fields,
3653                   sizeof (struct field) * num_fields);
3654           xfree (fields);
3655         }
3656       if (unsigned_enum)
3657         TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
3658     }
3659
3660   new_symbol (die, die->type, cu);
3661 }
3662
3663 /* Extract all information from a DW_TAG_array_type DIE and put it in
3664    the DIE's type field.  For now, this only handles one dimensional
3665    arrays.  */
3666
3667 static void
3668 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
3669 {
3670   struct objfile *objfile = cu->objfile;
3671   struct die_info *child_die;
3672   struct type *type = NULL;
3673   struct type *element_type, *range_type, *index_type;
3674   struct type **range_types = NULL;
3675   struct attribute *attr;
3676   int ndim = 0;
3677   struct cleanup *back_to;
3678
3679   /* Return if we've already decoded this type. */
3680   if (die->type)
3681     {
3682       return;
3683     }
3684
3685   element_type = die_type (die, cu);
3686
3687   /* Irix 6.2 native cc creates array types without children for
3688      arrays with unspecified length.  */
3689   if (die->child == NULL)
3690     {
3691       index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
3692       range_type = create_range_type (NULL, index_type, 0, -1);
3693       die->type = create_array_type (NULL, element_type, range_type);
3694       return;
3695     }
3696
3697   back_to = make_cleanup (null_cleanup, NULL);
3698   child_die = die->child;
3699   while (child_die && child_die->tag)
3700     {
3701       if (child_die->tag == DW_TAG_subrange_type)
3702         {
3703           read_subrange_type (child_die, cu);
3704
3705           if (child_die->type != NULL)
3706             {
3707               /* The range type was succesfully read. Save it for
3708                  the array type creation.  */
3709               if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
3710                 {
3711                   range_types = (struct type **)
3712                     xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
3713                               * sizeof (struct type *));
3714                   if (ndim == 0)
3715                     make_cleanup (free_current_contents, &range_types);
3716                 }
3717               range_types[ndim++] = child_die->type;
3718             }
3719         }
3720       child_die = sibling_die (child_die);
3721     }
3722
3723   /* Dwarf2 dimensions are output from left to right, create the
3724      necessary array types in backwards order.  */
3725   type = element_type;
3726   while (ndim-- > 0)
3727     type = create_array_type (NULL, type, range_types[ndim]);
3728
3729   /* Understand Dwarf2 support for vector types (like they occur on
3730      the PowerPC w/ AltiVec).  Gcc just adds another attribute to the
3731      array type.  This is not part of the Dwarf2/3 standard yet, but a
3732      custom vendor extension.  The main difference between a regular
3733      array and the vector variant is that vectors are passed by value
3734      to functions.  */
3735   attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
3736   if (attr)
3737     TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
3738
3739   do_cleanups (back_to);
3740
3741   /* Install the type in the die. */
3742   die->type = type;
3743 }
3744
3745 /* First cut: install each common block member as a global variable.  */
3746
3747 static void
3748 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
3749 {
3750   struct die_info *child_die;
3751   struct attribute *attr;
3752   struct symbol *sym;
3753   CORE_ADDR base = (CORE_ADDR) 0;
3754
3755   attr = dwarf2_attr (die, DW_AT_location, cu);
3756   if (attr)
3757     {
3758       /* Support the .debug_loc offsets */
3759       if (attr_form_is_block (attr))
3760         {
3761           base = decode_locdesc (DW_BLOCK (attr), cu);
3762         }
3763       else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3764         {
3765           dwarf2_complex_location_expr_complaint ();
3766         }
3767       else
3768         {
3769           dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3770                                                  "common block member");
3771         }
3772     }
3773   if (die->child != NULL)
3774     {
3775       child_die = die->child;
3776       while (child_die && child_die->tag)
3777         {
3778           sym = new_symbol (child_die, NULL, cu);
3779           attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
3780           if (attr)
3781             {
3782               SYMBOL_VALUE_ADDRESS (sym) =
3783                 base + decode_locdesc (DW_BLOCK (attr), cu);
3784               add_symbol_to_list (sym, &global_symbols);
3785             }
3786           child_die = sibling_die (child_die);
3787         }
3788     }
3789 }
3790
3791 /* Read a C++ namespace.  */
3792
3793 static void
3794 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
3795 {
3796   struct objfile *objfile = cu->objfile;
3797   const char *previous_prefix = processing_current_prefix;
3798   const char *name;
3799   int is_anonymous;
3800   struct die_info *current_die;
3801
3802   name = namespace_name (die, &is_anonymous, cu);
3803
3804   /* Now build the name of the current namespace.  */
3805
3806   if (previous_prefix[0] == '\0')
3807     {
3808       processing_current_prefix = name;
3809     }
3810   else
3811     {
3812       /* We need temp_name around because processing_current_prefix
3813          is a const char *.  */
3814       char *temp_name = alloca (strlen (previous_prefix)
3815                                 + 2 + strlen(name) + 1);
3816       strcpy (temp_name, previous_prefix);
3817       strcat (temp_name, "::");
3818       strcat (temp_name, name);
3819
3820       processing_current_prefix = temp_name;
3821     }
3822
3823   /* Add a symbol associated to this if we haven't seen the namespace
3824      before.  Also, add a using directive if it's an anonymous
3825      namespace.  */
3826
3827   if (dwarf2_extension (die, cu) == NULL)
3828     {
3829       struct type *type;
3830
3831       /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
3832          this cast will hopefully become unnecessary.  */
3833       type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
3834                         (char *) processing_current_prefix,
3835                         objfile);
3836       TYPE_TAG_NAME (type) = TYPE_NAME (type);
3837
3838       new_symbol (die, type, cu);
3839       die->type = type;
3840
3841       if (is_anonymous)
3842         cp_add_using_directive (processing_current_prefix,
3843                                 strlen (previous_prefix),
3844                                 strlen (processing_current_prefix));
3845     }
3846
3847   if (die->child != NULL)
3848     {
3849       struct die_info *child_die = die->child;
3850
3851       while (child_die && child_die->tag)
3852         {
3853           process_die (child_die, cu);
3854           child_die = sibling_die (child_die);
3855         }
3856     }
3857
3858   processing_current_prefix = previous_prefix;
3859 }
3860
3861 /* Return the name of the namespace represented by DIE.  Set
3862    *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
3863    namespace.  */
3864
3865 static const char *
3866 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
3867 {
3868   struct die_info *current_die;
3869   const char *name = NULL;
3870
3871   /* Loop through the extensions until we find a name.  */
3872
3873   for (current_die = die;
3874        current_die != NULL;
3875        current_die = dwarf2_extension (die, cu))
3876     {
3877       name = dwarf2_name (current_die, cu);
3878       if (name != NULL)
3879         break;
3880     }
3881
3882   /* Is it an anonymous namespace?  */
3883
3884   *is_anonymous = (name == NULL);
3885   if (*is_anonymous)
3886     name = "(anonymous namespace)";
3887
3888   return name;
3889 }
3890
3891 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3892    the user defined type vector.  */
3893
3894 static void
3895 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
3896 {
3897   struct comp_unit_head *cu_header = &cu->header;
3898   struct type *type;
3899   struct attribute *attr_byte_size;
3900   struct attribute *attr_address_class;
3901   int byte_size, addr_class;
3902
3903   if (die->type)
3904     {
3905       return;
3906     }
3907
3908   type = lookup_pointer_type (die_type (die, cu));
3909
3910   attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
3911   if (attr_byte_size)
3912     byte_size = DW_UNSND (attr_byte_size);
3913   else
3914     byte_size = cu_header->addr_size;
3915
3916   attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
3917   if (attr_address_class)
3918     addr_class = DW_UNSND (attr_address_class);
3919   else
3920     addr_class = DW_ADDR_none;
3921
3922   /* If the pointer size or address class is different than the
3923      default, create a type variant marked as such and set the
3924      length accordingly.  */
3925   if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
3926     {
3927       if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3928         {
3929           int type_flags;
3930
3931           type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
3932           gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
3933           type = make_type_with_address_space (type, type_flags);
3934         }
3935       else if (TYPE_LENGTH (type) != byte_size)
3936         {
3937           complaint (&symfile_complaints, "invalid pointer size %d", byte_size);
3938         }
3939       else {
3940         /* Should we also complain about unhandled address classes?  */
3941       }
3942     }
3943
3944   TYPE_LENGTH (type) = byte_size;
3945   die->type = type;
3946 }
3947
3948 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3949    the user defined type vector.  */
3950
3951 static void
3952 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
3953 {
3954   struct objfile *objfile = cu->objfile;
3955   struct type *type;
3956   struct type *to_type;
3957   struct type *domain;
3958
3959   if (die->type)
3960     {
3961       return;
3962     }
3963
3964   type = alloc_type (objfile);
3965   to_type = die_type (die, cu);
3966   domain = die_containing_type (die, cu);
3967   smash_to_member_type (type, domain, to_type);
3968
3969   die->type = type;
3970 }
3971
3972 /* Extract all information from a DW_TAG_reference_type DIE and add to
3973    the user defined type vector.  */
3974
3975 static void
3976 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
3977 {
3978   struct comp_unit_head *cu_header = &cu->header;
3979   struct type *type;
3980   struct attribute *attr;
3981
3982   if (die->type)
3983     {
3984       return;
3985     }
3986
3987   type = lookup_reference_type (die_type (die, cu));
3988   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
3989   if (attr)
3990     {
3991       TYPE_LENGTH (type) = DW_UNSND (attr);
3992     }
3993   else
3994     {
3995       TYPE_LENGTH (type) = cu_header->addr_size;
3996     }
3997   die->type = type;
3998 }
3999
4000 static void
4001 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
4002 {
4003   struct type *base_type;
4004
4005   if (die->type)
4006     {
4007       return;
4008     }
4009
4010   base_type = die_type (die, cu);
4011   die->type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
4012 }
4013
4014 static void
4015 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
4016 {
4017   struct type *base_type;
4018
4019   if (die->type)
4020     {
4021       return;
4022     }
4023
4024   base_type = die_type (die, cu);
4025   die->type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
4026 }
4027
4028 /* Extract all information from a DW_TAG_string_type DIE and add to
4029    the user defined type vector.  It isn't really a user defined type,
4030    but it behaves like one, with other DIE's using an AT_user_def_type
4031    attribute to reference it.  */
4032
4033 static void
4034 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
4035 {
4036   struct objfile *objfile = cu->objfile;
4037   struct type *type, *range_type, *index_type, *char_type;
4038   struct attribute *attr;
4039   unsigned int length;
4040
4041   if (die->type)
4042     {
4043       return;
4044     }
4045
4046   attr = dwarf2_attr (die, DW_AT_string_length, cu);
4047   if (attr)
4048     {
4049       length = DW_UNSND (attr);
4050     }
4051   else
4052     {
4053       /* check for the DW_AT_byte_size attribute */
4054       attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4055       if (attr)
4056         {
4057           length = DW_UNSND (attr);
4058         }
4059       else
4060         {
4061           length = 1;
4062         }
4063     }
4064   index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
4065   range_type = create_range_type (NULL, index_type, 1, length);
4066   if (cu->language == language_fortran)
4067     {
4068       /* Need to create a unique string type for bounds
4069          information */
4070       type = create_string_type (0, range_type);
4071     }
4072   else
4073     {
4074       char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
4075       type = create_string_type (char_type, range_type);
4076     }
4077   die->type = type;
4078 }
4079
4080 /* Handle DIES due to C code like:
4081
4082    struct foo
4083    {
4084    int (*funcp)(int a, long l);
4085    int b;
4086    };
4087
4088    ('funcp' generates a DW_TAG_subroutine_type DIE)
4089  */
4090
4091 static void
4092 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
4093 {
4094   struct type *type;            /* Type that this function returns */
4095   struct type *ftype;           /* Function that returns above type */
4096   struct attribute *attr;
4097
4098   /* Decode the type that this subroutine returns */
4099   if (die->type)
4100     {
4101       return;
4102     }
4103   type = die_type (die, cu);
4104   ftype = lookup_function_type (type);
4105
4106   /* All functions in C++ have prototypes.  */
4107   attr = dwarf2_attr (die, DW_AT_prototyped, cu);
4108   if ((attr && (DW_UNSND (attr) != 0))
4109       || cu->language == language_cplus)
4110     TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
4111
4112   if (die->child != NULL)
4113     {
4114       struct die_info *child_die;
4115       int nparams = 0;
4116       int iparams = 0;
4117
4118       /* Count the number of parameters.
4119          FIXME: GDB currently ignores vararg functions, but knows about
4120          vararg member functions.  */
4121       child_die = die->child;
4122       while (child_die && child_die->tag)
4123         {
4124           if (child_die->tag == DW_TAG_formal_parameter)
4125             nparams++;
4126           else if (child_die->tag == DW_TAG_unspecified_parameters)
4127             TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
4128           child_die = sibling_die (child_die);
4129         }
4130
4131       /* Allocate storage for parameters and fill them in.  */
4132       TYPE_NFIELDS (ftype) = nparams;
4133       TYPE_FIELDS (ftype) = (struct field *)
4134         TYPE_ALLOC (ftype, nparams * sizeof (struct field));
4135
4136       child_die = die->child;
4137       while (child_die && child_die->tag)
4138         {
4139           if (child_die->tag == DW_TAG_formal_parameter)
4140             {
4141               /* Dwarf2 has no clean way to discern C++ static and non-static
4142                  member functions. G++ helps GDB by marking the first
4143                  parameter for non-static member functions (which is the
4144                  this pointer) as artificial. We pass this information
4145                  to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.  */
4146               attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
4147               if (attr)
4148                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
4149               else
4150                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
4151               TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
4152               iparams++;
4153             }
4154           child_die = sibling_die (child_die);
4155         }
4156     }
4157
4158   die->type = ftype;
4159 }
4160
4161 static void
4162 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
4163 {
4164   struct objfile *objfile = cu->objfile;
4165   struct attribute *attr;
4166   char *name = NULL;
4167
4168   if (!die->type)
4169     {
4170       attr = dwarf2_attr (die, DW_AT_name, cu);
4171       if (attr && DW_STRING (attr))
4172         {
4173           name = DW_STRING (attr);
4174         }
4175       die->type = init_type (TYPE_CODE_TYPEDEF, 0, TYPE_FLAG_TARGET_STUB, name, objfile);
4176       TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
4177     }
4178 }
4179
4180 /* Find a representation of a given base type and install
4181    it in the TYPE field of the die.  */
4182
4183 static void
4184 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
4185 {
4186   struct objfile *objfile = cu->objfile;
4187   struct type *type;
4188   struct attribute *attr;
4189   int encoding = 0, size = 0;
4190
4191   /* If we've already decoded this die, this is a no-op. */
4192   if (die->type)
4193     {
4194       return;
4195     }
4196
4197   attr = dwarf2_attr (die, DW_AT_encoding, cu);
4198   if (attr)
4199     {
4200       encoding = DW_UNSND (attr);
4201     }
4202   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4203   if (attr)
4204     {
4205       size = DW_UNSND (attr);
4206     }
4207   attr = dwarf2_attr (die, DW_AT_name, cu);
4208   if (attr && DW_STRING (attr))
4209     {
4210       enum type_code code = TYPE_CODE_INT;
4211       int type_flags = 0;
4212
4213       switch (encoding)
4214         {
4215         case DW_ATE_address:
4216           /* Turn DW_ATE_address into a void * pointer.  */
4217           code = TYPE_CODE_PTR;
4218           type_flags |= TYPE_FLAG_UNSIGNED;
4219           break;
4220         case DW_ATE_boolean:
4221           code = TYPE_CODE_BOOL;
4222           type_flags |= TYPE_FLAG_UNSIGNED;
4223           break;
4224         case DW_ATE_complex_float:
4225           code = TYPE_CODE_COMPLEX;
4226           break;
4227         case DW_ATE_float:
4228           code = TYPE_CODE_FLT;
4229           break;
4230         case DW_ATE_signed:
4231         case DW_ATE_signed_char:
4232           break;
4233         case DW_ATE_unsigned:
4234         case DW_ATE_unsigned_char:
4235           type_flags |= TYPE_FLAG_UNSIGNED;
4236           break;
4237         default:
4238           complaint (&symfile_complaints, "unsupported DW_AT_encoding: '%s'",
4239                      dwarf_type_encoding_name (encoding));
4240           break;
4241         }
4242       type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
4243       if (encoding == DW_ATE_address)
4244         TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
4245                                                            cu);
4246       else if (encoding == DW_ATE_complex_float)
4247         {
4248           if (size == 32)
4249             TYPE_TARGET_TYPE (type)
4250               = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
4251           else if (size == 16)
4252             TYPE_TARGET_TYPE (type)
4253               = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
4254           else if (size == 8)
4255             TYPE_TARGET_TYPE (type)
4256               = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
4257         }
4258     }
4259   else
4260     {
4261       type = dwarf_base_type (encoding, size, cu);
4262     }
4263   die->type = type;
4264 }
4265
4266 /* Read the given DW_AT_subrange DIE.  */
4267
4268 static void
4269 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
4270 {
4271   struct type *base_type;
4272   struct type *range_type;
4273   struct attribute *attr;
4274   int low = 0;
4275   int high = -1;
4276
4277   /* If we have already decoded this die, then nothing more to do.  */
4278   if (die->type)
4279     return;
4280
4281   base_type = die_type (die, cu);
4282   if (base_type == NULL)
4283     {
4284       complaint (&symfile_complaints,
4285                 "DW_AT_type missing from DW_TAG_subrange_type");
4286       return;
4287     }
4288
4289   if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
4290     base_type = alloc_type (NULL);
4291
4292   if (cu->language == language_fortran)
4293     {
4294       /* FORTRAN implies a lower bound of 1, if not given.  */
4295       low = 1;
4296     }
4297
4298   attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
4299   if (attr)
4300     low = dwarf2_get_attr_constant_value (attr, 0);
4301
4302   attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
4303   if (attr)
4304     {
4305       if (attr->form == DW_FORM_block1)
4306         {
4307           /* GCC encodes arrays with unspecified or dynamic length
4308              with a DW_FORM_block1 attribute.
4309              FIXME: GDB does not yet know how to handle dynamic
4310              arrays properly, treat them as arrays with unspecified
4311              length for now.
4312
4313              FIXME: jimb/2003-09-22: GDB does not really know
4314              how to handle arrays of unspecified length
4315              either; we just represent them as zero-length
4316              arrays.  Choose an appropriate upper bound given
4317              the lower bound we've computed above.  */
4318           high = low - 1;
4319         }
4320       else
4321         high = dwarf2_get_attr_constant_value (attr, 1);
4322     }
4323
4324   range_type = create_range_type (NULL, base_type, low, high);
4325
4326   attr = dwarf2_attr (die, DW_AT_name, cu);
4327   if (attr && DW_STRING (attr))
4328     TYPE_NAME (range_type) = DW_STRING (attr);
4329
4330   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4331   if (attr)
4332     TYPE_LENGTH (range_type) = DW_UNSND (attr);
4333
4334   die->type = range_type;
4335 }
4336
4337
4338 /* Read a whole compilation unit into a linked list of dies.  */
4339
4340 static struct die_info *
4341 read_comp_unit (char *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
4342 {
4343   /* Reset die reference table; we are
4344      building new ones now.  */
4345   dwarf2_empty_hash_tables ();
4346
4347   return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
4348 }
4349
4350 /* Read a single die and all its descendents.  Set the die's sibling
4351    field to NULL; set other fields in the die correctly, and set all
4352    of the descendents' fields correctly.  Set *NEW_INFO_PTR to the
4353    location of the info_ptr after reading all of those dies.  PARENT
4354    is the parent of the die in question.  */
4355
4356 static struct die_info *
4357 read_die_and_children (char *info_ptr, bfd *abfd,
4358                        struct dwarf2_cu *cu,
4359                        char **new_info_ptr,
4360                        struct die_info *parent)
4361 {
4362   struct die_info *die;
4363   char *cur_ptr;
4364   int has_children;
4365
4366   cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
4367   store_in_ref_table (die->offset, die);
4368
4369   if (has_children)
4370     {
4371       die->child = read_die_and_siblings (cur_ptr, abfd, cu,
4372                                           new_info_ptr, die);
4373     }
4374   else
4375     {
4376       die->child = NULL;
4377       *new_info_ptr = cur_ptr;
4378     }
4379
4380   die->sibling = NULL;
4381   die->parent = parent;
4382   return die;
4383 }
4384
4385 /* Read a die, all of its descendents, and all of its siblings; set
4386    all of the fields of all of the dies correctly.  Arguments are as
4387    in read_die_and_children.  */
4388
4389 static struct die_info *
4390 read_die_and_siblings (char *info_ptr, bfd *abfd,
4391                        struct dwarf2_cu *cu,
4392                        char **new_info_ptr,
4393                        struct die_info *parent)
4394 {
4395   struct die_info *first_die, *last_sibling;
4396   char *cur_ptr;
4397
4398   cur_ptr = info_ptr;
4399   first_die = last_sibling = NULL;
4400
4401   while (1)
4402     {
4403       struct die_info *die
4404         = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
4405
4406       if (!first_die)
4407         {
4408           first_die = die;
4409         }
4410       else
4411         {
4412           last_sibling->sibling = die;
4413         }
4414
4415       if (die->tag == 0)
4416         {
4417           *new_info_ptr = cur_ptr;
4418           return first_die;
4419         }
4420       else
4421         {
4422           last_sibling = die;
4423         }
4424     }
4425 }
4426
4427 /* Free a linked list of dies.  */
4428
4429 static void
4430 free_die_list (struct die_info *dies)
4431 {
4432   struct die_info *die, *next;
4433
4434   die = dies;
4435   while (die)
4436     {
4437       if (die->child != NULL)
4438         free_die_list (die->child);
4439       next = die->sibling;
4440       xfree (die->attrs);
4441       xfree (die);
4442       die = next;
4443     }
4444 }
4445
4446 static void
4447 do_free_die_list_cleanup (void *dies)
4448 {
4449   free_die_list (dies);
4450 }
4451
4452 static struct cleanup *
4453 make_cleanup_free_die_list (struct die_info *dies)
4454 {
4455   return make_cleanup (do_free_die_list_cleanup, dies);
4456 }
4457
4458
4459 /* Read the contents of the section at OFFSET and of size SIZE from the
4460    object file specified by OBJFILE into the objfile_obstack and return it.  */
4461
4462 char *
4463 dwarf2_read_section (struct objfile *objfile, asection *sectp)
4464 {
4465   bfd *abfd = objfile->obfd;
4466   char *buf, *retbuf;
4467   bfd_size_type size = bfd_get_section_size (sectp);
4468
4469   if (size == 0)
4470     return NULL;
4471
4472   buf = (char *) obstack_alloc (&objfile->objfile_obstack, size);
4473   retbuf
4474     = (char *) symfile_relocate_debug_section (abfd, sectp, (bfd_byte *) buf);
4475   if (retbuf != NULL)
4476     return retbuf;
4477
4478   if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
4479       || bfd_bread (buf, size, abfd) != size)
4480     error ("Dwarf Error: Can't read DWARF data from '%s'",
4481            bfd_get_filename (abfd));
4482
4483   return buf;
4484 }
4485
4486 /* In DWARF version 2, the description of the debugging information is
4487    stored in a separate .debug_abbrev section.  Before we read any
4488    dies from a section we read in all abbreviations and install them
4489    in a hash table.  This function also sets flags in CU describing
4490    the data found in the abbrev table.  */
4491
4492 static void
4493 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
4494 {
4495   struct comp_unit_head *cu_header = &cu->header;
4496   char *abbrev_ptr;
4497   struct abbrev_info *cur_abbrev;
4498   unsigned int abbrev_number, bytes_read, abbrev_name;
4499   unsigned int abbrev_form, hash_number;
4500   struct attr_abbrev *cur_attrs;
4501   unsigned int allocated_attrs;
4502
4503   /* Initialize dwarf2 abbrevs */
4504   obstack_init (&cu->abbrev_obstack);
4505   cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
4506                                       (ABBREV_HASH_SIZE
4507                                        * sizeof (struct abbrev_info *)));
4508   memset (cu->dwarf2_abbrevs, 0,
4509           ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
4510
4511   abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset;
4512   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4513   abbrev_ptr += bytes_read;
4514
4515   allocated_attrs = ATTR_ALLOC_CHUNK;
4516   cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
4517
4518   /* loop until we reach an abbrev number of 0 */
4519   while (abbrev_number)
4520     {
4521       cur_abbrev = dwarf_alloc_abbrev (cu);
4522
4523       /* read in abbrev header */
4524       cur_abbrev->number = abbrev_number;
4525       cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4526       abbrev_ptr += bytes_read;
4527       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
4528       abbrev_ptr += 1;
4529
4530       if (cur_abbrev->tag == DW_TAG_namespace)
4531         cu->has_namespace_info = 1;
4532
4533       /* now read in declarations */
4534       abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4535       abbrev_ptr += bytes_read;
4536       abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4537       abbrev_ptr += bytes_read;
4538       while (abbrev_name)
4539         {
4540           if (cur_abbrev->num_attrs == allocated_attrs)
4541             {
4542               allocated_attrs += ATTR_ALLOC_CHUNK;
4543               cur_attrs
4544                 = xrealloc (cur_attrs, (allocated_attrs
4545                                         * sizeof (struct attr_abbrev)));
4546             }
4547           cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
4548           cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
4549           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4550           abbrev_ptr += bytes_read;
4551           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4552           abbrev_ptr += bytes_read;
4553         }
4554
4555       cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
4556                                          (cur_abbrev->num_attrs
4557                                           * sizeof (struct attr_abbrev)));
4558       memcpy (cur_abbrev->attrs, cur_attrs,
4559               cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
4560
4561       hash_number = abbrev_number % ABBREV_HASH_SIZE;
4562       cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
4563       cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
4564
4565       /* Get next abbreviation.
4566          Under Irix6 the abbreviations for a compilation unit are not
4567          always properly terminated with an abbrev number of 0.
4568          Exit loop if we encounter an abbreviation which we have
4569          already read (which means we are about to read the abbreviations
4570          for the next compile unit) or if the end of the abbreviation
4571          table is reached.  */
4572       if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer)
4573           >= dwarf2_per_objfile->abbrev_size)
4574         break;
4575       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
4576       abbrev_ptr += bytes_read;
4577       if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
4578         break;
4579     }
4580
4581   xfree (cur_attrs);
4582 }
4583
4584 /* Release the memory used by the abbrev table for a compilation unit.  */
4585
4586 static void
4587 dwarf2_free_abbrev_table (void *ptr_to_cu)
4588 {
4589   struct dwarf2_cu *cu = ptr_to_cu;
4590
4591   obstack_free (&cu->abbrev_obstack, NULL);
4592   cu->dwarf2_abbrevs = NULL;
4593 }
4594
4595 /* Lookup an abbrev_info structure in the abbrev hash table.  */
4596
4597 static struct abbrev_info *
4598 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
4599 {
4600   unsigned int hash_number;
4601   struct abbrev_info *abbrev;
4602
4603   hash_number = number % ABBREV_HASH_SIZE;
4604   abbrev = cu->dwarf2_abbrevs[hash_number];
4605
4606   while (abbrev)
4607     {
4608       if (abbrev->number == number)
4609         return abbrev;
4610       else
4611         abbrev = abbrev->next;
4612     }
4613   return NULL;
4614 }
4615
4616 /* Returns nonzero if TAG represents a type that we might generate a partial
4617    symbol for.  */
4618
4619 static int
4620 is_type_tag_for_partial (int tag)
4621 {
4622   switch (tag)
4623     {
4624 #if 0
4625     /* Some types that would be reasonable to generate partial symbols for,
4626        that we don't at present.  */
4627     case DW_TAG_array_type:
4628     case DW_TAG_file_type:
4629     case DW_TAG_ptr_to_member_type:
4630     case DW_TAG_set_type:
4631     case DW_TAG_string_type:
4632     case DW_TAG_subroutine_type:
4633 #endif
4634     case DW_TAG_base_type:
4635     case DW_TAG_class_type:
4636     case DW_TAG_enumeration_type:
4637     case DW_TAG_structure_type:
4638     case DW_TAG_subrange_type:
4639     case DW_TAG_typedef:
4640     case DW_TAG_union_type:
4641       return 1;
4642     default:
4643       return 0;
4644     }
4645 }
4646
4647 /* Load all DIEs that are interesting for partial symbols into memory.  */
4648
4649 static struct partial_die_info *
4650 load_partial_dies (bfd *abfd, char *info_ptr, int building_psymtab,
4651                    struct dwarf2_cu *cu)
4652 {
4653   struct partial_die_info *part_die;
4654   struct partial_die_info *parent_die, *last_die, *first_die = NULL;
4655   struct abbrev_info *abbrev;
4656   unsigned int bytes_read;
4657
4658   int nesting_level = 1;
4659
4660   parent_die = NULL;
4661   last_die = NULL;
4662
4663   cu->partial_dies
4664     = htab_create_alloc_ex (cu->header.length / 12,
4665                             partial_die_hash,
4666                             partial_die_eq,
4667                             NULL,
4668                             &cu->comp_unit_obstack,
4669                             hashtab_obstack_allocate,
4670                             dummy_obstack_deallocate);
4671
4672   part_die = obstack_alloc (&cu->comp_unit_obstack,
4673                             sizeof (struct partial_die_info));
4674
4675   while (1)
4676     {
4677       abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
4678
4679       /* A NULL abbrev means the end of a series of children.  */
4680       if (abbrev == NULL)
4681         {
4682           if (--nesting_level == 0)
4683             {
4684               /* PART_DIE was probably the last thing allocated on the
4685                  comp_unit_obstack, so we could call obstack_free
4686                  here.  We don't do that because the waste is small,
4687                  and will be cleaned up when we're done with this
4688                  compilation unit.  This way, we're also more robust
4689                  against other users of the comp_unit_obstack.  */
4690               return first_die;
4691             }
4692           info_ptr += bytes_read;
4693           last_die = parent_die;
4694           parent_die = parent_die->die_parent;
4695           continue;
4696         }
4697
4698       /* Check whether this DIE is interesting enough to save.  */
4699       if (!is_type_tag_for_partial (abbrev->tag)
4700           && abbrev->tag != DW_TAG_enumerator
4701           && abbrev->tag != DW_TAG_subprogram
4702           && abbrev->tag != DW_TAG_variable
4703           && abbrev->tag != DW_TAG_namespace)
4704         {
4705           /* Otherwise we skip to the next sibling, if any.  */
4706           info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
4707           continue;
4708         }
4709
4710       info_ptr = read_partial_die (part_die, abbrev, bytes_read,
4711                                    abfd, info_ptr, cu);
4712
4713       /* This two-pass algorithm for processing partial symbols has a
4714          high cost in cache pressure.  Thus, handle some simple cases
4715          here which cover the majority of C partial symbols.  DIEs
4716          which neither have specification tags in them, nor could have
4717          specification tags elsewhere pointing at them, can simply be
4718          processed and discarded.
4719
4720          This segment is also optional; scan_partial_symbols and
4721          add_partial_symbol will handle these DIEs if we chain
4722          them in normally.  When compilers which do not emit large
4723          quantities of duplicate debug information are more common,
4724          this code can probably be removed.  */
4725
4726       /* Any complete simple types at the top level (pretty much all
4727          of them, for a language without namespaces), can be processed
4728          directly.  */
4729       if (parent_die == NULL
4730           && part_die->has_specification == 0
4731           && part_die->is_declaration == 0
4732           && (part_die->tag == DW_TAG_typedef
4733               || part_die->tag == DW_TAG_base_type
4734               || part_die->tag == DW_TAG_subrange_type))
4735         {
4736           if (building_psymtab && part_die->name != NULL)
4737             add_psymbol_to_list (part_die->name, strlen (part_die->name),
4738                                  VAR_DOMAIN, LOC_TYPEDEF,
4739                                  &cu->objfile->static_psymbols,
4740                                  0, (CORE_ADDR) 0, cu->language, cu->objfile);
4741           info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
4742           continue;
4743         }
4744
4745       /* If we're at the second level, and we're an enumerator, and
4746          our parent has no specification (meaning possibly lives in a
4747          namespace elsewhere), then we can add the partial symbol now
4748          instead of queueing it.  */
4749       if (part_die->tag == DW_TAG_enumerator
4750           && parent_die != NULL
4751           && parent_die->die_parent == NULL
4752           && parent_die->tag == DW_TAG_enumeration_type
4753           && parent_die->has_specification == 0)
4754         {
4755           if (part_die->name == NULL)
4756             complaint (&symfile_complaints, "malformed enumerator DIE ignored");
4757           else if (building_psymtab)
4758             add_psymbol_to_list (part_die->name, strlen (part_die->name),
4759                                  VAR_DOMAIN, LOC_CONST,
4760                                  cu->language == language_cplus
4761                                  ? &cu->objfile->global_psymbols
4762                                  : &cu->objfile->static_psymbols,
4763                                  0, (CORE_ADDR) 0, cu->language, cu->objfile);
4764
4765           info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
4766           continue;
4767         }
4768
4769       /* We'll save this DIE so link it in.  */
4770       part_die->die_parent = parent_die;
4771       part_die->die_sibling = NULL;
4772       part_die->die_child = NULL;
4773
4774       if (last_die && last_die == parent_die)
4775         last_die->die_child = part_die;
4776       else if (last_die)
4777         last_die->die_sibling = part_die;
4778
4779       last_die = part_die;
4780
4781       if (first_die == NULL)
4782         first_die = part_die;
4783
4784       /* Maybe add the DIE to the hash table.  Not all DIEs that we
4785          find interesting need to be in the hash table, because we
4786          also have the parent/sibling/child chains; only those that we
4787          might refer to by offset later during partial symbol reading.
4788
4789          For now this means things that might have be the target of a
4790          DW_AT_specification, DW_AT_abstract_origin, or
4791          DW_AT_extension.  DW_AT_extension will refer only to
4792          namespaces; DW_AT_abstract_origin refers to functions (and
4793          many things under the function DIE, but we do not recurse
4794          into function DIEs during partial symbol reading) and
4795          possibly variables as well; DW_AT_specification refers to
4796          declarations.  Declarations ought to have the DW_AT_declaration
4797          flag.  It happens that GCC forgets to put it in sometimes, but
4798          only for functions, not for types.
4799
4800          Adding more things than necessary to the hash table is harmless
4801          except for the performance cost.  Adding too few will result in
4802          internal errors in find_partial_die.  */
4803
4804       if (abbrev->tag == DW_TAG_subprogram
4805           || abbrev->tag == DW_TAG_variable
4806           || abbrev->tag == DW_TAG_namespace
4807           || part_die->is_declaration)
4808         {
4809           void **slot;
4810
4811           slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
4812                                            part_die->offset, INSERT);
4813           *slot = part_die;
4814         }
4815
4816       part_die = obstack_alloc (&cu->comp_unit_obstack,
4817                                 sizeof (struct partial_die_info));
4818
4819       /* For some DIEs we want to follow their children (if any).  For C
4820          we have no reason to follow the children of structures; for other
4821          languages we have to, both so that we can get at method physnames
4822          to infer fully qualified class names, and for DW_AT_specification.  */
4823       if (last_die->has_children
4824           && (last_die->tag == DW_TAG_namespace
4825               || last_die->tag == DW_TAG_enumeration_type
4826               || (cu->language != language_c
4827                   && (last_die->tag == DW_TAG_class_type
4828                       || last_die->tag == DW_TAG_structure_type
4829                       || last_die->tag == DW_TAG_union_type))))
4830         {
4831           nesting_level++;
4832           parent_die = last_die;
4833           continue;
4834         }
4835
4836       /* Otherwise we skip to the next sibling, if any.  */
4837       info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu);
4838
4839       /* Back to the top, do it again.  */
4840     }
4841 }
4842
4843 /* Read a minimal amount of information into the minimal die structure.  */
4844
4845 static char *
4846 read_partial_die (struct partial_die_info *part_die,
4847                   struct abbrev_info *abbrev,
4848                   unsigned int abbrev_len, bfd *abfd,
4849                   char *info_ptr, struct dwarf2_cu *cu)
4850 {
4851   unsigned int bytes_read, i;
4852   struct attribute attr;
4853   int has_low_pc_attr = 0;
4854   int has_high_pc_attr = 0;
4855
4856   memset (part_die, 0, sizeof (struct partial_die_info));
4857
4858   part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer;
4859
4860   info_ptr += abbrev_len;
4861
4862   if (abbrev == NULL)
4863     return info_ptr;
4864
4865   part_die->tag = abbrev->tag;
4866   part_die->has_children = abbrev->has_children;
4867
4868   for (i = 0; i < abbrev->num_attrs; ++i)
4869     {
4870       info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
4871
4872       /* Store the data if it is of an attribute we want to keep in a
4873          partial symbol table.  */
4874       switch (attr.name)
4875         {
4876         case DW_AT_name:
4877
4878           /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
4879           if (part_die->name == NULL)
4880             part_die->name = DW_STRING (&attr);
4881           break;
4882         case DW_AT_comp_dir:
4883           if (part_die->dirname == NULL)
4884             part_die->dirname = DW_STRING (&attr);
4885           break;
4886         case DW_AT_MIPS_linkage_name:
4887           part_die->name = DW_STRING (&attr);
4888           break;
4889         case DW_AT_low_pc:
4890           has_low_pc_attr = 1;
4891           part_die->lowpc = DW_ADDR (&attr);
4892           break;
4893         case DW_AT_high_pc:
4894           has_high_pc_attr = 1;
4895           part_die->highpc = DW_ADDR (&attr);
4896           break;
4897         case DW_AT_location:
4898           /* Support the .debug_loc offsets */
4899           if (attr_form_is_block (&attr))
4900             {
4901                part_die->locdesc = DW_BLOCK (&attr);
4902             }
4903           else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
4904             {
4905               dwarf2_complex_location_expr_complaint ();
4906             }
4907           else
4908             {
4909               dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4910                                                      "partial symbol information");
4911             }
4912           break;
4913         case DW_AT_language:
4914           part_die->language = DW_UNSND (&attr);
4915           break;
4916         case DW_AT_external:
4917           part_die->is_external = DW_UNSND (&attr);
4918           break;
4919         case DW_AT_declaration:
4920           part_die->is_declaration = DW_UNSND (&attr);
4921           break;
4922         case DW_AT_type:
4923           part_die->has_type = 1;
4924           break;
4925         case DW_AT_abstract_origin:
4926         case DW_AT_specification:
4927         case DW_AT_extension:
4928           part_die->has_specification = 1;
4929           part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu);
4930           break;
4931         case DW_AT_sibling:
4932           /* Ignore absolute siblings, they might point outside of
4933              the current compile unit.  */
4934           if (attr.form == DW_FORM_ref_addr)
4935             complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling");
4936           else
4937             part_die->sibling = dwarf2_per_objfile->info_buffer
4938               + dwarf2_get_ref_die_offset (&attr, cu);
4939           break;
4940         case DW_AT_stmt_list:
4941           part_die->has_stmt_list = 1;
4942           part_die->line_offset = DW_UNSND (&attr);
4943           break;
4944         default:
4945           break;
4946         }
4947     }
4948
4949   /* When using the GNU linker, .gnu.linkonce. sections are used to
4950      eliminate duplicate copies of functions and vtables and such.
4951      The linker will arbitrarily choose one and discard the others.
4952      The AT_*_pc values for such functions refer to local labels in
4953      these sections.  If the section from that file was discarded, the
4954      labels are not in the output, so the relocs get a value of 0.
4955      If this is a discarded function, mark the pc bounds as invalid,
4956      so that GDB will ignore it.  */
4957   if (has_low_pc_attr && has_high_pc_attr
4958       && part_die->lowpc < part_die->highpc
4959       && (part_die->lowpc != 0
4960           || (bfd_get_file_flags (abfd) & HAS_RELOC)))
4961     part_die->has_pc_info = 1;
4962   return info_ptr;
4963 }
4964
4965 /* Find a cached partial DIE at OFFSET in CU.  */
4966
4967 static struct partial_die_info *
4968 find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu)
4969 {
4970   struct partial_die_info *lookup_die = NULL;
4971   struct partial_die_info part_die;
4972
4973   part_die.offset = offset;
4974   lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
4975
4976   if (lookup_die == NULL)
4977     internal_error (__FILE__, __LINE__,
4978                     "could not find partial DIE in cache\n");
4979
4980   return lookup_die;
4981 }
4982
4983 /* Find a partial DIE at OFFSET, which may or may not be in CU.  */
4984
4985 static struct partial_die_info *
4986 find_partial_die (unsigned long offset, struct dwarf2_cu *cu,
4987                   struct dwarf2_cu **target_cu)
4988 {
4989   struct dwarf2_per_cu_data *per_cu;
4990
4991   if (offset >= cu->header.offset
4992       && offset < cu->header.offset + cu->header.length)
4993     {
4994       *target_cu = cu;
4995       return find_partial_die_in_comp_unit (offset, cu);
4996     }
4997
4998   internal_error (__FILE__, __LINE__,
4999                   "unsupported inter-compilation-unit reference");
5000 }
5001
5002 /* Adjust PART_DIE before generating a symbol for it.  This function
5003    may set the is_external flag or change the DIE's name.  */
5004
5005 static void
5006 fixup_partial_die (struct partial_die_info *part_die,
5007                    struct dwarf2_cu *cu)
5008 {
5009   /* If we found a reference attribute and the DIE has no name, try
5010      to find a name in the referred to DIE.  */
5011
5012   if (part_die->name == NULL && part_die->has_specification)
5013     {
5014       struct partial_die_info *spec_die;
5015       struct dwarf2_cu *spec_cu;
5016
5017       spec_die = find_partial_die (part_die->spec_offset, cu, &spec_cu);
5018
5019       fixup_partial_die (spec_die, spec_cu);
5020
5021       if (spec_die->name)
5022         {
5023           part_die->name = spec_die->name;
5024
5025           /* Copy DW_AT_external attribute if it is set.  */
5026           if (spec_die->is_external)
5027             part_die->is_external = spec_die->is_external;
5028         }
5029     }
5030
5031   /* Set default names for some unnamed DIEs.  */
5032   if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
5033                                  || part_die->tag == DW_TAG_class_type))
5034     part_die->name = "(anonymous class)";
5035
5036   if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
5037     part_die->name = "(anonymous namespace)";
5038
5039   if (part_die->tag == DW_TAG_structure_type
5040       || part_die->tag == DW_TAG_class_type
5041       || part_die->tag == DW_TAG_union_type)
5042     guess_structure_name (part_die, cu);
5043 }
5044
5045 /* Read the die from the .debug_info section buffer.  Set DIEP to
5046    point to a newly allocated die with its information, except for its
5047    child, sibling, and parent fields.  Set HAS_CHILDREN to tell
5048    whether the die has children or not.  */
5049
5050 static char *
5051 read_full_die (struct die_info **diep, bfd *abfd, char *info_ptr,
5052                struct dwarf2_cu *cu, int *has_children)
5053 {
5054   unsigned int abbrev_number, bytes_read, i, offset;
5055   struct abbrev_info *abbrev;
5056   struct die_info *die;
5057
5058   offset = info_ptr - dwarf2_per_objfile->info_buffer;
5059   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5060   info_ptr += bytes_read;
5061   if (!abbrev_number)
5062     {
5063       die = dwarf_alloc_die ();
5064       die->tag = 0;
5065       die->abbrev = abbrev_number;
5066       die->type = NULL;
5067       *diep = die;
5068       *has_children = 0;
5069       return info_ptr;
5070     }
5071
5072   abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
5073   if (!abbrev)
5074     {
5075       error ("Dwarf Error: could not find abbrev number %d [in module %s]",
5076              abbrev_number,
5077              bfd_get_filename (abfd));
5078     }
5079   die = dwarf_alloc_die ();
5080   die->offset = offset;
5081   die->tag = abbrev->tag;
5082   die->abbrev = abbrev_number;
5083   die->type = NULL;
5084
5085   die->num_attrs = abbrev->num_attrs;
5086   die->attrs = (struct attribute *)
5087     xmalloc (die->num_attrs * sizeof (struct attribute));
5088
5089   for (i = 0; i < abbrev->num_attrs; ++i)
5090     {
5091       info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
5092                                  abfd, info_ptr, cu);
5093     }
5094
5095   *diep = die;
5096   *has_children = abbrev->has_children;
5097   return info_ptr;
5098 }
5099
5100 /* Read an attribute value described by an attribute form.  */
5101
5102 static char *
5103 read_attribute_value (struct attribute *attr, unsigned form,
5104                       bfd *abfd, char *info_ptr,
5105                       struct dwarf2_cu *cu)
5106 {
5107   struct comp_unit_head *cu_header = &cu->header;
5108   unsigned int bytes_read;
5109   struct dwarf_block *blk;
5110
5111   attr->form = form;
5112   switch (form)
5113     {
5114     case DW_FORM_addr:
5115     case DW_FORM_ref_addr:
5116       DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
5117       info_ptr += bytes_read;
5118       break;
5119     case DW_FORM_block2:
5120       blk = dwarf_alloc_block (cu);
5121       blk->size = read_2_bytes (abfd, info_ptr);
5122       info_ptr += 2;
5123       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5124       info_ptr += blk->size;
5125       DW_BLOCK (attr) = blk;
5126       break;
5127     case DW_FORM_block4:
5128       blk = dwarf_alloc_block (cu);
5129       blk->size = read_4_bytes (abfd, info_ptr);
5130       info_ptr += 4;
5131       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5132       info_ptr += blk->size;
5133       DW_BLOCK (attr) = blk;
5134       break;
5135     case DW_FORM_data2:
5136       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
5137       info_ptr += 2;
5138       break;
5139     case DW_FORM_data4:
5140       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
5141       info_ptr += 4;
5142       break;
5143     case DW_FORM_data8:
5144       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
5145       info_ptr += 8;
5146       break;
5147     case DW_FORM_string:
5148       DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
5149       info_ptr += bytes_read;
5150       break;
5151     case DW_FORM_strp:
5152       DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
5153                                                &bytes_read);
5154       info_ptr += bytes_read;
5155       break;
5156     case DW_FORM_block:
5157       blk = dwarf_alloc_block (cu);
5158       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5159       info_ptr += bytes_read;
5160       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5161       info_ptr += blk->size;
5162       DW_BLOCK (attr) = blk;
5163       break;
5164     case DW_FORM_block1:
5165       blk = dwarf_alloc_block (cu);
5166       blk->size = read_1_byte (abfd, info_ptr);
5167       info_ptr += 1;
5168       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
5169       info_ptr += blk->size;
5170       DW_BLOCK (attr) = blk;
5171       break;
5172     case DW_FORM_data1:
5173       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5174       info_ptr += 1;
5175       break;
5176     case DW_FORM_flag:
5177       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5178       info_ptr += 1;
5179       break;
5180     case DW_FORM_sdata:
5181       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
5182       info_ptr += bytes_read;
5183       break;
5184     case DW_FORM_udata:
5185       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5186       info_ptr += bytes_read;
5187       break;
5188     case DW_FORM_ref1:
5189       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
5190       info_ptr += 1;
5191       break;
5192     case DW_FORM_ref2:
5193       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
5194       info_ptr += 2;
5195       break;
5196     case DW_FORM_ref4:
5197       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
5198       info_ptr += 4;
5199       break;
5200     case DW_FORM_ref8:
5201       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
5202       info_ptr += 8;
5203       break;
5204     case DW_FORM_ref_udata:
5205       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5206       info_ptr += bytes_read;
5207       break;
5208     case DW_FORM_indirect:
5209       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5210       info_ptr += bytes_read;
5211       info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
5212       break;
5213     default:
5214       error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
5215              dwarf_form_name (form),
5216              bfd_get_filename (abfd));
5217     }
5218   return info_ptr;
5219 }
5220
5221 /* Read an attribute described by an abbreviated attribute.  */
5222
5223 static char *
5224 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
5225                 bfd *abfd, char *info_ptr, struct dwarf2_cu *cu)
5226 {
5227   attr->name = abbrev->name;
5228   return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
5229 }
5230
5231 /* read dwarf information from a buffer */
5232
5233 static unsigned int
5234 read_1_byte (bfd *abfd, char *buf)
5235 {
5236   return bfd_get_8 (abfd, (bfd_byte *) buf);
5237 }
5238
5239 static int
5240 read_1_signed_byte (bfd *abfd, char *buf)
5241 {
5242   return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
5243 }
5244
5245 static unsigned int
5246 read_2_bytes (bfd *abfd, char *buf)
5247 {
5248   return bfd_get_16 (abfd, (bfd_byte *) buf);
5249 }
5250
5251 static int
5252 read_2_signed_bytes (bfd *abfd, char *buf)
5253 {
5254   return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
5255 }
5256
5257 static unsigned int
5258 read_4_bytes (bfd *abfd, char *buf)
5259 {
5260   return bfd_get_32 (abfd, (bfd_byte *) buf);
5261 }
5262
5263 static int
5264 read_4_signed_bytes (bfd *abfd, char *buf)
5265 {
5266   return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
5267 }
5268
5269 static unsigned long
5270 read_8_bytes (bfd *abfd, char *buf)
5271 {
5272   return bfd_get_64 (abfd, (bfd_byte *) buf);
5273 }
5274
5275 static CORE_ADDR
5276 read_address (bfd *abfd, char *buf, struct dwarf2_cu *cu, int *bytes_read)
5277 {
5278   struct comp_unit_head *cu_header = &cu->header;
5279   CORE_ADDR retval = 0;
5280
5281   if (cu_header->signed_addr_p)
5282     {
5283       switch (cu_header->addr_size)
5284         {
5285         case 2:
5286           retval = bfd_get_signed_16 (abfd, (bfd_byte *) buf);
5287           break;
5288         case 4:
5289           retval = bfd_get_signed_32 (abfd, (bfd_byte *) buf);
5290           break;
5291         case 8:
5292           retval = bfd_get_signed_64 (abfd, (bfd_byte *) buf);
5293           break;
5294         default:
5295           internal_error (__FILE__, __LINE__,
5296                           "read_address: bad switch, signed [in module %s]",
5297                           bfd_get_filename (abfd));
5298         }
5299     }
5300   else
5301     {
5302       switch (cu_header->addr_size)
5303         {
5304         case 2:
5305           retval = bfd_get_16 (abfd, (bfd_byte *) buf);
5306           break;
5307         case 4:
5308           retval = bfd_get_32 (abfd, (bfd_byte *) buf);
5309           break;
5310         case 8:
5311           retval = bfd_get_64 (abfd, (bfd_byte *) buf);
5312           break;
5313         default:
5314           internal_error (__FILE__, __LINE__,
5315                           "read_address: bad switch, unsigned [in module %s]",
5316                           bfd_get_filename (abfd));
5317         }
5318     }
5319
5320   *bytes_read = cu_header->addr_size;
5321   return retval;
5322 }
5323
5324 /* Read the initial length from a section.  The (draft) DWARF 3
5325    specification allows the initial length to take up either 4 bytes
5326    or 12 bytes.  If the first 4 bytes are 0xffffffff, then the next 8
5327    bytes describe the length and all offsets will be 8 bytes in length
5328    instead of 4.
5329
5330    An older, non-standard 64-bit format is also handled by this
5331    function.  The older format in question stores the initial length
5332    as an 8-byte quantity without an escape value.  Lengths greater
5333    than 2^32 aren't very common which means that the initial 4 bytes
5334    is almost always zero.  Since a length value of zero doesn't make
5335    sense for the 32-bit format, this initial zero can be considered to
5336    be an escape value which indicates the presence of the older 64-bit
5337    format.  As written, the code can't detect (old format) lengths
5338    greater than 4GB.  If it becomes necessary to handle lengths somewhat
5339    larger than 4GB, we could allow other small values (such as the
5340    non-sensical values of 1, 2, and 3) to also be used as escape values
5341    indicating the presence of the old format.
5342
5343    The value returned via bytes_read should be used to increment
5344    the relevant pointer after calling read_initial_length().
5345
5346    As a side effect, this function sets the fields initial_length_size
5347    and offset_size in cu_header to the values appropriate for the
5348    length field.  (The format of the initial length field determines
5349    the width of file offsets to be fetched later with fetch_offset().)
5350
5351    [ Note:  read_initial_length() and read_offset() are based on the
5352      document entitled "DWARF Debugging Information Format", revision
5353      3, draft 8, dated November 19, 2001.  This document was obtained
5354      from:
5355
5356         http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5357
5358      This document is only a draft and is subject to change.  (So beware.)
5359
5360      Details regarding the older, non-standard 64-bit format were
5361      determined empirically by examining 64-bit ELF files produced
5362      by the SGI toolchain on an IRIX 6.5 machine.
5363
5364      - Kevin, July 16, 2002
5365    ] */
5366
5367 static LONGEST
5368 read_initial_length (bfd *abfd, char *buf, struct comp_unit_head *cu_header,
5369                      int *bytes_read)
5370 {
5371   LONGEST retval = 0;
5372
5373   retval = bfd_get_32 (abfd, (bfd_byte *) buf);
5374
5375   if (retval == 0xffffffff)
5376     {
5377       retval = bfd_get_64 (abfd, (bfd_byte *) buf + 4);
5378       *bytes_read = 12;
5379       if (cu_header != NULL)
5380         {
5381           cu_header->initial_length_size = 12;
5382           cu_header->offset_size = 8;
5383         }
5384     }
5385   else if (retval == 0)
5386     {
5387       /* Handle (non-standard) 64-bit DWARF2 formats such as that used
5388          by IRIX.  */
5389       retval = bfd_get_64 (abfd, (bfd_byte *) buf);
5390       *bytes_read = 8;
5391       if (cu_header != NULL)
5392         {
5393           cu_header->initial_length_size = 8;
5394           cu_header->offset_size = 8;
5395         }
5396     }
5397   else
5398     {
5399       *bytes_read = 4;
5400       if (cu_header != NULL)
5401         {
5402           cu_header->initial_length_size = 4;
5403           cu_header->offset_size = 4;
5404         }
5405     }
5406
5407  return retval;
5408 }
5409
5410 /* Read an offset from the data stream.  The size of the offset is
5411    given by cu_header->offset_size. */
5412
5413 static LONGEST
5414 read_offset (bfd *abfd, char *buf, const struct comp_unit_head *cu_header,
5415              int *bytes_read)
5416 {
5417   LONGEST retval = 0;
5418
5419   switch (cu_header->offset_size)
5420     {
5421     case 4:
5422       retval = bfd_get_32 (abfd, (bfd_byte *) buf);
5423       *bytes_read = 4;
5424       break;
5425     case 8:
5426       retval = bfd_get_64 (abfd, (bfd_byte *) buf);
5427       *bytes_read = 8;
5428       break;
5429     default:
5430       internal_error (__FILE__, __LINE__,
5431                       "read_offset: bad switch [in module %s]",
5432                       bfd_get_filename (abfd));
5433     }
5434
5435  return retval;
5436 }
5437
5438 static char *
5439 read_n_bytes (bfd *abfd, char *buf, unsigned int size)
5440 {
5441   /* If the size of a host char is 8 bits, we can return a pointer
5442      to the buffer, otherwise we have to copy the data to a buffer
5443      allocated on the temporary obstack.  */
5444   gdb_assert (HOST_CHAR_BIT == 8);
5445   return buf;
5446 }
5447
5448 static char *
5449 read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
5450 {
5451   /* If the size of a host char is 8 bits, we can return a pointer
5452      to the string, otherwise we have to copy the string to a buffer
5453      allocated on the temporary obstack.  */
5454   gdb_assert (HOST_CHAR_BIT == 8);
5455   if (*buf == '\0')
5456     {
5457       *bytes_read_ptr = 1;
5458       return NULL;
5459     }
5460   *bytes_read_ptr = strlen (buf) + 1;
5461   return buf;
5462 }
5463
5464 static char *
5465 read_indirect_string (bfd *abfd, char *buf,
5466                       const struct comp_unit_head *cu_header,
5467                       unsigned int *bytes_read_ptr)
5468 {
5469   LONGEST str_offset = read_offset (abfd, buf, cu_header,
5470                                     (int *) bytes_read_ptr);
5471
5472   if (dwarf2_per_objfile->str_buffer == NULL)
5473     {
5474       error ("DW_FORM_strp used without .debug_str section [in module %s]",
5475                       bfd_get_filename (abfd));
5476       return NULL;
5477     }
5478   if (str_offset >= dwarf2_per_objfile->str_size)
5479     {
5480       error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
5481                       bfd_get_filename (abfd));
5482       return NULL;
5483     }
5484   gdb_assert (HOST_CHAR_BIT == 8);
5485   if (dwarf2_per_objfile->str_buffer[str_offset] == '\0')
5486     return NULL;
5487   return dwarf2_per_objfile->str_buffer + str_offset;
5488 }
5489
5490 static unsigned long
5491 read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
5492 {
5493   unsigned long result;
5494   unsigned int num_read;
5495   int i, shift;
5496   unsigned char byte;
5497
5498   result = 0;
5499   shift = 0;
5500   num_read = 0;
5501   i = 0;
5502   while (1)
5503     {
5504       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
5505       buf++;
5506       num_read++;
5507       result |= ((unsigned long)(byte & 127) << shift);
5508       if ((byte & 128) == 0)
5509         {
5510           break;
5511         }
5512       shift += 7;
5513     }
5514   *bytes_read_ptr = num_read;
5515   return result;
5516 }
5517
5518 static long
5519 read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
5520 {
5521   long result;
5522   int i, shift, size, num_read;
5523   unsigned char byte;
5524
5525   result = 0;
5526   shift = 0;
5527   size = 32;
5528   num_read = 0;
5529   i = 0;
5530   while (1)
5531     {
5532       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
5533       buf++;
5534       num_read++;
5535       result |= ((long)(byte & 127) << shift);
5536       shift += 7;
5537       if ((byte & 128) == 0)
5538         {
5539           break;
5540         }
5541     }
5542   if ((shift < size) && (byte & 0x40))
5543     {
5544       result |= -(1 << shift);
5545     }
5546   *bytes_read_ptr = num_read;
5547   return result;
5548 }
5549
5550 /* Return a pointer to just past the end of an LEB128 number in BUF.  */
5551
5552 static char *
5553 skip_leb128 (bfd *abfd, char *buf)
5554 {
5555   int byte;
5556
5557   while (1)
5558     {
5559       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
5560       buf++;
5561       if ((byte & 128) == 0)
5562         return buf;
5563     }
5564 }
5565
5566 static void
5567 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
5568 {
5569   switch (lang)
5570     {
5571     case DW_LANG_C89:
5572     case DW_LANG_C:
5573       cu->language = language_c;
5574       break;
5575     case DW_LANG_C_plus_plus:
5576       cu->language = language_cplus;
5577       break;
5578     case DW_LANG_Fortran77:
5579     case DW_LANG_Fortran90:
5580     case DW_LANG_Fortran95:
5581       cu->language = language_fortran;
5582       break;
5583     case DW_LANG_Mips_Assembler:
5584       cu->language = language_asm;
5585       break;
5586     case DW_LANG_Java:
5587       cu->language = language_java;
5588       break;
5589     case DW_LANG_Ada83:
5590     case DW_LANG_Ada95:
5591     case DW_LANG_Cobol74:
5592     case DW_LANG_Cobol85:
5593     case DW_LANG_Pascal83:
5594     case DW_LANG_Modula2:
5595     default:
5596       cu->language = language_minimal;
5597       break;
5598     }
5599   cu->language_defn = language_def (cu->language);
5600 }
5601
5602 /* Return the named attribute or NULL if not there.  */
5603
5604 static struct attribute *
5605 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
5606 {
5607   unsigned int i;
5608   struct attribute *spec = NULL;
5609
5610   for (i = 0; i < die->num_attrs; ++i)
5611     {
5612       if (die->attrs[i].name == name)
5613         {
5614           return &die->attrs[i];
5615         }
5616       if (die->attrs[i].name == DW_AT_specification
5617           || die->attrs[i].name == DW_AT_abstract_origin)
5618         spec = &die->attrs[i];
5619     }
5620   if (spec)
5621     {
5622       struct die_info *ref_die =
5623       follow_die_ref (dwarf2_get_ref_die_offset (spec, cu));
5624
5625       if (ref_die)
5626         return dwarf2_attr (ref_die, name, cu);
5627     }
5628
5629   return NULL;
5630 }
5631
5632 /* Return non-zero iff the attribute NAME is defined for the given DIE,
5633    and holds a non-zero value.  This function should only be used for
5634    DW_FORM_flag attributes.  */
5635
5636 static int
5637 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
5638 {
5639   struct attribute *attr = dwarf2_attr (die, name, cu);
5640
5641   return (attr && DW_UNSND (attr));
5642 }
5643
5644 static int
5645 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
5646 {
5647   /* A DIE is a declaration if it has a DW_AT_declaration attribute
5648      which value is non-zero.  However, we have to be careful with
5649      DIEs having a DW_AT_specification attribute, because dwarf2_attr()
5650      (via dwarf2_flag_true_p) follows this attribute.  So we may
5651      end up accidently finding a declaration attribute that belongs
5652      to a different DIE referenced by the specification attribute,
5653      even though the given DIE does not have a declaration attribute.  */
5654   return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
5655           && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
5656 }
5657
5658 /* Return the die giving the specification for DIE, if there is
5659    one.  */
5660
5661 static struct die_info *
5662 die_specification (struct die_info *die, struct dwarf2_cu *cu)
5663 {
5664   struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
5665
5666   if (spec_attr == NULL)
5667     return NULL;
5668   else
5669     return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr, cu));
5670 }
5671
5672 /* Free the line_header structure *LH, and any arrays and strings it
5673    refers to.  */
5674 static void
5675 free_line_header (struct line_header *lh)
5676 {
5677   if (lh->standard_opcode_lengths)
5678     xfree (lh->standard_opcode_lengths);
5679
5680   /* Remember that all the lh->file_names[i].name pointers are
5681      pointers into debug_line_buffer, and don't need to be freed.  */
5682   if (lh->file_names)
5683     xfree (lh->file_names);
5684
5685   /* Similarly for the include directory names.  */
5686   if (lh->include_dirs)
5687     xfree (lh->include_dirs);
5688
5689   xfree (lh);
5690 }
5691
5692
5693 /* Add an entry to LH's include directory table.  */
5694 static void
5695 add_include_dir (struct line_header *lh, char *include_dir)
5696 {
5697   /* Grow the array if necessary.  */
5698   if (lh->include_dirs_size == 0)
5699     {
5700       lh->include_dirs_size = 1; /* for testing */
5701       lh->include_dirs = xmalloc (lh->include_dirs_size
5702                                   * sizeof (*lh->include_dirs));
5703     }
5704   else if (lh->num_include_dirs >= lh->include_dirs_size)
5705     {
5706       lh->include_dirs_size *= 2;
5707       lh->include_dirs = xrealloc (lh->include_dirs,
5708                                    (lh->include_dirs_size
5709                                     * sizeof (*lh->include_dirs)));
5710     }
5711
5712   lh->include_dirs[lh->num_include_dirs++] = include_dir;
5713 }
5714
5715
5716 /* Add an entry to LH's file name table.  */
5717 static void
5718 add_file_name (struct line_header *lh,
5719                char *name,
5720                unsigned int dir_index,
5721                unsigned int mod_time,
5722                unsigned int length)
5723 {
5724   struct file_entry *fe;
5725
5726   /* Grow the array if necessary.  */
5727   if (lh->file_names_size == 0)
5728     {
5729       lh->file_names_size = 1; /* for testing */
5730       lh->file_names = xmalloc (lh->file_names_size
5731                                 * sizeof (*lh->file_names));
5732     }
5733   else if (lh->num_file_names >= lh->file_names_size)
5734     {
5735       lh->file_names_size *= 2;
5736       lh->file_names = xrealloc (lh->file_names,
5737                                  (lh->file_names_size
5738                                   * sizeof (*lh->file_names)));
5739     }
5740
5741   fe = &lh->file_names[lh->num_file_names++];
5742   fe->name = name;
5743   fe->dir_index = dir_index;
5744   fe->mod_time = mod_time;
5745   fe->length = length;
5746   fe->included_p = 0;
5747 }
5748
5749
5750 /* Read the statement program header starting at OFFSET in
5751    .debug_line, according to the endianness of ABFD.  Return a pointer
5752    to a struct line_header, allocated using xmalloc.
5753
5754    NOTE: the strings in the include directory and file name tables of
5755    the returned object point into debug_line_buffer, and must not be
5756    freed.  */
5757 static struct line_header *
5758 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
5759                           struct dwarf2_cu *cu)
5760 {
5761   struct cleanup *back_to;
5762   struct line_header *lh;
5763   char *line_ptr;
5764   int bytes_read;
5765   int i;
5766   char *cur_dir, *cur_file;
5767
5768   if (dwarf2_per_objfile->line_buffer == NULL)
5769     {
5770       complaint (&symfile_complaints, "missing .debug_line section");
5771       return 0;
5772     }
5773
5774   /* Make sure that at least there's room for the total_length field.  That
5775      could be 12 bytes long, but we're just going to fudge that.  */
5776   if (offset + 4 >= dwarf2_per_objfile->line_size)
5777     {
5778       dwarf2_statement_list_fits_in_line_number_section_complaint ();
5779       return 0;
5780     }
5781
5782   lh = xmalloc (sizeof (*lh));
5783   memset (lh, 0, sizeof (*lh));
5784   back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
5785                           (void *) lh);
5786
5787   line_ptr = dwarf2_per_objfile->line_buffer + offset;
5788
5789   /* read in the header */
5790   lh->total_length = read_initial_length (abfd, line_ptr, NULL, &bytes_read);
5791   line_ptr += bytes_read;
5792   if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer
5793                                      + dwarf2_per_objfile->line_size))
5794     {
5795       dwarf2_statement_list_fits_in_line_number_section_complaint ();
5796       return 0;
5797     }
5798   lh->statement_program_end = line_ptr + lh->total_length;
5799   lh->version = read_2_bytes (abfd, line_ptr);
5800   line_ptr += 2;
5801   lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
5802   line_ptr += bytes_read;
5803   lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
5804   line_ptr += 1;
5805   lh->default_is_stmt = read_1_byte (abfd, line_ptr);
5806   line_ptr += 1;
5807   lh->line_base = read_1_signed_byte (abfd, line_ptr);
5808   line_ptr += 1;
5809   lh->line_range = read_1_byte (abfd, line_ptr);
5810   line_ptr += 1;
5811   lh->opcode_base = read_1_byte (abfd, line_ptr);
5812   line_ptr += 1;
5813   lh->standard_opcode_lengths
5814     = (unsigned char *) xmalloc (lh->opcode_base * sizeof (unsigned char));
5815
5816   lh->standard_opcode_lengths[0] = 1;  /* This should never be used anyway.  */
5817   for (i = 1; i < lh->opcode_base; ++i)
5818     {
5819       lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
5820       line_ptr += 1;
5821     }
5822
5823   /* Read directory table  */
5824   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
5825     {
5826       line_ptr += bytes_read;
5827       add_include_dir (lh, cur_dir);
5828     }
5829   line_ptr += bytes_read;
5830
5831   /* Read file name table */
5832   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
5833     {
5834       unsigned int dir_index, mod_time, length;
5835
5836       line_ptr += bytes_read;
5837       dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5838       line_ptr += bytes_read;
5839       mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5840       line_ptr += bytes_read;
5841       length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
5842       line_ptr += bytes_read;
5843
5844       add_file_name (lh, cur_file, dir_index, mod_time, length);
5845     }
5846   line_ptr += bytes_read;
5847   lh->statement_program_start = line_ptr;
5848
5849   if (line_ptr > (dwarf2_per_objfile->line_buffer
5850                   + dwarf2_per_objfile->line_size))
5851     complaint (&symfile_complaints,
5852                "line number info header doesn't fit in `.debug_line' section");
5853
5854   discard_cleanups (back_to);
5855   return lh;
5856 }
5857
5858 /* This function exists to work around a bug in certain compilers
5859    (particularly GCC 2.95), in which the first line number marker of a
5860    function does not show up until after the prologue, right before
5861    the second line number marker.  This function shifts ADDRESS down
5862    to the beginning of the function if necessary, and is called on
5863    addresses passed to record_line.  */
5864
5865 static CORE_ADDR
5866 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
5867 {
5868   struct function_range *fn;
5869
5870   /* Find the function_range containing address.  */
5871   if (!cu->first_fn)
5872     return address;
5873
5874   if (!cu->cached_fn)
5875     cu->cached_fn = cu->first_fn;
5876
5877   fn = cu->cached_fn;
5878   while (fn)
5879     if (fn->lowpc <= address && fn->highpc > address)
5880       goto found;
5881     else
5882       fn = fn->next;
5883
5884   fn = cu->first_fn;
5885   while (fn && fn != cu->cached_fn)
5886     if (fn->lowpc <= address && fn->highpc > address)
5887       goto found;
5888     else
5889       fn = fn->next;
5890
5891   return address;
5892
5893  found:
5894   if (fn->seen_line)
5895     return address;
5896   if (address != fn->lowpc)
5897     complaint (&symfile_complaints,
5898                "misplaced first line number at 0x%lx for '%s'",
5899                (unsigned long) address, fn->name);
5900   fn->seen_line = 1;
5901   return fn->lowpc;
5902 }
5903
5904 /* Decode the Line Number Program (LNP) for the given line_header
5905    structure and CU.  The actual information extracted and the type
5906    of structures created from the LNP depends on the value of PST.
5907
5908    1. If PST is NULL, then this procedure uses the data from the program
5909       to create all necessary symbol tables, and their linetables.
5910       The compilation directory of the file is passed in COMP_DIR,
5911       and must not be NULL.
5912
5913    2. If PST is not NULL, this procedure reads the program to determine
5914       the list of files included by the unit represented by PST, and
5915       builds all the associated partial symbol tables.  In this case,
5916       the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
5917       is not used to compute the full name of the symtab, and therefore
5918       omitting it when building the partial symtab does not introduce
5919       the potential for inconsistency - a partial symtab and its associated
5920       symbtab having a different fullname -).  */
5921
5922 static void
5923 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
5924                     struct dwarf2_cu *cu, struct partial_symtab *pst)
5925 {
5926   char *line_ptr;
5927   char *line_end;
5928   unsigned int bytes_read;
5929   unsigned char op_code, extended_op, adj_opcode;
5930   CORE_ADDR baseaddr;
5931   struct objfile *objfile = cu->objfile;
5932   const int decode_for_pst_p = (pst != NULL);
5933
5934   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5935
5936   line_ptr = lh->statement_program_start;
5937   line_end = lh->statement_program_end;
5938
5939   /* Read the statement sequences until there's nothing left.  */
5940   while (line_ptr < line_end)
5941     {
5942       /* state machine registers  */
5943       CORE_ADDR address = 0;
5944       unsigned int file = 1;
5945       unsigned int line = 1;
5946       unsigned int column = 0;
5947       int is_stmt = lh->default_is_stmt;
5948       int basic_block = 0;
5949       int end_sequence = 0;
5950
5951       if (!decode_for_pst_p && lh->num_file_names >= file)
5952         {
5953           /* Start a subfile for the current file of the state machine.  */
5954           /* lh->include_dirs and lh->file_names are 0-based, but the
5955              directory and file name numbers in the statement program
5956              are 1-based.  */
5957           struct file_entry *fe = &lh->file_names[file - 1];
5958           char *dir;
5959           if (fe->dir_index)
5960             dir = lh->include_dirs[fe->dir_index - 1];
5961           else
5962             dir = comp_dir;
5963           dwarf2_start_subfile (fe->name, dir);
5964         }
5965
5966       /* Decode the table. */
5967       while (!end_sequence)
5968         {
5969           op_code = read_1_byte (abfd, line_ptr);
5970           line_ptr += 1;
5971
5972           if (op_code >= lh->opcode_base)
5973             {           /* Special operand.  */
5974               adj_opcode = op_code - lh->opcode_base;
5975               address += (adj_opcode / lh->line_range)
5976                 * lh->minimum_instruction_length;
5977               line += lh->line_base + (adj_opcode % lh->line_range);
5978               if (!decode_for_pst_p)
5979                 {
5980                   /* append row to matrix using current values */
5981                   record_line (current_subfile, line,
5982                                check_cu_functions (address, cu));
5983                 }
5984               basic_block = 1;
5985             }
5986           else switch (op_code)
5987             {
5988             case DW_LNS_extended_op:
5989               line_ptr += 1;    /* ignore length */
5990               extended_op = read_1_byte (abfd, line_ptr);
5991               line_ptr += 1;
5992               switch (extended_op)
5993                 {
5994                 case DW_LNE_end_sequence:
5995                   end_sequence = 1;
5996                   if (!decode_for_pst_p)
5997                     record_line (current_subfile, 0, address);
5998                   break;
5999                 case DW_LNE_set_address:
6000                   address = read_address (abfd, line_ptr, cu, &bytes_read);
6001                   line_ptr += bytes_read;
6002                   address += baseaddr;
6003                   break;
6004                 case DW_LNE_define_file:
6005                   {
6006                     char *cur_file;
6007                     unsigned int dir_index, mod_time, length;
6008
6009                     cur_file = read_string (abfd, line_ptr, &bytes_read);
6010                     line_ptr += bytes_read;
6011                     dir_index =
6012                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6013                     line_ptr += bytes_read;
6014                     mod_time =
6015                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6016                     line_ptr += bytes_read;
6017                     length =
6018                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6019                     line_ptr += bytes_read;
6020                     add_file_name (lh, cur_file, dir_index, mod_time, length);
6021                   }
6022                   break;
6023                 default:
6024                   complaint (&symfile_complaints,
6025                              "mangled .debug_line section");
6026                   return;
6027                 }
6028               break;
6029             case DW_LNS_copy:
6030               if (!decode_for_pst_p)
6031                 record_line (current_subfile, line,
6032                              check_cu_functions (address, cu));
6033               basic_block = 0;
6034               break;
6035             case DW_LNS_advance_pc:
6036               address += lh->minimum_instruction_length
6037                 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6038               line_ptr += bytes_read;
6039               break;
6040             case DW_LNS_advance_line:
6041               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
6042               line_ptr += bytes_read;
6043               break;
6044             case DW_LNS_set_file:
6045               {
6046                 /* lh->include_dirs and lh->file_names are 0-based,
6047                    but the directory and file name numbers in the
6048                    statement program are 1-based.  */
6049                 struct file_entry *fe;
6050                 char *dir;
6051                 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6052                 line_ptr += bytes_read;
6053                 fe = &lh->file_names[file - 1];
6054                 fe->included_p = 1;
6055                 if (fe->dir_index)
6056                   dir = lh->include_dirs[fe->dir_index - 1];
6057                 else
6058                   dir = comp_dir;
6059                 if (!decode_for_pst_p)
6060                   dwarf2_start_subfile (fe->name, dir);
6061               }
6062               break;
6063             case DW_LNS_set_column:
6064               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6065               line_ptr += bytes_read;
6066               break;
6067             case DW_LNS_negate_stmt:
6068               is_stmt = (!is_stmt);
6069               break;
6070             case DW_LNS_set_basic_block:
6071               basic_block = 1;
6072               break;
6073             /* Add to the address register of the state machine the
6074                address increment value corresponding to special opcode
6075                255.  Ie, this value is scaled by the minimum instruction
6076                length since special opcode 255 would have scaled the
6077                the increment.  */
6078             case DW_LNS_const_add_pc:
6079               address += (lh->minimum_instruction_length
6080                           * ((255 - lh->opcode_base) / lh->line_range));
6081               break;
6082             case DW_LNS_fixed_advance_pc:
6083               address += read_2_bytes (abfd, line_ptr);
6084               line_ptr += 2;
6085               break;
6086             default:
6087               {  /* Unknown standard opcode, ignore it.  */
6088                 int i;
6089                 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
6090                   {
6091                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6092                     line_ptr += bytes_read;
6093                   }
6094               }
6095             }
6096         }
6097     }
6098
6099   if (decode_for_pst_p)
6100     {
6101       int file_index;
6102
6103       /* Now that we're done scanning the Line Header Program, we can
6104          create the psymtab of each included file.  */
6105       for (file_index = 0; file_index < lh->num_file_names; file_index++)
6106         if (lh->file_names[file_index].included_p == 1)
6107           {
6108             char *include_name = lh->file_names [file_index].name;
6109
6110             if (strcmp (include_name, pst->filename) != 0)
6111               dwarf2_create_include_psymtab (include_name, pst, objfile);
6112           }
6113     }
6114 }
6115
6116 /* Start a subfile for DWARF.  FILENAME is the name of the file and
6117    DIRNAME the name of the source directory which contains FILENAME
6118    or NULL if not known.
6119    This routine tries to keep line numbers from identical absolute and
6120    relative file names in a common subfile.
6121
6122    Using the `list' example from the GDB testsuite, which resides in
6123    /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6124    of /srcdir/list0.c yields the following debugging information for list0.c:
6125
6126    DW_AT_name:          /srcdir/list0.c
6127    DW_AT_comp_dir:              /compdir
6128    files.files[0].name: list0.h
6129    files.files[0].dir:  /srcdir
6130    files.files[1].name: list0.c
6131    files.files[1].dir:  /srcdir
6132
6133    The line number information for list0.c has to end up in a single
6134    subfile, so that `break /srcdir/list0.c:1' works as expected.  */
6135
6136 static void
6137 dwarf2_start_subfile (char *filename, char *dirname)
6138 {
6139   /* If the filename isn't absolute, try to match an existing subfile
6140      with the full pathname.  */
6141
6142   if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
6143     {
6144       struct subfile *subfile;
6145       char *fullname = concat (dirname, "/", filename, NULL);
6146
6147       for (subfile = subfiles; subfile; subfile = subfile->next)
6148         {
6149           if (FILENAME_CMP (subfile->name, fullname) == 0)
6150             {
6151               current_subfile = subfile;
6152               xfree (fullname);
6153               return;
6154             }
6155         }
6156       xfree (fullname);
6157     }
6158   start_subfile (filename, dirname);
6159 }
6160
6161 static void
6162 var_decode_location (struct attribute *attr, struct symbol *sym,
6163                      struct dwarf2_cu *cu)
6164 {
6165   struct objfile *objfile = cu->objfile;
6166   struct comp_unit_head *cu_header = &cu->header;
6167
6168   /* NOTE drow/2003-01-30: There used to be a comment and some special
6169      code here to turn a symbol with DW_AT_external and a
6170      SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol.  This was
6171      necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6172      with some versions of binutils) where shared libraries could have
6173      relocations against symbols in their debug information - the
6174      minimal symbol would have the right address, but the debug info
6175      would not.  It's no longer necessary, because we will explicitly
6176      apply relocations when we read in the debug information now.  */
6177
6178   /* A DW_AT_location attribute with no contents indicates that a
6179      variable has been optimized away.  */
6180   if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
6181     {
6182       SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
6183       return;
6184     }
6185
6186   /* Handle one degenerate form of location expression specially, to
6187      preserve GDB's previous behavior when section offsets are
6188      specified.  If this is just a DW_OP_addr then mark this symbol
6189      as LOC_STATIC.  */
6190
6191   if (attr_form_is_block (attr)
6192       && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
6193       && DW_BLOCK (attr)->data[0] == DW_OP_addr)
6194     {
6195       int dummy;
6196
6197       SYMBOL_VALUE_ADDRESS (sym) =
6198         read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
6199       fixup_symbol_section (sym, objfile);
6200       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
6201                                               SYMBOL_SECTION (sym));
6202       SYMBOL_CLASS (sym) = LOC_STATIC;
6203       return;
6204     }
6205
6206   /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6207      expression evaluator, and use LOC_COMPUTED only when necessary
6208      (i.e. when the value of a register or memory location is
6209      referenced, or a thread-local block, etc.).  Then again, it might
6210      not be worthwhile.  I'm assuming that it isn't unless performance
6211      or memory numbers show me otherwise.  */
6212
6213   dwarf2_symbol_mark_computed (attr, sym, cu);
6214   SYMBOL_CLASS (sym) = LOC_COMPUTED;
6215 }
6216
6217 /* Given a pointer to a DWARF information entry, figure out if we need
6218    to make a symbol table entry for it, and if so, create a new entry
6219    and return a pointer to it.
6220    If TYPE is NULL, determine symbol type from the die, otherwise
6221    used the passed type.  */
6222
6223 static struct symbol *
6224 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
6225 {
6226   struct objfile *objfile = cu->objfile;
6227   struct symbol *sym = NULL;
6228   char *name;
6229   struct attribute *attr = NULL;
6230   struct attribute *attr2 = NULL;
6231   CORE_ADDR baseaddr;
6232
6233   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6234
6235   if (die->tag != DW_TAG_namespace)
6236     name = dwarf2_linkage_name (die, cu);
6237   else
6238     name = TYPE_NAME (type);
6239
6240   if (name)
6241     {
6242       sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
6243                                              sizeof (struct symbol));
6244       OBJSTAT (objfile, n_syms++);
6245       memset (sym, 0, sizeof (struct symbol));
6246
6247       /* Cache this symbol's name and the name's demangled form (if any).  */
6248       SYMBOL_LANGUAGE (sym) = cu->language;
6249       SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
6250
6251       /* Default assumptions.
6252          Use the passed type or decode it from the die.  */
6253       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6254       SYMBOL_CLASS (sym) = LOC_STATIC;
6255       if (type != NULL)
6256         SYMBOL_TYPE (sym) = type;
6257       else
6258         SYMBOL_TYPE (sym) = die_type (die, cu);
6259       attr = dwarf2_attr (die, DW_AT_decl_line, cu);
6260       if (attr)
6261         {
6262           SYMBOL_LINE (sym) = DW_UNSND (attr);
6263         }
6264       switch (die->tag)
6265         {
6266         case DW_TAG_label:
6267           attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6268           if (attr)
6269             {
6270               SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
6271             }
6272           SYMBOL_CLASS (sym) = LOC_LABEL;
6273           break;
6274         case DW_TAG_subprogram:
6275           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6276              finish_block.  */
6277           SYMBOL_CLASS (sym) = LOC_BLOCK;
6278           attr2 = dwarf2_attr (die, DW_AT_external, cu);
6279           if (attr2 && (DW_UNSND (attr2) != 0))
6280             {
6281               add_symbol_to_list (sym, &global_symbols);
6282             }
6283           else
6284             {
6285               add_symbol_to_list (sym, cu->list_in_scope);
6286             }
6287           break;
6288         case DW_TAG_variable:
6289           /* Compilation with minimal debug info may result in variables
6290              with missing type entries. Change the misleading `void' type
6291              to something sensible.  */
6292           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
6293             SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
6294                                            TARGET_INT_BIT / HOST_CHAR_BIT, 0,
6295                                            "<variable, no debug info>",
6296                                            objfile);
6297           attr = dwarf2_attr (die, DW_AT_const_value, cu);
6298           if (attr)
6299             {
6300               dwarf2_const_value (attr, sym, cu);
6301               attr2 = dwarf2_attr (die, DW_AT_external, cu);
6302               if (attr2 && (DW_UNSND (attr2) != 0))
6303                 add_symbol_to_list (sym, &global_symbols);
6304               else
6305                 add_symbol_to_list (sym, cu->list_in_scope);
6306               break;
6307             }
6308           attr = dwarf2_attr (die, DW_AT_location, cu);
6309           if (attr)
6310             {
6311               var_decode_location (attr, sym, cu);
6312               attr2 = dwarf2_attr (die, DW_AT_external, cu);
6313               if (attr2 && (DW_UNSND (attr2) != 0))
6314                 add_symbol_to_list (sym, &global_symbols);
6315               else
6316                 add_symbol_to_list (sym, cu->list_in_scope);
6317             }
6318           else
6319             {
6320               /* We do not know the address of this symbol.
6321                  If it is an external symbol and we have type information
6322                  for it, enter the symbol as a LOC_UNRESOLVED symbol.
6323                  The address of the variable will then be determined from
6324                  the minimal symbol table whenever the variable is
6325                  referenced.  */
6326               attr2 = dwarf2_attr (die, DW_AT_external, cu);
6327               if (attr2 && (DW_UNSND (attr2) != 0)
6328                   && dwarf2_attr (die, DW_AT_type, cu) != NULL)
6329                 {
6330                   SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
6331                   add_symbol_to_list (sym, &global_symbols);
6332                 }
6333             }
6334           break;
6335         case DW_TAG_formal_parameter:
6336           attr = dwarf2_attr (die, DW_AT_location, cu);
6337           if (attr)
6338             {
6339               var_decode_location (attr, sym, cu);
6340               /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary?  */
6341               if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
6342                 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
6343             }
6344           attr = dwarf2_attr (die, DW_AT_const_value, cu);
6345           if (attr)
6346             {
6347               dwarf2_const_value (attr, sym, cu);
6348             }
6349           add_symbol_to_list (sym, cu->list_in_scope);
6350           break;
6351         case DW_TAG_unspecified_parameters:
6352           /* From varargs functions; gdb doesn't seem to have any
6353              interest in this information, so just ignore it for now.
6354              (FIXME?) */
6355           break;
6356         case DW_TAG_class_type:
6357         case DW_TAG_structure_type:
6358         case DW_TAG_union_type:
6359         case DW_TAG_enumeration_type:
6360           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6361           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
6362
6363           /* Make sure that the symbol includes appropriate enclosing
6364              classes/namespaces in its name.  These are calculated in
6365              read_structure_type, and the correct name is saved in
6366              the type.  */
6367
6368           if (cu->language == language_cplus)
6369             {
6370               struct type *type = SYMBOL_TYPE (sym);
6371
6372               if (TYPE_TAG_NAME (type) != NULL)
6373                 {
6374                   /* FIXME: carlton/2003-11-10: Should this use
6375                      SYMBOL_SET_NAMES instead?  (The same problem also
6376                      arises further down in this function.)  */
6377                   /* The type's name is already allocated along with
6378                      this objfile, so we don't need to duplicate it
6379                      for the symbol.  */
6380                   SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
6381                 }
6382             }
6383
6384           {
6385             /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
6386                really ever be static objects: otherwise, if you try
6387                to, say, break of a class's method and you're in a file
6388                which doesn't mention that class, it won't work unless
6389                the check for all static symbols in lookup_symbol_aux
6390                saves you.  See the OtherFileClass tests in
6391                gdb.c++/namespace.exp.  */
6392
6393             struct pending **list_to_add;
6394
6395             list_to_add = (cu->list_in_scope == &file_symbols
6396                            && cu->language == language_cplus
6397                            ? &global_symbols : cu->list_in_scope);
6398
6399             add_symbol_to_list (sym, list_to_add);
6400
6401             /* The semantics of C++ state that "struct foo { ... }" also
6402                defines a typedef for "foo". Synthesize a typedef symbol so
6403                that "ptype foo" works as expected.  */
6404             if (cu->language == language_cplus)
6405               {
6406                 struct symbol *typedef_sym = (struct symbol *)
6407                   obstack_alloc (&objfile->objfile_obstack,
6408                                  sizeof (struct symbol));
6409                 *typedef_sym = *sym;
6410                 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
6411                 /* The symbol's name is already allocated along with
6412                    this objfile, so we don't need to duplicate it for
6413                    the type.  */
6414                 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
6415                   TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_NATURAL_NAME (sym);
6416                 add_symbol_to_list (typedef_sym, list_to_add);
6417               }
6418           }
6419           break;
6420         case DW_TAG_typedef:
6421           if (processing_has_namespace_info
6422               && processing_current_prefix[0] != '\0')
6423             {
6424               SYMBOL_LINKAGE_NAME (sym) = obconcat (&objfile->objfile_obstack,
6425                                                     processing_current_prefix,
6426                                                     "::",
6427                                                     name);
6428             }
6429           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6430           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6431           add_symbol_to_list (sym, cu->list_in_scope);
6432           break;
6433         case DW_TAG_base_type:
6434         case DW_TAG_subrange_type:
6435           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6436           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
6437           add_symbol_to_list (sym, cu->list_in_scope);
6438           break;
6439         case DW_TAG_enumerator:
6440           if (processing_has_namespace_info
6441               && processing_current_prefix[0] != '\0')
6442             {
6443               SYMBOL_LINKAGE_NAME (sym) = obconcat (&objfile->objfile_obstack,
6444                                                     processing_current_prefix,
6445                                                     "::",
6446                                                     name);
6447             }
6448           attr = dwarf2_attr (die, DW_AT_const_value, cu);
6449           if (attr)
6450             {
6451               dwarf2_const_value (attr, sym, cu);
6452             }
6453           {
6454             /* NOTE: carlton/2003-11-10: See comment above in the
6455                DW_TAG_class_type, etc. block.  */
6456
6457             struct pending **list_to_add;
6458
6459             list_to_add = (cu->list_in_scope == &file_symbols
6460                            && cu->language == language_cplus
6461                            ? &global_symbols : cu->list_in_scope);
6462
6463             add_symbol_to_list (sym, list_to_add);
6464           }
6465           break;
6466         case DW_TAG_namespace:
6467           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
6468           add_symbol_to_list (sym, &global_symbols);
6469           break;
6470         default:
6471           /* Not a tag we recognize.  Hopefully we aren't processing
6472              trash data, but since we must specifically ignore things
6473              we don't recognize, there is nothing else we should do at
6474              this point. */
6475           complaint (&symfile_complaints, "unsupported tag: '%s'",
6476                      dwarf_tag_name (die->tag));
6477           break;
6478         }
6479     }
6480   return (sym);
6481 }
6482
6483 /* Copy constant value from an attribute to a symbol.  */
6484
6485 static void
6486 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
6487                     struct dwarf2_cu *cu)
6488 {
6489   struct objfile *objfile = cu->objfile;
6490   struct comp_unit_head *cu_header = &cu->header;
6491   struct dwarf_block *blk;
6492
6493   switch (attr->form)
6494     {
6495     case DW_FORM_addr:
6496       if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
6497         dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
6498                                                       cu_header->addr_size,
6499                                                       TYPE_LENGTH (SYMBOL_TYPE
6500                                                                    (sym)));
6501       SYMBOL_VALUE_BYTES (sym) = (char *)
6502         obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
6503       /* NOTE: cagney/2003-05-09: In-lined store_address call with
6504          it's body - store_unsigned_integer.  */
6505       store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
6506                               DW_ADDR (attr));
6507       SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
6508       break;
6509     case DW_FORM_block1:
6510     case DW_FORM_block2:
6511     case DW_FORM_block4:
6512     case DW_FORM_block:
6513       blk = DW_BLOCK (attr);
6514       if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
6515         dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
6516                                                       blk->size,
6517                                                       TYPE_LENGTH (SYMBOL_TYPE
6518                                                                    (sym)));
6519       SYMBOL_VALUE_BYTES (sym) = (char *)
6520         obstack_alloc (&objfile->objfile_obstack, blk->size);
6521       memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
6522       SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
6523       break;
6524
6525       /* The DW_AT_const_value attributes are supposed to carry the
6526          symbol's value "represented as it would be on the target
6527          architecture."  By the time we get here, it's already been
6528          converted to host endianness, so we just need to sign- or
6529          zero-extend it as appropriate.  */
6530     case DW_FORM_data1:
6531       dwarf2_const_value_data (attr, sym, 8);
6532       break;
6533     case DW_FORM_data2:
6534       dwarf2_const_value_data (attr, sym, 16);
6535       break;
6536     case DW_FORM_data4:
6537       dwarf2_const_value_data (attr, sym, 32);
6538       break;
6539     case DW_FORM_data8:
6540       dwarf2_const_value_data (attr, sym, 64);
6541       break;
6542
6543     case DW_FORM_sdata:
6544       SYMBOL_VALUE (sym) = DW_SND (attr);
6545       SYMBOL_CLASS (sym) = LOC_CONST;
6546       break;
6547
6548     case DW_FORM_udata:
6549       SYMBOL_VALUE (sym) = DW_UNSND (attr);
6550       SYMBOL_CLASS (sym) = LOC_CONST;
6551       break;
6552
6553     default:
6554       complaint (&symfile_complaints,
6555                  "unsupported const value attribute form: '%s'",
6556                  dwarf_form_name (attr->form));
6557       SYMBOL_VALUE (sym) = 0;
6558       SYMBOL_CLASS (sym) = LOC_CONST;
6559       break;
6560     }
6561 }
6562
6563
6564 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
6565    or zero-extend it as appropriate for the symbol's type.  */
6566 static void
6567 dwarf2_const_value_data (struct attribute *attr,
6568                          struct symbol *sym,
6569                          int bits)
6570 {
6571   LONGEST l = DW_UNSND (attr);
6572
6573   if (bits < sizeof (l) * 8)
6574     {
6575       if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
6576         l &= ((LONGEST) 1 << bits) - 1;
6577       else
6578         l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
6579     }
6580
6581   SYMBOL_VALUE (sym) = l;
6582   SYMBOL_CLASS (sym) = LOC_CONST;
6583 }
6584
6585
6586 /* Return the type of the die in question using its DW_AT_type attribute.  */
6587
6588 static struct type *
6589 die_type (struct die_info *die, struct dwarf2_cu *cu)
6590 {
6591   struct type *type;
6592   struct attribute *type_attr;
6593   struct die_info *type_die;
6594   unsigned int ref;
6595
6596   type_attr = dwarf2_attr (die, DW_AT_type, cu);
6597   if (!type_attr)
6598     {
6599       /* A missing DW_AT_type represents a void type.  */
6600       return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
6601     }
6602   else
6603     {
6604       ref = dwarf2_get_ref_die_offset (type_attr, cu);
6605       type_die = follow_die_ref (ref);
6606       if (!type_die)
6607         {
6608           error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
6609                           ref, cu->objfile->name);
6610           return NULL;
6611         }
6612     }
6613   type = tag_type_to_type (type_die, cu);
6614   if (!type)
6615     {
6616       dump_die (type_die);
6617       error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
6618                       cu->objfile->name);
6619     }
6620   return type;
6621 }
6622
6623 /* Return the containing type of the die in question using its
6624    DW_AT_containing_type attribute.  */
6625
6626 static struct type *
6627 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
6628 {
6629   struct type *type = NULL;
6630   struct attribute *type_attr;
6631   struct die_info *type_die = NULL;
6632   unsigned int ref;
6633
6634   type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
6635   if (type_attr)
6636     {
6637       ref = dwarf2_get_ref_die_offset (type_attr, cu);
6638       type_die = follow_die_ref (ref);
6639       if (!type_die)
6640         {
6641           error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref,
6642                           cu->objfile->name);
6643           return NULL;
6644         }
6645       type = tag_type_to_type (type_die, cu);
6646     }
6647   if (!type)
6648     {
6649       if (type_die)
6650         dump_die (type_die);
6651       error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
6652                       cu->objfile->name);
6653     }
6654   return type;
6655 }
6656
6657 #if 0
6658 static struct type *
6659 type_at_offset (unsigned int offset, struct dwarf2_cu *cu)
6660 {
6661   struct die_info *die;
6662   struct type *type;
6663
6664   die = follow_die_ref (offset);
6665   if (!die)
6666     {
6667       error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
6668       return NULL;
6669     }
6670   type = tag_type_to_type (die, cu);
6671   return type;
6672 }
6673 #endif
6674
6675 static struct type *
6676 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
6677 {
6678   if (die->type)
6679     {
6680       return die->type;
6681     }
6682   else
6683     {
6684       read_type_die (die, cu);
6685       if (!die->type)
6686         {
6687           dump_die (die);
6688           error ("Dwarf Error: Cannot find type of die [in module %s]",
6689                           cu->objfile->name);
6690         }
6691       return die->type;
6692     }
6693 }
6694
6695 static void
6696 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
6697 {
6698   char *prefix = determine_prefix (die, cu);
6699   const char *old_prefix = processing_current_prefix;
6700   struct cleanup *back_to = make_cleanup (xfree, prefix);
6701   processing_current_prefix = prefix;
6702
6703   switch (die->tag)
6704     {
6705     case DW_TAG_class_type:
6706     case DW_TAG_structure_type:
6707     case DW_TAG_union_type:
6708       read_structure_type (die, cu);
6709       break;
6710     case DW_TAG_enumeration_type:
6711       read_enumeration_type (die, cu);
6712       break;
6713     case DW_TAG_subprogram:
6714     case DW_TAG_subroutine_type:
6715       read_subroutine_type (die, cu);
6716       break;
6717     case DW_TAG_array_type:
6718       read_array_type (die, cu);
6719       break;
6720     case DW_TAG_pointer_type:
6721       read_tag_pointer_type (die, cu);
6722       break;
6723     case DW_TAG_ptr_to_member_type:
6724       read_tag_ptr_to_member_type (die, cu);
6725       break;
6726     case DW_TAG_reference_type:
6727       read_tag_reference_type (die, cu);
6728       break;
6729     case DW_TAG_const_type:
6730       read_tag_const_type (die, cu);
6731       break;
6732     case DW_TAG_volatile_type:
6733       read_tag_volatile_type (die, cu);
6734       break;
6735     case DW_TAG_string_type:
6736       read_tag_string_type (die, cu);
6737       break;
6738     case DW_TAG_typedef:
6739       read_typedef (die, cu);
6740       break;
6741     case DW_TAG_subrange_type:
6742       read_subrange_type (die, cu);
6743       break;
6744     case DW_TAG_base_type:
6745       read_base_type (die, cu);
6746       break;
6747     default:
6748       complaint (&symfile_complaints, "unexepected tag in read_type_die: '%s'",
6749                  dwarf_tag_name (die->tag));
6750       break;
6751     }
6752
6753   processing_current_prefix = old_prefix;
6754   do_cleanups (back_to);
6755 }
6756
6757 /* Return the name of the namespace/class that DIE is defined within,
6758    or "" if we can't tell.  The caller should xfree the result.  */
6759
6760 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
6761    therein) for an example of how to use this function to deal with
6762    DW_AT_specification.  */
6763
6764 static char *
6765 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
6766 {
6767   struct die_info *parent;
6768
6769   if (cu->language != language_cplus)
6770     return NULL;
6771
6772   parent = die->parent;
6773
6774   if (parent == NULL)
6775     {
6776       return xstrdup ("");
6777     }
6778   else
6779     {
6780       switch (parent->tag) {
6781       case DW_TAG_namespace:
6782         {
6783           /* FIXME: carlton/2004-03-05: Should I follow extension dies
6784              before doing this check?  */
6785           if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
6786             {
6787               return xstrdup (TYPE_TAG_NAME (parent->type));
6788             }
6789           else
6790             {
6791               int dummy;
6792               char *parent_prefix = determine_prefix (parent, cu);
6793               char *retval = typename_concat (parent_prefix,
6794                                               namespace_name (parent, &dummy,
6795                                                               cu));
6796               xfree (parent_prefix);
6797               return retval;
6798             }
6799         }
6800         break;
6801       case DW_TAG_class_type:
6802       case DW_TAG_structure_type:
6803         {
6804           if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
6805             {
6806               return xstrdup (TYPE_TAG_NAME (parent->type));
6807             }
6808           else
6809             {
6810               const char *old_prefix = processing_current_prefix;
6811               char *new_prefix = determine_prefix (parent, cu);
6812               char *retval;
6813
6814               processing_current_prefix = new_prefix;
6815               retval = determine_class_name (parent, cu);
6816               processing_current_prefix = old_prefix;
6817
6818               xfree (new_prefix);
6819               return retval;
6820             }
6821         }
6822       default:
6823         return determine_prefix (parent, cu);
6824       }
6825     }
6826 }
6827
6828 /* Return a newly-allocated string formed by concatenating PREFIX,
6829    "::", and SUFFIX, except that if PREFIX is NULL or the empty
6830    string, just return a copy of SUFFIX.  */
6831
6832 static char *
6833 typename_concat (const char *prefix, const char *suffix)
6834 {
6835   if (prefix == NULL || prefix[0] == '\0')
6836     return xstrdup (suffix);
6837   else
6838     {
6839       char *retval = xmalloc (strlen (prefix) + 2 + strlen (suffix) + 1);
6840
6841       strcpy (retval, prefix);
6842       strcat (retval, "::");
6843       strcat (retval, suffix);
6844
6845       return retval;
6846     }
6847 }
6848
6849 static struct type *
6850 dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu)
6851 {
6852   struct objfile *objfile = cu->objfile;
6853
6854   /* FIXME - this should not produce a new (struct type *)
6855      every time.  It should cache base types.  */
6856   struct type *type;
6857   switch (encoding)
6858     {
6859     case DW_ATE_address:
6860       type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
6861       return type;
6862     case DW_ATE_boolean:
6863       type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
6864       return type;
6865     case DW_ATE_complex_float:
6866       if (size == 16)
6867         {
6868           type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
6869         }
6870       else
6871         {
6872           type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
6873         }
6874       return type;
6875     case DW_ATE_float:
6876       if (size == 8)
6877         {
6878           type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
6879         }
6880       else
6881         {
6882           type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
6883         }
6884       return type;
6885     case DW_ATE_signed:
6886       switch (size)
6887         {
6888         case 1:
6889           type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
6890           break;
6891         case 2:
6892           type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
6893           break;
6894         default:
6895         case 4:
6896           type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
6897           break;
6898         }
6899       return type;
6900     case DW_ATE_signed_char:
6901       type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
6902       return type;
6903     case DW_ATE_unsigned:
6904       switch (size)
6905         {
6906         case 1:
6907           type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
6908           break;
6909         case 2:
6910           type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
6911           break;
6912         default:
6913         case 4:
6914           type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
6915           break;
6916         }
6917       return type;
6918     case DW_ATE_unsigned_char:
6919       type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
6920       return type;
6921     default:
6922       type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
6923       return type;
6924     }
6925 }
6926
6927 #if 0
6928 struct die_info *
6929 copy_die (struct die_info *old_die)
6930 {
6931   struct die_info *new_die;
6932   int i, num_attrs;
6933
6934   new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
6935   memset (new_die, 0, sizeof (struct die_info));
6936
6937   new_die->tag = old_die->tag;
6938   new_die->has_children = old_die->has_children;
6939   new_die->abbrev = old_die->abbrev;
6940   new_die->offset = old_die->offset;
6941   new_die->type = NULL;
6942
6943   num_attrs = old_die->num_attrs;
6944   new_die->num_attrs = num_attrs;
6945   new_die->attrs = (struct attribute *)
6946     xmalloc (num_attrs * sizeof (struct attribute));
6947
6948   for (i = 0; i < old_die->num_attrs; ++i)
6949     {
6950       new_die->attrs[i].name = old_die->attrs[i].name;
6951       new_die->attrs[i].form = old_die->attrs[i].form;
6952       new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
6953     }
6954
6955   new_die->next = NULL;
6956   return new_die;
6957 }
6958 #endif
6959
6960 /* Return sibling of die, NULL if no sibling.  */
6961
6962 static struct die_info *
6963 sibling_die (struct die_info *die)
6964 {
6965   return die->sibling;
6966 }
6967
6968 /* Get linkage name of a die, return NULL if not found.  */
6969
6970 static char *
6971 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
6972 {
6973   struct attribute *attr;
6974
6975   attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
6976   if (attr && DW_STRING (attr))
6977     return DW_STRING (attr);
6978   attr = dwarf2_attr (die, DW_AT_name, cu);
6979   if (attr && DW_STRING (attr))
6980     return DW_STRING (attr);
6981   return NULL;
6982 }
6983
6984 /* Get name of a die, return NULL if not found.  */
6985
6986 static char *
6987 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
6988 {
6989   struct attribute *attr;
6990
6991   attr = dwarf2_attr (die, DW_AT_name, cu);
6992   if (attr && DW_STRING (attr))
6993     return DW_STRING (attr);
6994   return NULL;
6995 }
6996
6997 /* Return the die that this die in an extension of, or NULL if there
6998    is none.  */
6999
7000 static struct die_info *
7001 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
7002 {
7003   struct attribute *attr;
7004   struct die_info *extension_die;
7005   unsigned int ref;
7006
7007   attr = dwarf2_attr (die, DW_AT_extension, cu);
7008   if (attr == NULL)
7009     return NULL;
7010
7011   ref = dwarf2_get_ref_die_offset (attr, cu);
7012   extension_die = follow_die_ref (ref);
7013   if (!extension_die)
7014     {
7015       error ("Dwarf Error: Cannot find referent at offset %d.", ref);
7016     }
7017
7018   return extension_die;
7019 }
7020
7021 /* Convert a DIE tag into its string name.  */
7022
7023 static char *
7024 dwarf_tag_name (unsigned tag)
7025 {
7026   switch (tag)
7027     {
7028     case DW_TAG_padding:
7029       return "DW_TAG_padding";
7030     case DW_TAG_array_type:
7031       return "DW_TAG_array_type";
7032     case DW_TAG_class_type:
7033       return "DW_TAG_class_type";
7034     case DW_TAG_entry_point:
7035       return "DW_TAG_entry_point";
7036     case DW_TAG_enumeration_type:
7037       return "DW_TAG_enumeration_type";
7038     case DW_TAG_formal_parameter:
7039       return "DW_TAG_formal_parameter";
7040     case DW_TAG_imported_declaration:
7041       return "DW_TAG_imported_declaration";
7042     case DW_TAG_label:
7043       return "DW_TAG_label";
7044     case DW_TAG_lexical_block:
7045       return "DW_TAG_lexical_block";
7046     case DW_TAG_member:
7047       return "DW_TAG_member";
7048     case DW_TAG_pointer_type:
7049       return "DW_TAG_pointer_type";
7050     case DW_TAG_reference_type:
7051       return "DW_TAG_reference_type";
7052     case DW_TAG_compile_unit:
7053       return "DW_TAG_compile_unit";
7054     case DW_TAG_string_type:
7055       return "DW_TAG_string_type";
7056     case DW_TAG_structure_type:
7057       return "DW_TAG_structure_type";
7058     case DW_TAG_subroutine_type:
7059       return "DW_TAG_subroutine_type";
7060     case DW_TAG_typedef:
7061       return "DW_TAG_typedef";
7062     case DW_TAG_union_type:
7063       return "DW_TAG_union_type";
7064     case DW_TAG_unspecified_parameters:
7065       return "DW_TAG_unspecified_parameters";
7066     case DW_TAG_variant:
7067       return "DW_TAG_variant";
7068     case DW_TAG_common_block:
7069       return "DW_TAG_common_block";
7070     case DW_TAG_common_inclusion:
7071       return "DW_TAG_common_inclusion";
7072     case DW_TAG_inheritance:
7073       return "DW_TAG_inheritance";
7074     case DW_TAG_inlined_subroutine:
7075       return "DW_TAG_inlined_subroutine";
7076     case DW_TAG_module:
7077       return "DW_TAG_module";
7078     case DW_TAG_ptr_to_member_type:
7079       return "DW_TAG_ptr_to_member_type";
7080     case DW_TAG_set_type:
7081       return "DW_TAG_set_type";
7082     case DW_TAG_subrange_type:
7083       return "DW_TAG_subrange_type";
7084     case DW_TAG_with_stmt:
7085       return "DW_TAG_with_stmt";
7086     case DW_TAG_access_declaration:
7087       return "DW_TAG_access_declaration";
7088     case DW_TAG_base_type:
7089       return "DW_TAG_base_type";
7090     case DW_TAG_catch_block:
7091       return "DW_TAG_catch_block";
7092     case DW_TAG_const_type:
7093       return "DW_TAG_const_type";
7094     case DW_TAG_constant:
7095       return "DW_TAG_constant";
7096     case DW_TAG_enumerator:
7097       return "DW_TAG_enumerator";
7098     case DW_TAG_file_type:
7099       return "DW_TAG_file_type";
7100     case DW_TAG_friend:
7101       return "DW_TAG_friend";
7102     case DW_TAG_namelist:
7103       return "DW_TAG_namelist";
7104     case DW_TAG_namelist_item:
7105       return "DW_TAG_namelist_item";
7106     case DW_TAG_packed_type:
7107       return "DW_TAG_packed_type";
7108     case DW_TAG_subprogram:
7109       return "DW_TAG_subprogram";
7110     case DW_TAG_template_type_param:
7111       return "DW_TAG_template_type_param";
7112     case DW_TAG_template_value_param:
7113       return "DW_TAG_template_value_param";
7114     case DW_TAG_thrown_type:
7115       return "DW_TAG_thrown_type";
7116     case DW_TAG_try_block:
7117       return "DW_TAG_try_block";
7118     case DW_TAG_variant_part:
7119       return "DW_TAG_variant_part";
7120     case DW_TAG_variable:
7121       return "DW_TAG_variable";
7122     case DW_TAG_volatile_type:
7123       return "DW_TAG_volatile_type";
7124     case DW_TAG_dwarf_procedure:
7125       return "DW_TAG_dwarf_procedure";
7126     case DW_TAG_restrict_type:
7127       return "DW_TAG_restrict_type";
7128     case DW_TAG_interface_type:
7129       return "DW_TAG_interface_type";
7130     case DW_TAG_namespace:
7131       return "DW_TAG_namespace";
7132     case DW_TAG_imported_module:
7133       return "DW_TAG_imported_module";
7134     case DW_TAG_unspecified_type:
7135       return "DW_TAG_unspecified_type";
7136     case DW_TAG_partial_unit:
7137       return "DW_TAG_partial_unit";
7138     case DW_TAG_imported_unit:
7139       return "DW_TAG_imported_unit";
7140     case DW_TAG_MIPS_loop:
7141       return "DW_TAG_MIPS_loop";
7142     case DW_TAG_format_label:
7143       return "DW_TAG_format_label";
7144     case DW_TAG_function_template:
7145       return "DW_TAG_function_template";
7146     case DW_TAG_class_template:
7147       return "DW_TAG_class_template";
7148     default:
7149       return "DW_TAG_<unknown>";
7150     }
7151 }
7152
7153 /* Convert a DWARF attribute code into its string name.  */
7154
7155 static char *
7156 dwarf_attr_name (unsigned attr)
7157 {
7158   switch (attr)
7159     {
7160     case DW_AT_sibling:
7161       return "DW_AT_sibling";
7162     case DW_AT_location:
7163       return "DW_AT_location";
7164     case DW_AT_name:
7165       return "DW_AT_name";
7166     case DW_AT_ordering:
7167       return "DW_AT_ordering";
7168     case DW_AT_subscr_data:
7169       return "DW_AT_subscr_data";
7170     case DW_AT_byte_size:
7171       return "DW_AT_byte_size";
7172     case DW_AT_bit_offset:
7173       return "DW_AT_bit_offset";
7174     case DW_AT_bit_size:
7175       return "DW_AT_bit_size";
7176     case DW_AT_element_list:
7177       return "DW_AT_element_list";
7178     case DW_AT_stmt_list:
7179       return "DW_AT_stmt_list";
7180     case DW_AT_low_pc:
7181       return "DW_AT_low_pc";
7182     case DW_AT_high_pc:
7183       return "DW_AT_high_pc";
7184     case DW_AT_language:
7185       return "DW_AT_language";
7186     case DW_AT_member:
7187       return "DW_AT_member";
7188     case DW_AT_discr:
7189       return "DW_AT_discr";
7190     case DW_AT_discr_value:
7191       return "DW_AT_discr_value";
7192     case DW_AT_visibility:
7193       return "DW_AT_visibility";
7194     case DW_AT_import:
7195       return "DW_AT_import";
7196     case DW_AT_string_length:
7197       return "DW_AT_string_length";
7198     case DW_AT_common_reference:
7199       return "DW_AT_common_reference";
7200     case DW_AT_comp_dir:
7201       return "DW_AT_comp_dir";
7202     case DW_AT_const_value:
7203       return "DW_AT_const_value";
7204     case DW_AT_containing_type:
7205       return "DW_AT_containing_type";
7206     case DW_AT_default_value:
7207       return "DW_AT_default_value";
7208     case DW_AT_inline:
7209       return "DW_AT_inline";
7210     case DW_AT_is_optional:
7211       return "DW_AT_is_optional";
7212     case DW_AT_lower_bound:
7213       return "DW_AT_lower_bound";
7214     case DW_AT_producer:
7215       return "DW_AT_producer";
7216     case DW_AT_prototyped:
7217       return "DW_AT_prototyped";
7218     case DW_AT_return_addr:
7219       return "DW_AT_return_addr";
7220     case DW_AT_start_scope:
7221       return "DW_AT_start_scope";
7222     case DW_AT_stride_size:
7223       return "DW_AT_stride_size";
7224     case DW_AT_upper_bound:
7225       return "DW_AT_upper_bound";
7226     case DW_AT_abstract_origin:
7227       return "DW_AT_abstract_origin";
7228     case DW_AT_accessibility:
7229       return "DW_AT_accessibility";
7230     case DW_AT_address_class:
7231       return "DW_AT_address_class";
7232     case DW_AT_artificial:
7233       return "DW_AT_artificial";
7234     case DW_AT_base_types:
7235       return "DW_AT_base_types";
7236     case DW_AT_calling_convention:
7237       return "DW_AT_calling_convention";
7238     case DW_AT_count:
7239       return "DW_AT_count";
7240     case DW_AT_data_member_location:
7241       return "DW_AT_data_member_location";
7242     case DW_AT_decl_column:
7243       return "DW_AT_decl_column";
7244     case DW_AT_decl_file:
7245       return "DW_AT_decl_file";
7246     case DW_AT_decl_line:
7247       return "DW_AT_decl_line";
7248     case DW_AT_declaration:
7249       return "DW_AT_declaration";
7250     case DW_AT_discr_list:
7251       return "DW_AT_discr_list";
7252     case DW_AT_encoding:
7253       return "DW_AT_encoding";
7254     case DW_AT_external:
7255       return "DW_AT_external";
7256     case DW_AT_frame_base:
7257       return "DW_AT_frame_base";
7258     case DW_AT_friend:
7259       return "DW_AT_friend";
7260     case DW_AT_identifier_case:
7261       return "DW_AT_identifier_case";
7262     case DW_AT_macro_info:
7263       return "DW_AT_macro_info";
7264     case DW_AT_namelist_items:
7265       return "DW_AT_namelist_items";
7266     case DW_AT_priority:
7267       return "DW_AT_priority";
7268     case DW_AT_segment:
7269       return "DW_AT_segment";
7270     case DW_AT_specification:
7271       return "DW_AT_specification";
7272     case DW_AT_static_link:
7273       return "DW_AT_static_link";
7274     case DW_AT_type:
7275       return "DW_AT_type";
7276     case DW_AT_use_location:
7277       return "DW_AT_use_location";
7278     case DW_AT_variable_parameter:
7279       return "DW_AT_variable_parameter";
7280     case DW_AT_virtuality:
7281       return "DW_AT_virtuality";
7282     case DW_AT_vtable_elem_location:
7283       return "DW_AT_vtable_elem_location";
7284     case DW_AT_allocated:
7285       return "DW_AT_allocated";
7286     case DW_AT_associated:
7287       return "DW_AT_associated";
7288     case DW_AT_data_location:
7289       return "DW_AT_data_location";
7290     case DW_AT_stride:
7291       return "DW_AT_stride";
7292     case DW_AT_entry_pc:
7293       return "DW_AT_entry_pc";
7294     case DW_AT_use_UTF8:
7295       return "DW_AT_use_UTF8";
7296     case DW_AT_extension:
7297       return "DW_AT_extension";
7298     case DW_AT_ranges:
7299       return "DW_AT_ranges";
7300     case DW_AT_trampoline:
7301       return "DW_AT_trampoline";
7302     case DW_AT_call_column:
7303       return "DW_AT_call_column";
7304     case DW_AT_call_file:
7305       return "DW_AT_call_file";
7306     case DW_AT_call_line:
7307       return "DW_AT_call_line";
7308 #ifdef MIPS
7309     case DW_AT_MIPS_fde:
7310       return "DW_AT_MIPS_fde";
7311     case DW_AT_MIPS_loop_begin:
7312       return "DW_AT_MIPS_loop_begin";
7313     case DW_AT_MIPS_tail_loop_begin:
7314       return "DW_AT_MIPS_tail_loop_begin";
7315     case DW_AT_MIPS_epilog_begin:
7316       return "DW_AT_MIPS_epilog_begin";
7317     case DW_AT_MIPS_loop_unroll_factor:
7318       return "DW_AT_MIPS_loop_unroll_factor";
7319     case DW_AT_MIPS_software_pipeline_depth:
7320       return "DW_AT_MIPS_software_pipeline_depth";
7321 #endif
7322     case DW_AT_MIPS_linkage_name:
7323       return "DW_AT_MIPS_linkage_name";
7324
7325     case DW_AT_sf_names:
7326       return "DW_AT_sf_names";
7327     case DW_AT_src_info:
7328       return "DW_AT_src_info";
7329     case DW_AT_mac_info:
7330       return "DW_AT_mac_info";
7331     case DW_AT_src_coords:
7332       return "DW_AT_src_coords";
7333     case DW_AT_body_begin:
7334       return "DW_AT_body_begin";
7335     case DW_AT_body_end:
7336       return "DW_AT_body_end";
7337     case DW_AT_GNU_vector:
7338       return "DW_AT_GNU_vector";
7339     default:
7340       return "DW_AT_<unknown>";
7341     }
7342 }
7343
7344 /* Convert a DWARF value form code into its string name.  */
7345
7346 static char *
7347 dwarf_form_name (unsigned form)
7348 {
7349   switch (form)
7350     {
7351     case DW_FORM_addr:
7352       return "DW_FORM_addr";
7353     case DW_FORM_block2:
7354       return "DW_FORM_block2";
7355     case DW_FORM_block4:
7356       return "DW_FORM_block4";
7357     case DW_FORM_data2:
7358       return "DW_FORM_data2";
7359     case DW_FORM_data4:
7360       return "DW_FORM_data4";
7361     case DW_FORM_data8:
7362       return "DW_FORM_data8";
7363     case DW_FORM_string:
7364       return "DW_FORM_string";
7365     case DW_FORM_block:
7366       return "DW_FORM_block";
7367     case DW_FORM_block1:
7368       return "DW_FORM_block1";
7369     case DW_FORM_data1:
7370       return "DW_FORM_data1";
7371     case DW_FORM_flag:
7372       return "DW_FORM_flag";
7373     case DW_FORM_sdata:
7374       return "DW_FORM_sdata";
7375     case DW_FORM_strp:
7376       return "DW_FORM_strp";
7377     case DW_FORM_udata:
7378       return "DW_FORM_udata";
7379     case DW_FORM_ref_addr:
7380       return "DW_FORM_ref_addr";
7381     case DW_FORM_ref1:
7382       return "DW_FORM_ref1";
7383     case DW_FORM_ref2:
7384       return "DW_FORM_ref2";
7385     case DW_FORM_ref4:
7386       return "DW_FORM_ref4";
7387     case DW_FORM_ref8:
7388       return "DW_FORM_ref8";
7389     case DW_FORM_ref_udata:
7390       return "DW_FORM_ref_udata";
7391     case DW_FORM_indirect:
7392       return "DW_FORM_indirect";
7393     default:
7394       return "DW_FORM_<unknown>";
7395     }
7396 }
7397
7398 /* Convert a DWARF stack opcode into its string name.  */
7399
7400 static char *
7401 dwarf_stack_op_name (unsigned op)
7402 {
7403   switch (op)
7404     {
7405     case DW_OP_addr:
7406       return "DW_OP_addr";
7407     case DW_OP_deref:
7408       return "DW_OP_deref";
7409     case DW_OP_const1u:
7410       return "DW_OP_const1u";
7411     case DW_OP_const1s:
7412       return "DW_OP_const1s";
7413     case DW_OP_const2u:
7414       return "DW_OP_const2u";
7415     case DW_OP_const2s:
7416       return "DW_OP_const2s";
7417     case DW_OP_const4u:
7418       return "DW_OP_const4u";
7419     case DW_OP_const4s:
7420       return "DW_OP_const4s";
7421     case DW_OP_const8u:
7422       return "DW_OP_const8u";
7423     case DW_OP_const8s:
7424       return "DW_OP_const8s";
7425     case DW_OP_constu:
7426       return "DW_OP_constu";
7427     case DW_OP_consts:
7428       return "DW_OP_consts";
7429     case DW_OP_dup:
7430       return "DW_OP_dup";
7431     case DW_OP_drop:
7432       return "DW_OP_drop";
7433     case DW_OP_over:
7434       return "DW_OP_over";
7435     case DW_OP_pick:
7436       return "DW_OP_pick";
7437     case DW_OP_swap:
7438       return "DW_OP_swap";
7439     case DW_OP_rot:
7440       return "DW_OP_rot";
7441     case DW_OP_xderef:
7442       return "DW_OP_xderef";
7443     case DW_OP_abs:
7444       return "DW_OP_abs";
7445     case DW_OP_and:
7446       return "DW_OP_and";
7447     case DW_OP_div:
7448       return "DW_OP_div";
7449     case DW_OP_minus:
7450       return "DW_OP_minus";
7451     case DW_OP_mod:
7452       return "DW_OP_mod";
7453     case DW_OP_mul:
7454       return "DW_OP_mul";
7455     case DW_OP_neg:
7456       return "DW_OP_neg";
7457     case DW_OP_not:
7458       return "DW_OP_not";
7459     case DW_OP_or:
7460       return "DW_OP_or";
7461     case DW_OP_plus:
7462       return "DW_OP_plus";
7463     case DW_OP_plus_uconst:
7464       return "DW_OP_plus_uconst";
7465     case DW_OP_shl:
7466       return "DW_OP_shl";
7467     case DW_OP_shr:
7468       return "DW_OP_shr";
7469     case DW_OP_shra:
7470       return "DW_OP_shra";
7471     case DW_OP_xor:
7472       return "DW_OP_xor";
7473     case DW_OP_bra:
7474       return "DW_OP_bra";
7475     case DW_OP_eq:
7476       return "DW_OP_eq";
7477     case DW_OP_ge:
7478       return "DW_OP_ge";
7479     case DW_OP_gt:
7480       return "DW_OP_gt";
7481     case DW_OP_le:
7482       return "DW_OP_le";
7483     case DW_OP_lt:
7484       return "DW_OP_lt";
7485     case DW_OP_ne:
7486       return "DW_OP_ne";
7487     case DW_OP_skip:
7488       return "DW_OP_skip";
7489     case DW_OP_lit0:
7490       return "DW_OP_lit0";
7491     case DW_OP_lit1:
7492       return "DW_OP_lit1";
7493     case DW_OP_lit2:
7494       return "DW_OP_lit2";
7495     case DW_OP_lit3:
7496       return "DW_OP_lit3";
7497     case DW_OP_lit4:
7498       return "DW_OP_lit4";
7499     case DW_OP_lit5:
7500       return "DW_OP_lit5";
7501     case DW_OP_lit6:
7502       return "DW_OP_lit6";
7503     case DW_OP_lit7:
7504       return "DW_OP_lit7";
7505     case DW_OP_lit8:
7506       return "DW_OP_lit8";
7507     case DW_OP_lit9:
7508       return "DW_OP_lit9";
7509     case DW_OP_lit10:
7510       return "DW_OP_lit10";
7511     case DW_OP_lit11:
7512       return "DW_OP_lit11";
7513     case DW_OP_lit12:
7514       return "DW_OP_lit12";
7515     case DW_OP_lit13:
7516       return "DW_OP_lit13";
7517     case DW_OP_lit14:
7518       return "DW_OP_lit14";
7519     case DW_OP_lit15:
7520       return "DW_OP_lit15";
7521     case DW_OP_lit16:
7522       return "DW_OP_lit16";
7523     case DW_OP_lit17:
7524       return "DW_OP_lit17";
7525     case DW_OP_lit18:
7526       return "DW_OP_lit18";
7527     case DW_OP_lit19:
7528       return "DW_OP_lit19";
7529     case DW_OP_lit20:
7530       return "DW_OP_lit20";
7531     case DW_OP_lit21:
7532       return "DW_OP_lit21";
7533     case DW_OP_lit22:
7534       return "DW_OP_lit22";
7535     case DW_OP_lit23:
7536       return "DW_OP_lit23";
7537     case DW_OP_lit24:
7538       return "DW_OP_lit24";
7539     case DW_OP_lit25:
7540       return "DW_OP_lit25";
7541     case DW_OP_lit26:
7542       return "DW_OP_lit26";
7543     case DW_OP_lit27:
7544       return "DW_OP_lit27";
7545     case DW_OP_lit28:
7546       return "DW_OP_lit28";
7547     case DW_OP_lit29:
7548       return "DW_OP_lit29";
7549     case DW_OP_lit30:
7550       return "DW_OP_lit30";
7551     case DW_OP_lit31:
7552       return "DW_OP_lit31";
7553     case DW_OP_reg0:
7554       return "DW_OP_reg0";
7555     case DW_OP_reg1:
7556       return "DW_OP_reg1";
7557     case DW_OP_reg2:
7558       return "DW_OP_reg2";
7559     case DW_OP_reg3:
7560       return "DW_OP_reg3";
7561     case DW_OP_reg4:
7562       return "DW_OP_reg4";
7563     case DW_OP_reg5:
7564       return "DW_OP_reg5";
7565     case DW_OP_reg6:
7566       return "DW_OP_reg6";
7567     case DW_OP_reg7:
7568       return "DW_OP_reg7";
7569     case DW_OP_reg8:
7570       return "DW_OP_reg8";
7571     case DW_OP_reg9:
7572       return "DW_OP_reg9";
7573     case DW_OP_reg10:
7574       return "DW_OP_reg10";
7575     case DW_OP_reg11:
7576       return "DW_OP_reg11";
7577     case DW_OP_reg12:
7578       return "DW_OP_reg12";
7579     case DW_OP_reg13:
7580       return "DW_OP_reg13";
7581     case DW_OP_reg14:
7582       return "DW_OP_reg14";
7583     case DW_OP_reg15:
7584       return "DW_OP_reg15";
7585     case DW_OP_reg16:
7586       return "DW_OP_reg16";
7587     case DW_OP_reg17:
7588       return "DW_OP_reg17";
7589     case DW_OP_reg18:
7590       return "DW_OP_reg18";
7591     case DW_OP_reg19:
7592       return "DW_OP_reg19";
7593     case DW_OP_reg20:
7594       return "DW_OP_reg20";
7595     case DW_OP_reg21:
7596       return "DW_OP_reg21";
7597     case DW_OP_reg22:
7598       return "DW_OP_reg22";
7599     case DW_OP_reg23:
7600       return "DW_OP_reg23";
7601     case DW_OP_reg24:
7602       return "DW_OP_reg24";
7603     case DW_OP_reg25:
7604       return "DW_OP_reg25";
7605     case DW_OP_reg26:
7606       return "DW_OP_reg26";
7607     case DW_OP_reg27:
7608       return "DW_OP_reg27";
7609     case DW_OP_reg28:
7610       return "DW_OP_reg28";
7611     case DW_OP_reg29:
7612       return "DW_OP_reg29";
7613     case DW_OP_reg30:
7614       return "DW_OP_reg30";
7615     case DW_OP_reg31:
7616       return "DW_OP_reg31";
7617     case DW_OP_breg0:
7618       return "DW_OP_breg0";
7619     case DW_OP_breg1:
7620       return "DW_OP_breg1";
7621     case DW_OP_breg2:
7622       return "DW_OP_breg2";
7623     case DW_OP_breg3:
7624       return "DW_OP_breg3";
7625     case DW_OP_breg4:
7626       return "DW_OP_breg4";
7627     case DW_OP_breg5:
7628       return "DW_OP_breg5";
7629     case DW_OP_breg6:
7630       return "DW_OP_breg6";
7631     case DW_OP_breg7:
7632       return "DW_OP_breg7";
7633     case DW_OP_breg8:
7634       return "DW_OP_breg8";
7635     case DW_OP_breg9:
7636       return "DW_OP_breg9";
7637     case DW_OP_breg10:
7638       return "DW_OP_breg10";
7639     case DW_OP_breg11:
7640       return "DW_OP_breg11";
7641     case DW_OP_breg12:
7642       return "DW_OP_breg12";
7643     case DW_OP_breg13:
7644       return "DW_OP_breg13";
7645     case DW_OP_breg14:
7646       return "DW_OP_breg14";
7647     case DW_OP_breg15:
7648       return "DW_OP_breg15";
7649     case DW_OP_breg16:
7650       return "DW_OP_breg16";
7651     case DW_OP_breg17:
7652       return "DW_OP_breg17";
7653     case DW_OP_breg18:
7654       return "DW_OP_breg18";
7655     case DW_OP_breg19:
7656       return "DW_OP_breg19";
7657     case DW_OP_breg20:
7658       return "DW_OP_breg20";
7659     case DW_OP_breg21:
7660       return "DW_OP_breg21";
7661     case DW_OP_breg22:
7662       return "DW_OP_breg22";
7663     case DW_OP_breg23:
7664       return "DW_OP_breg23";
7665     case DW_OP_breg24:
7666       return "DW_OP_breg24";
7667     case DW_OP_breg25:
7668       return "DW_OP_breg25";
7669     case DW_OP_breg26:
7670       return "DW_OP_breg26";
7671     case DW_OP_breg27:
7672       return "DW_OP_breg27";
7673     case DW_OP_breg28:
7674       return "DW_OP_breg28";
7675     case DW_OP_breg29:
7676       return "DW_OP_breg29";
7677     case DW_OP_breg30:
7678       return "DW_OP_breg30";
7679     case DW_OP_breg31:
7680       return "DW_OP_breg31";
7681     case DW_OP_regx:
7682       return "DW_OP_regx";
7683     case DW_OP_fbreg:
7684       return "DW_OP_fbreg";
7685     case DW_OP_bregx:
7686       return "DW_OP_bregx";
7687     case DW_OP_piece:
7688       return "DW_OP_piece";
7689     case DW_OP_deref_size:
7690       return "DW_OP_deref_size";
7691     case DW_OP_xderef_size:
7692       return "DW_OP_xderef_size";
7693     case DW_OP_nop:
7694       return "DW_OP_nop";
7695       /* DWARF 3 extensions.  */
7696     case DW_OP_push_object_address:
7697       return "DW_OP_push_object_address";
7698     case DW_OP_call2:
7699       return "DW_OP_call2";
7700     case DW_OP_call4:
7701       return "DW_OP_call4";
7702     case DW_OP_call_ref:
7703       return "DW_OP_call_ref";
7704       /* GNU extensions.  */
7705     case DW_OP_GNU_push_tls_address:
7706       return "DW_OP_GNU_push_tls_address";
7707     default:
7708       return "OP_<unknown>";
7709     }
7710 }
7711
7712 static char *
7713 dwarf_bool_name (unsigned mybool)
7714 {
7715   if (mybool)
7716     return "TRUE";
7717   else
7718     return "FALSE";
7719 }
7720
7721 /* Convert a DWARF type code into its string name.  */
7722
7723 static char *
7724 dwarf_type_encoding_name (unsigned enc)
7725 {
7726   switch (enc)
7727     {
7728     case DW_ATE_address:
7729       return "DW_ATE_address";
7730     case DW_ATE_boolean:
7731       return "DW_ATE_boolean";
7732     case DW_ATE_complex_float:
7733       return "DW_ATE_complex_float";
7734     case DW_ATE_float:
7735       return "DW_ATE_float";
7736     case DW_ATE_signed:
7737       return "DW_ATE_signed";
7738     case DW_ATE_signed_char:
7739       return "DW_ATE_signed_char";
7740     case DW_ATE_unsigned:
7741       return "DW_ATE_unsigned";
7742     case DW_ATE_unsigned_char:
7743       return "DW_ATE_unsigned_char";
7744     case DW_ATE_imaginary_float:
7745       return "DW_ATE_imaginary_float";
7746     default:
7747       return "DW_ATE_<unknown>";
7748     }
7749 }
7750
7751 /* Convert a DWARF call frame info operation to its string name. */
7752
7753 #if 0
7754 static char *
7755 dwarf_cfi_name (unsigned cfi_opc)
7756 {
7757   switch (cfi_opc)
7758     {
7759     case DW_CFA_advance_loc:
7760       return "DW_CFA_advance_loc";
7761     case DW_CFA_offset:
7762       return "DW_CFA_offset";
7763     case DW_CFA_restore:
7764       return "DW_CFA_restore";
7765     case DW_CFA_nop:
7766       return "DW_CFA_nop";
7767     case DW_CFA_set_loc:
7768       return "DW_CFA_set_loc";
7769     case DW_CFA_advance_loc1:
7770       return "DW_CFA_advance_loc1";
7771     case DW_CFA_advance_loc2:
7772       return "DW_CFA_advance_loc2";
7773     case DW_CFA_advance_loc4:
7774       return "DW_CFA_advance_loc4";
7775     case DW_CFA_offset_extended:
7776       return "DW_CFA_offset_extended";
7777     case DW_CFA_restore_extended:
7778       return "DW_CFA_restore_extended";
7779     case DW_CFA_undefined:
7780       return "DW_CFA_undefined";
7781     case DW_CFA_same_value:
7782       return "DW_CFA_same_value";
7783     case DW_CFA_register:
7784       return "DW_CFA_register";
7785     case DW_CFA_remember_state:
7786       return "DW_CFA_remember_state";
7787     case DW_CFA_restore_state:
7788       return "DW_CFA_restore_state";
7789     case DW_CFA_def_cfa:
7790       return "DW_CFA_def_cfa";
7791     case DW_CFA_def_cfa_register:
7792       return "DW_CFA_def_cfa_register";
7793     case DW_CFA_def_cfa_offset:
7794       return "DW_CFA_def_cfa_offset";
7795
7796     /* DWARF 3 */
7797     case DW_CFA_def_cfa_expression:
7798       return "DW_CFA_def_cfa_expression";
7799     case DW_CFA_expression:
7800       return "DW_CFA_expression";
7801     case DW_CFA_offset_extended_sf:
7802       return "DW_CFA_offset_extended_sf";
7803     case DW_CFA_def_cfa_sf:
7804       return "DW_CFA_def_cfa_sf";
7805     case DW_CFA_def_cfa_offset_sf:
7806       return "DW_CFA_def_cfa_offset_sf";
7807
7808       /* SGI/MIPS specific */
7809     case DW_CFA_MIPS_advance_loc8:
7810       return "DW_CFA_MIPS_advance_loc8";
7811
7812     /* GNU extensions */
7813     case DW_CFA_GNU_window_save:
7814       return "DW_CFA_GNU_window_save";
7815     case DW_CFA_GNU_args_size:
7816       return "DW_CFA_GNU_args_size";
7817     case DW_CFA_GNU_negative_offset_extended:
7818       return "DW_CFA_GNU_negative_offset_extended";
7819
7820     default:
7821       return "DW_CFA_<unknown>";
7822     }
7823 }
7824 #endif
7825
7826 static void
7827 dump_die (struct die_info *die)
7828 {
7829   unsigned int i;
7830
7831   fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
7832            dwarf_tag_name (die->tag), die->abbrev, die->offset);
7833   fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
7834            dwarf_bool_name (die->child != NULL));
7835
7836   fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
7837   for (i = 0; i < die->num_attrs; ++i)
7838     {
7839       fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
7840                dwarf_attr_name (die->attrs[i].name),
7841                dwarf_form_name (die->attrs[i].form));
7842       switch (die->attrs[i].form)
7843         {
7844         case DW_FORM_ref_addr:
7845         case DW_FORM_addr:
7846           fprintf_unfiltered (gdb_stderr, "address: ");
7847           print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
7848           break;
7849         case DW_FORM_block2:
7850         case DW_FORM_block4:
7851         case DW_FORM_block:
7852         case DW_FORM_block1:
7853           fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
7854           break;
7855         case DW_FORM_data1:
7856         case DW_FORM_data2:
7857         case DW_FORM_data4:
7858         case DW_FORM_data8:
7859         case DW_FORM_ref1:
7860         case DW_FORM_ref2:
7861         case DW_FORM_ref4:
7862         case DW_FORM_udata:
7863         case DW_FORM_sdata:
7864           fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
7865           break;
7866         case DW_FORM_string:
7867         case DW_FORM_strp:
7868           fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
7869                    DW_STRING (&die->attrs[i])
7870                    ? DW_STRING (&die->attrs[i]) : "");
7871           break;
7872         case DW_FORM_flag:
7873           if (DW_UNSND (&die->attrs[i]))
7874             fprintf_unfiltered (gdb_stderr, "flag: TRUE");
7875           else
7876             fprintf_unfiltered (gdb_stderr, "flag: FALSE");
7877           break;
7878         case DW_FORM_indirect:
7879           /* the reader will have reduced the indirect form to
7880              the "base form" so this form should not occur */
7881           fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
7882           break;
7883         default:
7884           fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
7885                    die->attrs[i].form);
7886         }
7887       fprintf_unfiltered (gdb_stderr, "\n");
7888     }
7889 }
7890
7891 static void
7892 dump_die_list (struct die_info *die)
7893 {
7894   while (die)
7895     {
7896       dump_die (die);
7897       if (die->child != NULL)
7898         dump_die_list (die->child);
7899       if (die->sibling != NULL)
7900         dump_die_list (die->sibling);
7901     }
7902 }
7903
7904 static void
7905 store_in_ref_table (unsigned int offset, struct die_info *die)
7906 {
7907   int h;
7908   struct die_info *old;
7909
7910   h = (offset % REF_HASH_SIZE);
7911   old = die_ref_table[h];
7912   die->next_ref = old;
7913   die_ref_table[h] = die;
7914 }
7915
7916
7917 static void
7918 dwarf2_empty_hash_tables (void)
7919 {
7920   memset (die_ref_table, 0, sizeof (die_ref_table));
7921 }
7922
7923 static unsigned int
7924 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
7925 {
7926   unsigned int result = 0;
7927
7928   switch (attr->form)
7929     {
7930     case DW_FORM_ref_addr:
7931       result = DW_ADDR (attr);
7932       break;
7933     case DW_FORM_ref1:
7934     case DW_FORM_ref2:
7935     case DW_FORM_ref4:
7936     case DW_FORM_ref8:
7937     case DW_FORM_ref_udata:
7938       result = cu->header.offset + DW_UNSND (attr);
7939       break;
7940     default:
7941       complaint (&symfile_complaints,
7942                  "unsupported die ref attribute form: '%s'",
7943                  dwarf_form_name (attr->form));
7944     }
7945   return result;
7946 }
7947
7948 /* Return the constant value held by the given attribute.  Return -1
7949    if the value held by the attribute is not constant.  */
7950
7951 static int
7952 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
7953 {
7954   if (attr->form == DW_FORM_sdata)
7955     return DW_SND (attr);
7956   else if (attr->form == DW_FORM_udata
7957            || attr->form == DW_FORM_data1
7958            || attr->form == DW_FORM_data2
7959            || attr->form == DW_FORM_data4
7960            || attr->form == DW_FORM_data8)
7961     return DW_UNSND (attr);
7962   else
7963     {
7964       complaint (&symfile_complaints, "Attribute value is not a constant (%s)",
7965                  dwarf_form_name (attr->form));
7966       return default_value;
7967     }
7968 }
7969
7970 static struct die_info *
7971 follow_die_ref (unsigned int offset)
7972 {
7973   struct die_info *die;
7974   int h;
7975
7976   h = (offset % REF_HASH_SIZE);
7977   die = die_ref_table[h];
7978   while (die)
7979     {
7980       if (die->offset == offset)
7981         {
7982           return die;
7983         }
7984       die = die->next_ref;
7985     }
7986   return NULL;
7987 }
7988
7989 static struct type *
7990 dwarf2_fundamental_type (struct objfile *objfile, int typeid,
7991                          struct dwarf2_cu *cu)
7992 {
7993   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
7994     {
7995       error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
7996              typeid, objfile->name);
7997     }
7998
7999   /* Look for this particular type in the fundamental type vector.  If
8000      one is not found, create and install one appropriate for the
8001      current language and the current target machine. */
8002
8003   if (cu->ftypes[typeid] == NULL)
8004     {
8005       cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
8006     }
8007
8008   return (cu->ftypes[typeid]);
8009 }
8010
8011 /* Decode simple location descriptions.
8012    Given a pointer to a dwarf block that defines a location, compute
8013    the location and return the value.
8014
8015    NOTE drow/2003-11-18: This function is called in two situations
8016    now: for the address of static or global variables (partial symbols
8017    only) and for offsets into structures which are expected to be
8018    (more or less) constant.  The partial symbol case should go away,
8019    and only the constant case should remain.  That will let this
8020    function complain more accurately.  A few special modes are allowed
8021    without complaint for global variables (for instance, global
8022    register values and thread-local values).
8023
8024    A location description containing no operations indicates that the
8025    object is optimized out.  The return value is 0 for that case.
8026    FIXME drow/2003-11-16: No callers check for this case any more; soon all
8027    callers will only want a very basic result and this can become a
8028    complaint.
8029
8030    When the result is a register number, the global isreg flag is set,
8031    otherwise it is cleared.
8032
8033    Note that stack[0] is unused except as a default error return.
8034    Note that stack overflow is not yet handled.  */
8035
8036 static CORE_ADDR
8037 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
8038 {
8039   struct objfile *objfile = cu->objfile;
8040   struct comp_unit_head *cu_header = &cu->header;
8041   int i;
8042   int size = blk->size;
8043   char *data = blk->data;
8044   CORE_ADDR stack[64];
8045   int stacki;
8046   unsigned int bytes_read, unsnd;
8047   unsigned char op;
8048
8049   i = 0;
8050   stacki = 0;
8051   stack[stacki] = 0;
8052   isreg = 0;
8053
8054   while (i < size)
8055     {
8056       op = data[i++];
8057       switch (op)
8058         {
8059         case DW_OP_lit0:
8060         case DW_OP_lit1:
8061         case DW_OP_lit2:
8062         case DW_OP_lit3:
8063         case DW_OP_lit4:
8064         case DW_OP_lit5:
8065         case DW_OP_lit6:
8066         case DW_OP_lit7:
8067         case DW_OP_lit8:
8068         case DW_OP_lit9:
8069         case DW_OP_lit10:
8070         case DW_OP_lit11:
8071         case DW_OP_lit12:
8072         case DW_OP_lit13:
8073         case DW_OP_lit14:
8074         case DW_OP_lit15:
8075         case DW_OP_lit16:
8076         case DW_OP_lit17:
8077         case DW_OP_lit18:
8078         case DW_OP_lit19:
8079         case DW_OP_lit20:
8080         case DW_OP_lit21:
8081         case DW_OP_lit22:
8082         case DW_OP_lit23:
8083         case DW_OP_lit24:
8084         case DW_OP_lit25:
8085         case DW_OP_lit26:
8086         case DW_OP_lit27:
8087         case DW_OP_lit28:
8088         case DW_OP_lit29:
8089         case DW_OP_lit30:
8090         case DW_OP_lit31:
8091           stack[++stacki] = op - DW_OP_lit0;
8092           break;
8093
8094         case DW_OP_reg0:
8095         case DW_OP_reg1:
8096         case DW_OP_reg2:
8097         case DW_OP_reg3:
8098         case DW_OP_reg4:
8099         case DW_OP_reg5:
8100         case DW_OP_reg6:
8101         case DW_OP_reg7:
8102         case DW_OP_reg8:
8103         case DW_OP_reg9:
8104         case DW_OP_reg10:
8105         case DW_OP_reg11:
8106         case DW_OP_reg12:
8107         case DW_OP_reg13:
8108         case DW_OP_reg14:
8109         case DW_OP_reg15:
8110         case DW_OP_reg16:
8111         case DW_OP_reg17:
8112         case DW_OP_reg18:
8113         case DW_OP_reg19:
8114         case DW_OP_reg20:
8115         case DW_OP_reg21:
8116         case DW_OP_reg22:
8117         case DW_OP_reg23:
8118         case DW_OP_reg24:
8119         case DW_OP_reg25:
8120         case DW_OP_reg26:
8121         case DW_OP_reg27:
8122         case DW_OP_reg28:
8123         case DW_OP_reg29:
8124         case DW_OP_reg30:
8125         case DW_OP_reg31:
8126           isreg = 1;
8127           stack[++stacki] = op - DW_OP_reg0;
8128           if (i < size)
8129             dwarf2_complex_location_expr_complaint ();
8130           break;
8131
8132         case DW_OP_regx:
8133           isreg = 1;
8134           unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8135           i += bytes_read;
8136           stack[++stacki] = unsnd;
8137           if (i < size)
8138             dwarf2_complex_location_expr_complaint ();
8139           break;
8140
8141         case DW_OP_addr:
8142           stack[++stacki] = read_address (objfile->obfd, &data[i],
8143                                           cu, &bytes_read);
8144           i += bytes_read;
8145           break;
8146
8147         case DW_OP_const1u:
8148           stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
8149           i += 1;
8150           break;
8151
8152         case DW_OP_const1s:
8153           stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
8154           i += 1;
8155           break;
8156
8157         case DW_OP_const2u:
8158           stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
8159           i += 2;
8160           break;
8161
8162         case DW_OP_const2s:
8163           stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
8164           i += 2;
8165           break;
8166
8167         case DW_OP_const4u:
8168           stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
8169           i += 4;
8170           break;
8171
8172         case DW_OP_const4s:
8173           stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
8174           i += 4;
8175           break;
8176
8177         case DW_OP_constu:
8178           stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
8179                                                   &bytes_read);
8180           i += bytes_read;
8181           break;
8182
8183         case DW_OP_consts:
8184           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
8185           i += bytes_read;
8186           break;
8187
8188         case DW_OP_dup:
8189           stack[stacki + 1] = stack[stacki];
8190           stacki++;
8191           break;
8192
8193         case DW_OP_plus:
8194           stack[stacki - 1] += stack[stacki];
8195           stacki--;
8196           break;
8197
8198         case DW_OP_plus_uconst:
8199           stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
8200           i += bytes_read;
8201           break;
8202
8203         case DW_OP_minus:
8204           stack[stacki - 1] -= stack[stacki];
8205           stacki--;
8206           break;
8207
8208         case DW_OP_deref:
8209           /* If we're not the last op, then we definitely can't encode
8210              this using GDB's address_class enum.  This is valid for partial
8211              global symbols, although the variable's address will be bogus
8212              in the psymtab.  */
8213           if (i < size)
8214             dwarf2_complex_location_expr_complaint ();
8215           break;
8216
8217         case DW_OP_GNU_push_tls_address:
8218           /* The top of the stack has the offset from the beginning
8219              of the thread control block at which the variable is located.  */
8220           /* Nothing should follow this operator, so the top of stack would
8221              be returned.  */
8222           /* This is valid for partial global symbols, but the variable's
8223              address will be bogus in the psymtab.  */
8224           if (i < size)
8225             dwarf2_complex_location_expr_complaint ();
8226           break;
8227
8228         default:
8229           complaint (&symfile_complaints, "unsupported stack op: '%s'",
8230                      dwarf_stack_op_name (op));
8231           return (stack[stacki]);
8232         }
8233     }
8234   return (stack[stacki]);
8235 }
8236
8237 /* memory allocation interface */
8238
8239 static struct dwarf_block *
8240 dwarf_alloc_block (struct dwarf2_cu *cu)
8241 {
8242   struct dwarf_block *blk;
8243
8244   blk = (struct dwarf_block *)
8245     obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
8246   return (blk);
8247 }
8248
8249 static struct abbrev_info *
8250 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
8251 {
8252   struct abbrev_info *abbrev;
8253
8254   abbrev = (struct abbrev_info *)
8255     obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
8256   memset (abbrev, 0, sizeof (struct abbrev_info));
8257   return (abbrev);
8258 }
8259
8260 static struct die_info *
8261 dwarf_alloc_die (void)
8262 {
8263   struct die_info *die;
8264
8265   die = (struct die_info *) xmalloc (sizeof (struct die_info));
8266   memset (die, 0, sizeof (struct die_info));
8267   return (die);
8268 }
8269
8270 \f
8271 /* Macro support.  */
8272
8273
8274 /* Return the full name of file number I in *LH's file name table.
8275    Use COMP_DIR as the name of the current directory of the
8276    compilation.  The result is allocated using xmalloc; the caller is
8277    responsible for freeing it.  */
8278 static char *
8279 file_full_name (int file, struct line_header *lh, const char *comp_dir)
8280 {
8281   struct file_entry *fe = &lh->file_names[file - 1];
8282
8283   if (IS_ABSOLUTE_PATH (fe->name))
8284     return xstrdup (fe->name);
8285   else
8286     {
8287       const char *dir;
8288       int dir_len;
8289       char *full_name;
8290
8291       if (fe->dir_index)
8292         dir = lh->include_dirs[fe->dir_index - 1];
8293       else
8294         dir = comp_dir;
8295
8296       if (dir)
8297         {
8298           dir_len = strlen (dir);
8299           full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
8300           strcpy (full_name, dir);
8301           full_name[dir_len] = '/';
8302           strcpy (full_name + dir_len + 1, fe->name);
8303           return full_name;
8304         }
8305       else
8306         return xstrdup (fe->name);
8307     }
8308 }
8309
8310
8311 static struct macro_source_file *
8312 macro_start_file (int file, int line,
8313                   struct macro_source_file *current_file,
8314                   const char *comp_dir,
8315                   struct line_header *lh, struct objfile *objfile)
8316 {
8317   /* The full name of this source file.  */
8318   char *full_name = file_full_name (file, lh, comp_dir);
8319
8320   /* We don't create a macro table for this compilation unit
8321      at all until we actually get a filename.  */
8322   if (! pending_macros)
8323     pending_macros = new_macro_table (&objfile->objfile_obstack,
8324                                       objfile->macro_cache);
8325
8326   if (! current_file)
8327     /* If we have no current file, then this must be the start_file
8328        directive for the compilation unit's main source file.  */
8329     current_file = macro_set_main (pending_macros, full_name);
8330   else
8331     current_file = macro_include (current_file, line, full_name);
8332
8333   xfree (full_name);
8334
8335   return current_file;
8336 }
8337
8338
8339 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8340    followed by a null byte.  */
8341 static char *
8342 copy_string (const char *buf, int len)
8343 {
8344   char *s = xmalloc (len + 1);
8345   memcpy (s, buf, len);
8346   s[len] = '\0';
8347
8348   return s;
8349 }
8350
8351
8352 static const char *
8353 consume_improper_spaces (const char *p, const char *body)
8354 {
8355   if (*p == ' ')
8356     {
8357       complaint (&symfile_complaints,
8358                  "macro definition contains spaces in formal argument list:\n`%s'",
8359                  body);
8360
8361       while (*p == ' ')
8362         p++;
8363     }
8364
8365   return p;
8366 }
8367
8368
8369 static void
8370 parse_macro_definition (struct macro_source_file *file, int line,
8371                         const char *body)
8372 {
8373   const char *p;
8374
8375   /* The body string takes one of two forms.  For object-like macro
8376      definitions, it should be:
8377
8378         <macro name> " " <definition>
8379
8380      For function-like macro definitions, it should be:
8381
8382         <macro name> "() " <definition>
8383      or
8384         <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8385
8386      Spaces may appear only where explicitly indicated, and in the
8387      <definition>.
8388
8389      The Dwarf 2 spec says that an object-like macro's name is always
8390      followed by a space, but versions of GCC around March 2002 omit
8391      the space when the macro's definition is the empty string.
8392
8393      The Dwarf 2 spec says that there should be no spaces between the
8394      formal arguments in a function-like macro's formal argument list,
8395      but versions of GCC around March 2002 include spaces after the
8396      commas.  */
8397
8398
8399   /* Find the extent of the macro name.  The macro name is terminated
8400      by either a space or null character (for an object-like macro) or
8401      an opening paren (for a function-like macro).  */
8402   for (p = body; *p; p++)
8403     if (*p == ' ' || *p == '(')
8404       break;
8405
8406   if (*p == ' ' || *p == '\0')
8407     {
8408       /* It's an object-like macro.  */
8409       int name_len = p - body;
8410       char *name = copy_string (body, name_len);
8411       const char *replacement;
8412
8413       if (*p == ' ')
8414         replacement = body + name_len + 1;
8415       else
8416         {
8417           dwarf2_macro_malformed_definition_complaint (body);
8418           replacement = body + name_len;
8419         }
8420
8421       macro_define_object (file, line, name, replacement);
8422
8423       xfree (name);
8424     }
8425   else if (*p == '(')
8426     {
8427       /* It's a function-like macro.  */
8428       char *name = copy_string (body, p - body);
8429       int argc = 0;
8430       int argv_size = 1;
8431       char **argv = xmalloc (argv_size * sizeof (*argv));
8432
8433       p++;
8434
8435       p = consume_improper_spaces (p, body);
8436
8437       /* Parse the formal argument list.  */
8438       while (*p && *p != ')')
8439         {
8440           /* Find the extent of the current argument name.  */
8441           const char *arg_start = p;
8442
8443           while (*p && *p != ',' && *p != ')' && *p != ' ')
8444             p++;
8445
8446           if (! *p || p == arg_start)
8447             dwarf2_macro_malformed_definition_complaint (body);
8448           else
8449             {
8450               /* Make sure argv has room for the new argument.  */
8451               if (argc >= argv_size)
8452                 {
8453                   argv_size *= 2;
8454                   argv = xrealloc (argv, argv_size * sizeof (*argv));
8455                 }
8456
8457               argv[argc++] = copy_string (arg_start, p - arg_start);
8458             }
8459
8460           p = consume_improper_spaces (p, body);
8461
8462           /* Consume the comma, if present.  */
8463           if (*p == ',')
8464             {
8465               p++;
8466
8467               p = consume_improper_spaces (p, body);
8468             }
8469         }
8470
8471       if (*p == ')')
8472         {
8473           p++;
8474
8475           if (*p == ' ')
8476             /* Perfectly formed definition, no complaints.  */
8477             macro_define_function (file, line, name,
8478                                    argc, (const char **) argv,
8479                                    p + 1);
8480           else if (*p == '\0')
8481             {
8482               /* Complain, but do define it.  */
8483               dwarf2_macro_malformed_definition_complaint (body);
8484               macro_define_function (file, line, name,
8485                                      argc, (const char **) argv,
8486                                      p);
8487             }
8488           else
8489             /* Just complain.  */
8490             dwarf2_macro_malformed_definition_complaint (body);
8491         }
8492       else
8493         /* Just complain.  */
8494         dwarf2_macro_malformed_definition_complaint (body);
8495
8496       xfree (name);
8497       {
8498         int i;
8499
8500         for (i = 0; i < argc; i++)
8501           xfree (argv[i]);
8502       }
8503       xfree (argv);
8504     }
8505   else
8506     dwarf2_macro_malformed_definition_complaint (body);
8507 }
8508
8509
8510 static void
8511 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
8512                      char *comp_dir, bfd *abfd,
8513                      struct dwarf2_cu *cu)
8514 {
8515   char *mac_ptr, *mac_end;
8516   struct macro_source_file *current_file = 0;
8517
8518   if (dwarf2_per_objfile->macinfo_buffer == NULL)
8519     {
8520       complaint (&symfile_complaints, "missing .debug_macinfo section");
8521       return;
8522     }
8523
8524   mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset;
8525   mac_end = dwarf2_per_objfile->macinfo_buffer
8526     + dwarf2_per_objfile->macinfo_size;
8527
8528   for (;;)
8529     {
8530       enum dwarf_macinfo_record_type macinfo_type;
8531
8532       /* Do we at least have room for a macinfo type byte?  */
8533       if (mac_ptr >= mac_end)
8534         {
8535           dwarf2_macros_too_long_complaint ();
8536           return;
8537         }
8538
8539       macinfo_type = read_1_byte (abfd, mac_ptr);
8540       mac_ptr++;
8541
8542       switch (macinfo_type)
8543         {
8544           /* A zero macinfo type indicates the end of the macro
8545              information.  */
8546         case 0:
8547           return;
8548
8549         case DW_MACINFO_define:
8550         case DW_MACINFO_undef:
8551           {
8552             int bytes_read;
8553             int line;
8554             char *body;
8555
8556             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
8557             mac_ptr += bytes_read;
8558             body = read_string (abfd, mac_ptr, &bytes_read);
8559             mac_ptr += bytes_read;
8560
8561             if (! current_file)
8562               complaint (&symfile_complaints,
8563                          "debug info gives macro %s outside of any file: %s",
8564                          macinfo_type ==
8565                          DW_MACINFO_define ? "definition" : macinfo_type ==
8566                          DW_MACINFO_undef ? "undefinition" :
8567                          "something-or-other", body);
8568             else
8569               {
8570                 if (macinfo_type == DW_MACINFO_define)
8571                   parse_macro_definition (current_file, line, body);
8572                 else if (macinfo_type == DW_MACINFO_undef)
8573                   macro_undef (current_file, line, body);
8574               }
8575           }
8576           break;
8577
8578         case DW_MACINFO_start_file:
8579           {
8580             int bytes_read;
8581             int line, file;
8582
8583             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
8584             mac_ptr += bytes_read;
8585             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
8586             mac_ptr += bytes_read;
8587
8588             current_file = macro_start_file (file, line,
8589                                              current_file, comp_dir,
8590                                              lh, cu->objfile);
8591           }
8592           break;
8593
8594         case DW_MACINFO_end_file:
8595           if (! current_file)
8596             complaint (&symfile_complaints,
8597                        "macro debug info has an unmatched `close_file' directive");
8598           else
8599             {
8600               current_file = current_file->included_by;
8601               if (! current_file)
8602                 {
8603                   enum dwarf_macinfo_record_type next_type;
8604
8605                   /* GCC circa March 2002 doesn't produce the zero
8606                      type byte marking the end of the compilation
8607                      unit.  Complain if it's not there, but exit no
8608                      matter what.  */
8609
8610                   /* Do we at least have room for a macinfo type byte?  */
8611                   if (mac_ptr >= mac_end)
8612                     {
8613                       dwarf2_macros_too_long_complaint ();
8614                       return;
8615                     }
8616
8617                   /* We don't increment mac_ptr here, so this is just
8618                      a look-ahead.  */
8619                   next_type = read_1_byte (abfd, mac_ptr);
8620                   if (next_type != 0)
8621                     complaint (&symfile_complaints,
8622                                "no terminating 0-type entry for macros in `.debug_macinfo' section");
8623
8624                   return;
8625                 }
8626             }
8627           break;
8628
8629         case DW_MACINFO_vendor_ext:
8630           {
8631             int bytes_read;
8632             int constant;
8633             char *string;
8634
8635             constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
8636             mac_ptr += bytes_read;
8637             string = read_string (abfd, mac_ptr, &bytes_read);
8638             mac_ptr += bytes_read;
8639
8640             /* We don't recognize any vendor extensions.  */
8641           }
8642           break;
8643         }
8644     }
8645 }
8646
8647 /* Check if the attribute's form is a DW_FORM_block*
8648    if so return true else false. */
8649 static int
8650 attr_form_is_block (struct attribute *attr)
8651 {
8652   return (attr == NULL ? 0 :
8653       attr->form == DW_FORM_block1
8654       || attr->form == DW_FORM_block2
8655       || attr->form == DW_FORM_block4
8656       || attr->form == DW_FORM_block);
8657 }
8658
8659 static void
8660 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
8661                              struct dwarf2_cu *cu)
8662 {
8663   if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
8664     {
8665       struct dwarf2_loclist_baton *baton;
8666
8667       baton = obstack_alloc (&cu->objfile->objfile_obstack,
8668                              sizeof (struct dwarf2_loclist_baton));
8669       baton->objfile = cu->objfile;
8670
8671       /* We don't know how long the location list is, but make sure we
8672          don't run off the edge of the section.  */
8673       baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr);
8674       baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr);
8675       baton->base_address = cu->header.base_address;
8676       if (cu->header.base_known == 0)
8677         complaint (&symfile_complaints,
8678                    "Location list used without specifying the CU base address.");
8679
8680       SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
8681       SYMBOL_LOCATION_BATON (sym) = baton;
8682     }
8683   else
8684     {
8685       struct dwarf2_locexpr_baton *baton;
8686
8687       baton = obstack_alloc (&cu->objfile->objfile_obstack,
8688                              sizeof (struct dwarf2_locexpr_baton));
8689       baton->objfile = cu->objfile;
8690
8691       if (attr_form_is_block (attr))
8692         {
8693           /* Note that we're just copying the block's data pointer
8694              here, not the actual data.  We're still pointing into the
8695              info_buffer for SYM's objfile; right now we never release
8696              that buffer, but when we do clean up properly this may
8697              need to change.  */
8698           baton->size = DW_BLOCK (attr)->size;
8699           baton->data = DW_BLOCK (attr)->data;
8700         }
8701       else
8702         {
8703           dwarf2_invalid_attrib_class_complaint ("location description",
8704                                                  SYMBOL_NATURAL_NAME (sym));
8705           baton->size = 0;
8706           baton->data = NULL;
8707         }
8708
8709       SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
8710       SYMBOL_LOCATION_BATON (sym) = baton;
8711     }
8712 }
8713
8714 /* This cleanup function is passed the address of a dwarf2_cu on the stack
8715    when we're finished with it.  We can't free the pointer itself, but
8716    release any associated storage.
8717
8718    Only used during partial symbol parsing.  */
8719
8720 static void
8721 free_stack_comp_unit (void *data)
8722 {
8723   struct dwarf2_cu *cu = data;
8724
8725   obstack_free (&cu->comp_unit_obstack, NULL);
8726   cu->partial_dies = NULL;
8727 }
8728
8729 /* Allocation function for the libiberty hash table which uses an
8730    obstack.  */
8731
8732 static void *
8733 hashtab_obstack_allocate (void *data, size_t size, size_t count)
8734 {
8735   unsigned int total = size * count;
8736   void *ptr = obstack_alloc ((struct obstack *) data, total);
8737   memset (ptr, 0, total);
8738   return ptr;
8739 }
8740
8741 /* Trivial deallocation function for the libiberty splay tree and hash
8742    table - don't deallocate anything.  Rely on later deletion of the
8743    obstack.  */
8744
8745 static void
8746 dummy_obstack_deallocate (void *object, void *data)
8747 {
8748   return;
8749 }
8750
8751 /* Trivial hash function for partial_die_info: the hash value of a DIE
8752    is its offset in .debug_info for this objfile.  */
8753
8754 static hashval_t
8755 partial_die_hash (const void *item)
8756 {
8757   const struct partial_die_info *part_die = item;
8758   return part_die->offset;
8759 }
8760
8761 /* Trivial comparison function for partial_die_info structures: two DIEs
8762    are equal if they have the same offset.  */
8763
8764 static int
8765 partial_die_eq (const void *item_lhs, const void *item_rhs)
8766 {
8767   const struct partial_die_info *part_die_lhs = item_lhs;
8768   const struct partial_die_info *part_die_rhs = item_rhs;
8769   return part_die_lhs->offset == part_die_rhs->offset;
8770 }
8771
8772 void _initialize_dwarf2_read (void);
8773
8774 void
8775 _initialize_dwarf2_read (void)
8776 {
8777   dwarf2_objfile_data_key = register_objfile_data ();
8778 }