contrib/gdb-7/gdb/dwarf2read.c

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