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