gdb/dwarf2read.c

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