gdb/dwarf2read.c

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