gdb/dwarf2read.c

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