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 (gdbarch_bits_big_endian (current_gdbarch))
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   /* The enumeration DIE can be incomplete.  In Ada, any type can be
4237      declared as private in the package spec, and then defined only
4238      inside the package body.  Such types are known as Taft Amendment
4239      Types.  When another package uses such a type, an incomplete DIE
4240      may be generated by the compiler.  */
4241   if (die_is_declaration (die, cu))
4242     TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
4243
4244   set_die_type (die, type, cu);
4245 }
4246
4247 /* Determine the name of the type represented by DIE, which should be
4248    a named C++ or Java compound type.  Return the name in question; the caller
4249    is responsible for xfree()'ing it.  */
4250
4251 static char *
4252 determine_class_name (struct die_info *die, struct dwarf2_cu *cu)
4253 {
4254   struct cleanup *back_to = NULL;
4255   struct die_info *spec_die = die_specification (die, cu);
4256   char *new_prefix = NULL;
4257
4258   /* If this is the definition of a class that is declared by another
4259      die, then processing_current_prefix may not be accurate; see
4260      read_func_scope for a similar example.  */
4261   if (spec_die != NULL)
4262     {
4263       char *specification_prefix = determine_prefix (spec_die, cu);
4264       processing_current_prefix = specification_prefix;
4265       back_to = make_cleanup (xfree, specification_prefix);
4266     }
4267
4268   /* If we don't have namespace debug info, guess the name by trying
4269      to demangle the names of members, just like we did in
4270      guess_structure_name.  */
4271   if (!processing_has_namespace_info)
4272     {
4273       struct die_info *child;
4274
4275       for (child = die->child;
4276            child != NULL && child->tag != 0;
4277            child = sibling_die (child))
4278         {
4279           if (child->tag == DW_TAG_subprogram)
4280             {
4281               new_prefix
4282                 = language_class_name_from_physname (cu->language_defn,
4283                                                      dwarf2_linkage_name
4284                                                      (child, cu));
4285
4286               if (new_prefix != NULL)
4287                 break;
4288             }
4289         }
4290     }
4291
4292   if (new_prefix == NULL)
4293     {
4294       const char *name = dwarf2_name (die, cu);
4295       new_prefix = typename_concat (NULL, processing_current_prefix,
4296                                     name ? name : "<<anonymous>>",
4297                                     cu);
4298     }
4299
4300   if (back_to != NULL)
4301     do_cleanups (back_to);
4302
4303   return new_prefix;
4304 }
4305
4306 /* Given a pointer to a die which begins an enumeration, process all
4307    the dies that define the members of the enumeration, and create the
4308    symbol for the enumeration type.
4309
4310    NOTE: We reverse the order of the element list.  */
4311
4312 static void
4313 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
4314 {
4315   struct objfile *objfile = cu->objfile;
4316   struct die_info *child_die;
4317   struct field *fields;
4318   struct symbol *sym;
4319   int num_fields;
4320   int unsigned_enum = 1;
4321   char *name;
4322
4323   num_fields = 0;
4324   fields = NULL;
4325   if (die->child != NULL)
4326     {
4327       child_die = die->child;
4328       while (child_die && child_die->tag)
4329         {
4330           if (child_die->tag != DW_TAG_enumerator)
4331             {
4332               process_die (child_die, cu);
4333             }
4334           else
4335             {
4336               name = dwarf2_name (child_die, cu);
4337               if (name)
4338                 {
4339                   sym = new_symbol (child_die, die->type, cu);
4340                   if (SYMBOL_VALUE (sym) < 0)
4341                     unsigned_enum = 0;
4342
4343                   if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
4344                     {
4345                       fields = (struct field *)
4346                         xrealloc (fields,
4347                                   (num_fields + DW_FIELD_ALLOC_CHUNK)
4348                                   * sizeof (struct field));
4349                     }
4350
4351                   FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
4352                   FIELD_TYPE (fields[num_fields]) = NULL;
4353                   FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
4354                   FIELD_BITSIZE (fields[num_fields]) = 0;
4355                   FIELD_STATIC_KIND (fields[num_fields]) = 0;
4356
4357                   num_fields++;
4358                 }
4359             }
4360
4361           child_die = sibling_die (child_die);
4362         }
4363
4364       if (num_fields)
4365         {
4366           TYPE_NFIELDS (die->type) = num_fields;
4367           TYPE_FIELDS (die->type) = (struct field *)
4368             TYPE_ALLOC (die->type, sizeof (struct field) * num_fields);
4369           memcpy (TYPE_FIELDS (die->type), fields,
4370                   sizeof (struct field) * num_fields);
4371           xfree (fields);
4372         }
4373       if (unsigned_enum)
4374         TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED;
4375     }
4376
4377   new_symbol (die, die->type, cu);
4378 }
4379
4380 /* Extract all information from a DW_TAG_array_type DIE and put it in
4381    the DIE's type field.  For now, this only handles one dimensional
4382    arrays.  */
4383
4384 static void
4385 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
4386 {
4387   struct objfile *objfile = cu->objfile;
4388   struct die_info *child_die;
4389   struct type *type = NULL;
4390   struct type *element_type, *range_type, *index_type;
4391   struct type **range_types = NULL;
4392   struct attribute *attr;
4393   int ndim = 0;
4394   struct cleanup *back_to;
4395   char *name;
4396
4397   /* Return if we've already decoded this type. */
4398   if (die->type)
4399     {
4400       return;
4401     }
4402
4403   element_type = die_type (die, cu);
4404
4405   /* Irix 6.2 native cc creates array types without children for
4406      arrays with unspecified length.  */
4407   if (die->child == NULL)
4408     {
4409       index_type = builtin_type_int32;
4410       range_type = create_range_type (NULL, index_type, 0, -1);
4411       set_die_type (die, create_array_type (NULL, element_type, range_type),
4412                     cu);
4413       return;
4414     }
4415
4416   back_to = make_cleanup (null_cleanup, NULL);
4417   child_die = die->child;
4418   while (child_die && child_die->tag)
4419     {
4420       if (child_die->tag == DW_TAG_subrange_type)
4421         {
4422           read_subrange_type (child_die, cu);
4423
4424           if (child_die->type != NULL)
4425             {
4426               /* The range type was succesfully read. Save it for
4427                  the array type creation.  */
4428               if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
4429                 {
4430                   range_types = (struct type **)
4431                     xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
4432                               * sizeof (struct type *));
4433                   if (ndim == 0)
4434                     make_cleanup (free_current_contents, &range_types);
4435                 }
4436               range_types[ndim++] = child_die->type;
4437             }
4438         }
4439       child_die = sibling_die (child_die);
4440     }
4441
4442   /* Dwarf2 dimensions are output from left to right, create the
4443      necessary array types in backwards order.  */
4444
4445   type = element_type;
4446
4447   if (read_array_order (die, cu) == DW_ORD_col_major)
4448     {
4449       int i = 0;
4450       while (i < ndim)
4451         type = create_array_type (NULL, type, range_types[i++]);
4452     }
4453   else
4454     {
4455       while (ndim-- > 0)
4456         type = create_array_type (NULL, type, range_types[ndim]);
4457     }
4458
4459   /* Understand Dwarf2 support for vector types (like they occur on
4460      the PowerPC w/ AltiVec).  Gcc just adds another attribute to the
4461      array type.  This is not part of the Dwarf2/3 standard yet, but a
4462      custom vendor extension.  The main difference between a regular
4463      array and the vector variant is that vectors are passed by value
4464      to functions.  */
4465   attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
4466   if (attr)
4467     make_vector_type (type);
4468
4469   name = dwarf2_name (die, cu);
4470   if (name)
4471     TYPE_NAME (type) = name;
4472
4473   do_cleanups (back_to);
4474
4475   /* Install the type in the die. */
4476   set_die_type (die, type, cu);
4477 }
4478
4479 static enum dwarf_array_dim_ordering
4480 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
4481 {
4482   struct attribute *attr;
4483
4484   attr = dwarf2_attr (die, DW_AT_ordering, cu);
4485
4486   if (attr) return DW_SND (attr);
4487
4488   /*
4489     GNU F77 is a special case, as at 08/2004 array type info is the
4490     opposite order to the dwarf2 specification, but data is still
4491     laid out as per normal fortran.
4492
4493     FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4494     version checking.
4495   */
4496
4497   if (cu->language == language_fortran &&
4498       cu->producer && strstr (cu->producer, "GNU F77"))
4499     {
4500       return DW_ORD_row_major;
4501     }
4502
4503   switch (cu->language_defn->la_array_ordering)
4504     {
4505     case array_column_major:
4506       return DW_ORD_col_major;
4507     case array_row_major:
4508     default:
4509       return DW_ORD_row_major;
4510     };
4511 }
4512
4513 /* Extract all information from a DW_TAG_set_type DIE and put it in
4514    the DIE's type field. */
4515
4516 static void
4517 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
4518 {
4519   if (die->type == NULL)
4520     die->type = create_set_type ((struct type *) NULL, die_type (die, cu));
4521 }
4522
4523 /* First cut: install each common block member as a global variable.  */
4524
4525 static void
4526 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
4527 {
4528   struct die_info *child_die;
4529   struct attribute *attr;
4530   struct symbol *sym;
4531   CORE_ADDR base = (CORE_ADDR) 0;
4532
4533   attr = dwarf2_attr (die, DW_AT_location, cu);
4534   if (attr)
4535     {
4536       /* Support the .debug_loc offsets */
4537       if (attr_form_is_block (attr))
4538         {
4539           base = decode_locdesc (DW_BLOCK (attr), cu);
4540         }
4541       else if (attr_form_is_section_offset (attr))
4542         {
4543           dwarf2_complex_location_expr_complaint ();
4544         }
4545       else
4546         {
4547           dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4548                                                  "common block member");
4549         }
4550     }
4551   if (die->child != NULL)
4552     {
4553       child_die = die->child;
4554       while (child_die && child_die->tag)
4555         {
4556           sym = new_symbol (child_die, NULL, cu);
4557           attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
4558           if (attr)
4559             {
4560               SYMBOL_VALUE_ADDRESS (sym) =
4561                 base + decode_locdesc (DW_BLOCK (attr), cu);
4562               add_symbol_to_list (sym, &global_symbols);
4563             }
4564           child_die = sibling_die (child_die);
4565         }
4566     }
4567 }
4568
4569 /* Read a C++ namespace.  */
4570
4571 static void
4572 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
4573 {
4574   struct objfile *objfile = cu->objfile;
4575   const char *previous_prefix = processing_current_prefix;
4576   const char *name;
4577   int is_anonymous;
4578   struct die_info *current_die;
4579   struct cleanup *back_to = make_cleanup (null_cleanup, 0);
4580
4581   name = namespace_name (die, &is_anonymous, cu);
4582
4583   /* Now build the name of the current namespace.  */
4584
4585   if (previous_prefix[0] == '\0')
4586     {
4587       processing_current_prefix = name;
4588     }
4589   else
4590     {
4591       char *temp_name = typename_concat (NULL, previous_prefix, name, cu);
4592       make_cleanup (xfree, temp_name);
4593       processing_current_prefix = temp_name;
4594     }
4595
4596   /* Add a symbol associated to this if we haven't seen the namespace
4597      before.  Also, add a using directive if it's an anonymous
4598      namespace.  */
4599
4600   if (dwarf2_extension (die, cu) == NULL)
4601     {
4602       struct type *type;
4603
4604       /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4605          this cast will hopefully become unnecessary.  */
4606       type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
4607                         (char *) processing_current_prefix,
4608                         objfile);
4609       TYPE_TAG_NAME (type) = TYPE_NAME (type);
4610
4611       new_symbol (die, type, cu);
4612       set_die_type (die, type, cu);
4613
4614       if (is_anonymous)
4615         cp_add_using_directive (processing_current_prefix,
4616                                 strlen (previous_prefix),
4617                                 strlen (processing_current_prefix));
4618     }
4619
4620   if (die->child != NULL)
4621     {
4622       struct die_info *child_die = die->child;
4623
4624       while (child_die && child_die->tag)
4625         {
4626           process_die (child_die, cu);
4627           child_die = sibling_die (child_die);
4628         }
4629     }
4630
4631   processing_current_prefix = previous_prefix;
4632   do_cleanups (back_to);
4633 }
4634
4635 /* Return the name of the namespace represented by DIE.  Set
4636    *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4637    namespace.  */
4638
4639 static const char *
4640 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
4641 {
4642   struct die_info *current_die;
4643   const char *name = NULL;
4644
4645   /* Loop through the extensions until we find a name.  */
4646
4647   for (current_die = die;
4648        current_die != NULL;
4649        current_die = dwarf2_extension (die, cu))
4650     {
4651       name = dwarf2_name (current_die, cu);
4652       if (name != NULL)
4653         break;
4654     }
4655
4656   /* Is it an anonymous namespace?  */
4657
4658   *is_anonymous = (name == NULL);
4659   if (*is_anonymous)
4660     name = "(anonymous namespace)";
4661
4662   return name;
4663 }
4664
4665 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4666    the user defined type vector.  */
4667
4668 static void
4669 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
4670 {
4671   struct comp_unit_head *cu_header = &cu->header;
4672   struct type *type;
4673   struct attribute *attr_byte_size;
4674   struct attribute *attr_address_class;
4675   int byte_size, addr_class;
4676
4677   if (die->type)
4678     {
4679       return;
4680     }
4681
4682   type = lookup_pointer_type (die_type (die, cu));
4683
4684   attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
4685   if (attr_byte_size)
4686     byte_size = DW_UNSND (attr_byte_size);
4687   else
4688     byte_size = cu_header->addr_size;
4689
4690   attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
4691   if (attr_address_class)
4692     addr_class = DW_UNSND (attr_address_class);
4693   else
4694     addr_class = DW_ADDR_none;
4695
4696   /* If the pointer size or address class is different than the
4697      default, create a type variant marked as such and set the
4698      length accordingly.  */
4699   if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
4700     {
4701       if (gdbarch_address_class_type_flags_p (current_gdbarch))
4702         {
4703           int type_flags;
4704
4705           type_flags = gdbarch_address_class_type_flags
4706                          (current_gdbarch, byte_size, addr_class);
4707           gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
4708           type = make_type_with_address_space (type, type_flags);
4709         }
4710       else if (TYPE_LENGTH (type) != byte_size)
4711         {
4712           complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
4713         }
4714       else {
4715         /* Should we also complain about unhandled address classes?  */
4716       }
4717     }
4718
4719   TYPE_LENGTH (type) = byte_size;
4720   set_die_type (die, type, cu);
4721 }
4722
4723 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4724    the user defined type vector.  */
4725
4726 static void
4727 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
4728 {
4729   struct objfile *objfile = cu->objfile;
4730   struct type *type;
4731   struct type *to_type;
4732   struct type *domain;
4733
4734   if (die->type)
4735     {
4736       return;
4737     }
4738
4739   to_type = die_type (die, cu);
4740   domain = die_containing_type (die, cu);
4741
4742   if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
4743     type = lookup_methodptr_type (to_type);
4744   else
4745     type = lookup_memberptr_type (to_type, domain);
4746
4747   set_die_type (die, type, cu);
4748 }
4749
4750 /* Extract all information from a DW_TAG_reference_type DIE and add to
4751    the user defined type vector.  */
4752
4753 static void
4754 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
4755 {
4756   struct comp_unit_head *cu_header = &cu->header;
4757   struct type *type;
4758   struct attribute *attr;
4759
4760   if (die->type)
4761     {
4762       return;
4763     }
4764
4765   type = lookup_reference_type (die_type (die, cu));
4766   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4767   if (attr)
4768     {
4769       TYPE_LENGTH (type) = DW_UNSND (attr);
4770     }
4771   else
4772     {
4773       TYPE_LENGTH (type) = cu_header->addr_size;
4774     }
4775   set_die_type (die, type, cu);
4776 }
4777
4778 static void
4779 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
4780 {
4781   struct type *base_type;
4782
4783   if (die->type)
4784     {
4785       return;
4786     }
4787
4788   base_type = die_type (die, cu);
4789   set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0),
4790                 cu);
4791 }
4792
4793 static void
4794 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
4795 {
4796   struct type *base_type;
4797
4798   if (die->type)
4799     {
4800       return;
4801     }
4802
4803   base_type = die_type (die, cu);
4804   set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0),
4805                 cu);
4806 }
4807
4808 /* Extract all information from a DW_TAG_string_type DIE and add to
4809    the user defined type vector.  It isn't really a user defined type,
4810    but it behaves like one, with other DIE's using an AT_user_def_type
4811    attribute to reference it.  */
4812
4813 static void
4814 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
4815 {
4816   struct objfile *objfile = cu->objfile;
4817   struct type *type, *range_type, *index_type, *char_type;
4818   struct attribute *attr;
4819   unsigned int length;
4820
4821   if (die->type)
4822     {
4823       return;
4824     }
4825
4826   attr = dwarf2_attr (die, DW_AT_string_length, cu);
4827   if (attr)
4828     {
4829       length = DW_UNSND (attr);
4830     }
4831   else
4832     {
4833       /* check for the DW_AT_byte_size attribute */
4834       attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4835       if (attr)
4836         {
4837           length = DW_UNSND (attr);
4838         }
4839       else
4840         {
4841           length = 1;
4842         }
4843     }
4844
4845   index_type = builtin_type_int32;
4846   range_type = create_range_type (NULL, index_type, 1, length);
4847   type = create_string_type (NULL, range_type);
4848
4849   set_die_type (die, type, cu);
4850 }
4851
4852 /* Handle DIES due to C code like:
4853
4854    struct foo
4855    {
4856    int (*funcp)(int a, long l);
4857    int b;
4858    };
4859
4860    ('funcp' generates a DW_TAG_subroutine_type DIE)
4861  */
4862
4863 static void
4864 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
4865 {
4866   struct type *type;            /* Type that this function returns */
4867   struct type *ftype;           /* Function that returns above type */
4868   struct attribute *attr;
4869
4870   /* Decode the type that this subroutine returns */
4871   if (die->type)
4872     {
4873       return;
4874     }
4875   type = die_type (die, cu);
4876   ftype = make_function_type (type, (struct type **) 0);
4877
4878   /* All functions in C++, Pascal and Java have prototypes.  */
4879   attr = dwarf2_attr (die, DW_AT_prototyped, cu);
4880   if ((attr && (DW_UNSND (attr) != 0))
4881       || cu->language == language_cplus
4882       || cu->language == language_java
4883       || cu->language == language_pascal)
4884     TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
4885
4886   if (die->child != NULL)
4887     {
4888       struct die_info *child_die;
4889       int nparams = 0;
4890       int iparams = 0;
4891
4892       /* Count the number of parameters.
4893          FIXME: GDB currently ignores vararg functions, but knows about
4894          vararg member functions.  */
4895       child_die = die->child;
4896       while (child_die && child_die->tag)
4897         {
4898           if (child_die->tag == DW_TAG_formal_parameter)
4899             nparams++;
4900           else if (child_die->tag == DW_TAG_unspecified_parameters)
4901             TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
4902           child_die = sibling_die (child_die);
4903         }
4904
4905       /* Allocate storage for parameters and fill them in.  */
4906       TYPE_NFIELDS (ftype) = nparams;
4907       TYPE_FIELDS (ftype) = (struct field *)
4908         TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
4909
4910       child_die = die->child;
4911       while (child_die && child_die->tag)
4912         {
4913           if (child_die->tag == DW_TAG_formal_parameter)
4914             {
4915               /* Dwarf2 has no clean way to discern C++ static and non-static
4916                  member functions. G++ helps GDB by marking the first
4917                  parameter for non-static member functions (which is the
4918                  this pointer) as artificial. We pass this information
4919                  to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.  */
4920               attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
4921               if (attr)
4922                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
4923               else
4924                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
4925               TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu);
4926               iparams++;
4927             }
4928           child_die = sibling_die (child_die);
4929         }
4930     }
4931
4932   set_die_type (die, ftype, cu);
4933 }
4934
4935 static void
4936 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
4937 {
4938   struct objfile *objfile = cu->objfile;
4939   struct attribute *attr;
4940   char *name = NULL;
4941
4942   if (!die->type)
4943     {
4944       name = dwarf2_name (die, cu);
4945       set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0,
4946                                     TYPE_FLAG_TARGET_STUB, name, objfile),
4947                     cu);
4948       TYPE_TARGET_TYPE (die->type) = die_type (die, cu);
4949     }
4950 }
4951
4952 /* Find a representation of a given base type and install
4953    it in the TYPE field of the die.  */
4954
4955 static void
4956 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
4957 {
4958   struct objfile *objfile = cu->objfile;
4959   struct type *type;
4960   struct attribute *attr;
4961   int encoding = 0, size = 0;
4962   char *name;
4963   enum type_code code = TYPE_CODE_INT;
4964   int type_flags = 0;
4965   struct type *target_type = NULL;
4966
4967   /* If we've already decoded this die, this is a no-op. */
4968   if (die->type)
4969     {
4970       return;
4971     }
4972
4973   attr = dwarf2_attr (die, DW_AT_encoding, cu);
4974   if (attr)
4975     {
4976       encoding = DW_UNSND (attr);
4977     }
4978   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
4979   if (attr)
4980     {
4981       size = DW_UNSND (attr);
4982     }
4983   name = dwarf2_name (die, cu);
4984   if (!name)
4985     {
4986       complaint (&symfile_complaints,
4987                  _("DW_AT_name missing from DW_TAG_base_type"));
4988     }
4989
4990   switch (encoding)
4991     {
4992       case DW_ATE_address:
4993         /* Turn DW_ATE_address into a void * pointer.  */
4994         code = TYPE_CODE_PTR;
4995         type_flags |= TYPE_FLAG_UNSIGNED;
4996         target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
4997         break;
4998       case DW_ATE_boolean:
4999         code = TYPE_CODE_BOOL;
5000         type_flags |= TYPE_FLAG_UNSIGNED;
5001         break;
5002       case DW_ATE_complex_float:
5003         code = TYPE_CODE_COMPLEX;
5004         target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
5005         break;
5006       case DW_ATE_decimal_float:
5007         code = TYPE_CODE_DECFLOAT;
5008         break;
5009       case DW_ATE_float:
5010         code = TYPE_CODE_FLT;
5011         break;
5012       case DW_ATE_signed:
5013         break;
5014       case DW_ATE_unsigned:
5015         type_flags |= TYPE_FLAG_UNSIGNED;
5016         break;
5017       case DW_ATE_signed_char:
5018         if (cu->language == language_ada || cu->language == language_m2)
5019           code = TYPE_CODE_CHAR;
5020         break;
5021       case DW_ATE_unsigned_char:
5022         if (cu->language == language_ada || cu->language == language_m2)
5023           code = TYPE_CODE_CHAR;
5024         type_flags |= TYPE_FLAG_UNSIGNED;
5025         break;
5026       default:
5027         complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
5028                    dwarf_type_encoding_name (encoding));
5029         break;
5030     }
5031
5032   type = init_type (code, size, type_flags, name, objfile);
5033   TYPE_TARGET_TYPE (type) = target_type;
5034
5035   set_die_type (die, type, cu);
5036 }
5037
5038 /* Read the given DW_AT_subrange DIE.  */
5039
5040 static void
5041 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
5042 {
5043   struct type *base_type;
5044   struct type *range_type;
5045   struct attribute *attr;
5046   int low = 0;
5047   int high = -1;
5048   char *name;
5049
5050   /* If we have already decoded this die, then nothing more to do.  */
5051   if (die->type)
5052     return;
5053
5054   base_type = die_type (die, cu);
5055   if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
5056     {
5057       complaint (&symfile_complaints,
5058                 _("DW_AT_type missing from DW_TAG_subrange_type"));
5059       base_type
5060         = init_type (TYPE_CODE_INT, gdbarch_addr_bit (current_gdbarch) / 8,
5061                      0, NULL, cu->objfile);
5062     }
5063
5064   if (cu->language == language_fortran)
5065     {
5066       /* FORTRAN implies a lower bound of 1, if not given.  */
5067       low = 1;
5068     }
5069
5070   /* FIXME: For variable sized arrays either of these could be
5071      a variable rather than a constant value.  We'll allow it,
5072      but we don't know how to handle it.  */
5073   attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
5074   if (attr)
5075     low = dwarf2_get_attr_constant_value (attr, 0);
5076
5077   attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
5078   if (attr)
5079     {
5080       if (attr->form == DW_FORM_block1)
5081         {
5082           /* GCC encodes arrays with unspecified or dynamic length
5083              with a DW_FORM_block1 attribute.
5084              FIXME: GDB does not yet know how to handle dynamic
5085              arrays properly, treat them as arrays with unspecified
5086              length for now.
5087
5088              FIXME: jimb/2003-09-22: GDB does not really know
5089              how to handle arrays of unspecified length
5090              either; we just represent them as zero-length
5091              arrays.  Choose an appropriate upper bound given
5092              the lower bound we've computed above.  */
5093           high = low - 1;
5094         }
5095       else
5096         high = dwarf2_get_attr_constant_value (attr, 1);
5097     }
5098
5099   range_type = create_range_type (NULL, base_type, low, high);
5100
5101   name = dwarf2_name (die, cu);
5102   if (name)
5103     TYPE_NAME (range_type) = name;
5104
5105   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
5106   if (attr)
5107     TYPE_LENGTH (range_type) = DW_UNSND (attr);
5108
5109   set_die_type (die, range_type, cu);
5110 }
5111
5112 static void
5113 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
5114 {
5115   struct type *type;
5116
5117   if (die->type)
5118     return;
5119
5120   /* For now, we only support the C meaning of an unspecified type: void.  */
5121
5122   type = init_type (TYPE_CODE_VOID, 0, 0, dwarf2_name (die, cu),
5123                     cu->objfile);
5124
5125   set_die_type (die, type, cu);
5126 }
5127
5128 /* Read a whole compilation unit into a linked list of dies.  */
5129
5130 static struct die_info *
5131 read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
5132 {
5133   return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
5134 }
5135
5136 /* Read a single die and all its descendents.  Set the die's sibling
5137    field to NULL; set other fields in the die correctly, and set all
5138    of the descendents' fields correctly.  Set *NEW_INFO_PTR to the
5139    location of the info_ptr after reading all of those dies.  PARENT
5140    is the parent of the die in question.  */
5141
5142 static struct die_info *
5143 read_die_and_children (gdb_byte *info_ptr, bfd *abfd,
5144                        struct dwarf2_cu *cu,
5145                        gdb_byte **new_info_ptr,
5146                        struct die_info *parent)
5147 {
5148   struct die_info *die;
5149   gdb_byte *cur_ptr;
5150   int has_children;
5151
5152   cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
5153   store_in_ref_table (die->offset, die, cu);
5154
5155   if (has_children)
5156     {
5157       die->child = read_die_and_siblings (cur_ptr, abfd, cu,
5158                                           new_info_ptr, die);
5159     }
5160   else
5161     {
5162       die->child = NULL;
5163       *new_info_ptr = cur_ptr;
5164     }
5165
5166   die->sibling = NULL;
5167   die->parent = parent;
5168   return die;
5169 }
5170
5171 /* Read a die, all of its descendents, and all of its siblings; set
5172    all of the fields of all of the dies correctly.  Arguments are as
5173    in read_die_and_children.  */
5174
5175 static struct die_info *
5176 read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd,
5177                        struct dwarf2_cu *cu,
5178                        gdb_byte **new_info_ptr,
5179                        struct die_info *parent)
5180 {
5181   struct die_info *first_die, *last_sibling;
5182   gdb_byte *cur_ptr;
5183
5184   cur_ptr = info_ptr;
5185   first_die = last_sibling = NULL;
5186
5187   while (1)
5188     {
5189       struct die_info *die
5190         = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent);
5191
5192       if (!first_die)
5193         {
5194           first_die = die;
5195         }
5196       else
5197         {
5198           last_sibling->sibling = die;
5199         }
5200
5201       if (die->tag == 0)
5202         {
5203           *new_info_ptr = cur_ptr;
5204           return first_die;
5205         }
5206       else
5207         {
5208           last_sibling = die;
5209         }
5210     }
5211 }
5212
5213 /* Free a linked list of dies.  */
5214
5215 static void
5216 free_die_list (struct die_info *dies)
5217 {
5218   struct die_info *die, *next;
5219
5220   die = dies;
5221   while (die)
5222     {
5223       if (die->child != NULL)
5224         free_die_list (die->child);
5225       next = die->sibling;
5226       xfree (die->attrs);
5227       xfree (die);
5228       die = next;
5229     }
5230 }
5231
5232 /* Read the contents of the section at OFFSET and of size SIZE from the
5233    object file specified by OBJFILE into the objfile_obstack and return it.  */
5234
5235 gdb_byte *
5236 dwarf2_read_section (struct objfile *objfile, asection *sectp)
5237 {
5238   bfd *abfd = objfile->obfd;
5239   gdb_byte *buf, *retbuf;
5240   bfd_size_type size = bfd_get_section_size (sectp);
5241
5242   if (size == 0)
5243     return NULL;
5244
5245   buf = obstack_alloc (&objfile->objfile_obstack, size);
5246   retbuf = symfile_relocate_debug_section (abfd, sectp, buf);
5247   if (retbuf != NULL)
5248     return retbuf;
5249
5250   if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
5251       || bfd_bread (buf, size, abfd) != size)
5252     error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5253            bfd_get_filename (abfd));
5254
5255   return buf;
5256 }
5257
5258 /* In DWARF version 2, the description of the debugging information is
5259    stored in a separate .debug_abbrev section.  Before we read any
5260    dies from a section we read in all abbreviations and install them
5261    in a hash table.  This function also sets flags in CU describing
5262    the data found in the abbrev table.  */
5263
5264 static void
5265 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
5266 {
5267   struct comp_unit_head *cu_header = &cu->header;
5268   gdb_byte *abbrev_ptr;
5269   struct abbrev_info *cur_abbrev;
5270   unsigned int abbrev_number, bytes_read, abbrev_name;
5271   unsigned int abbrev_form, hash_number;
5272   struct attr_abbrev *cur_attrs;
5273   unsigned int allocated_attrs;
5274
5275   /* Initialize dwarf2 abbrevs */
5276   obstack_init (&cu->abbrev_obstack);
5277   cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
5278                                       (ABBREV_HASH_SIZE
5279                                        * sizeof (struct abbrev_info *)));
5280   memset (cu->dwarf2_abbrevs, 0,
5281           ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
5282
5283   abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset;
5284   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5285   abbrev_ptr += bytes_read;
5286
5287   allocated_attrs = ATTR_ALLOC_CHUNK;
5288   cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
5289
5290   /* loop until we reach an abbrev number of 0 */
5291   while (abbrev_number)
5292     {
5293       cur_abbrev = dwarf_alloc_abbrev (cu);
5294
5295       /* read in abbrev header */
5296       cur_abbrev->number = abbrev_number;
5297       cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5298       abbrev_ptr += bytes_read;
5299       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
5300       abbrev_ptr += 1;
5301
5302       if (cur_abbrev->tag == DW_TAG_namespace)
5303         cu->has_namespace_info = 1;
5304
5305       /* now read in declarations */
5306       abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5307       abbrev_ptr += bytes_read;
5308       abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5309       abbrev_ptr += bytes_read;
5310       while (abbrev_name)
5311         {
5312           if (cur_abbrev->num_attrs == allocated_attrs)
5313             {
5314               allocated_attrs += ATTR_ALLOC_CHUNK;
5315               cur_attrs
5316                 = xrealloc (cur_attrs, (allocated_attrs
5317                                         * sizeof (struct attr_abbrev)));
5318             }
5319
5320           /* Record whether this compilation unit might have
5321              inter-compilation-unit references.  If we don't know what form
5322              this attribute will have, then it might potentially be a
5323              DW_FORM_ref_addr, so we conservatively expect inter-CU
5324              references.  */
5325
5326           if (abbrev_form == DW_FORM_ref_addr
5327               || abbrev_form == DW_FORM_indirect)
5328             cu->has_form_ref_addr = 1;
5329
5330           cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
5331           cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
5332           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5333           abbrev_ptr += bytes_read;
5334           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5335           abbrev_ptr += bytes_read;
5336         }
5337
5338       cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
5339                                          (cur_abbrev->num_attrs
5340                                           * sizeof (struct attr_abbrev)));
5341       memcpy (cur_abbrev->attrs, cur_attrs,
5342               cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
5343
5344       hash_number = abbrev_number % ABBREV_HASH_SIZE;
5345       cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
5346       cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
5347
5348       /* Get next abbreviation.
5349          Under Irix6 the abbreviations for a compilation unit are not
5350          always properly terminated with an abbrev number of 0.
5351          Exit loop if we encounter an abbreviation which we have
5352          already read (which means we are about to read the abbreviations
5353          for the next compile unit) or if the end of the abbreviation
5354          table is reached.  */
5355       if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer)
5356           >= dwarf2_per_objfile->abbrev_size)
5357         break;
5358       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
5359       abbrev_ptr += bytes_read;
5360       if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
5361         break;
5362     }
5363
5364   xfree (cur_attrs);
5365 }
5366
5367 /* Release the memory used by the abbrev table for a compilation unit.  */
5368
5369 static void
5370 dwarf2_free_abbrev_table (void *ptr_to_cu)
5371 {
5372   struct dwarf2_cu *cu = ptr_to_cu;
5373
5374   obstack_free (&cu->abbrev_obstack, NULL);
5375   cu->dwarf2_abbrevs = NULL;
5376 }
5377
5378 /* Lookup an abbrev_info structure in the abbrev hash table.  */
5379
5380 static struct abbrev_info *
5381 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
5382 {
5383   unsigned int hash_number;
5384   struct abbrev_info *abbrev;
5385
5386   hash_number = number % ABBREV_HASH_SIZE;
5387   abbrev = cu->dwarf2_abbrevs[hash_number];
5388
5389   while (abbrev)
5390     {
5391       if (abbrev->number == number)
5392         return abbrev;
5393       else
5394         abbrev = abbrev->next;
5395     }
5396   return NULL;
5397 }
5398
5399 /* Returns nonzero if TAG represents a type that we might generate a partial
5400    symbol for.  */
5401
5402 static int
5403 is_type_tag_for_partial (int tag)
5404 {
5405   switch (tag)
5406     {
5407 #if 0
5408     /* Some types that would be reasonable to generate partial symbols for,
5409        that we don't at present.  */
5410     case DW_TAG_array_type:
5411     case DW_TAG_file_type:
5412     case DW_TAG_ptr_to_member_type:
5413     case DW_TAG_set_type:
5414     case DW_TAG_string_type:
5415     case DW_TAG_subroutine_type:
5416 #endif
5417     case DW_TAG_base_type:
5418     case DW_TAG_class_type:
5419     case DW_TAG_interface_type:
5420     case DW_TAG_enumeration_type:
5421     case DW_TAG_structure_type:
5422     case DW_TAG_subrange_type:
5423     case DW_TAG_typedef:
5424     case DW_TAG_union_type:
5425       return 1;
5426     default:
5427       return 0;
5428     }
5429 }
5430
5431 /* Load all DIEs that are interesting for partial symbols into memory.  */
5432
5433 static struct partial_die_info *
5434 load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab,
5435                    struct dwarf2_cu *cu)
5436 {
5437   struct partial_die_info *part_die;
5438   struct partial_die_info *parent_die, *last_die, *first_die = NULL;
5439   struct abbrev_info *abbrev;
5440   unsigned int bytes_read;
5441   unsigned int load_all = 0;
5442
5443   int nesting_level = 1;
5444
5445   parent_die = NULL;
5446   last_die = NULL;
5447
5448   if (cu->per_cu && cu->per_cu->load_all_dies)
5449     load_all = 1;
5450
5451   cu->partial_dies
5452     = htab_create_alloc_ex (cu->header.length / 12,
5453                             partial_die_hash,
5454                             partial_die_eq,
5455                             NULL,
5456                             &cu->comp_unit_obstack,
5457                             hashtab_obstack_allocate,
5458                             dummy_obstack_deallocate);
5459
5460   part_die = obstack_alloc (&cu->comp_unit_obstack,
5461                             sizeof (struct partial_die_info));
5462
5463   while (1)
5464     {
5465       abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
5466
5467       /* A NULL abbrev means the end of a series of children.  */
5468       if (abbrev == NULL)
5469         {
5470           if (--nesting_level == 0)
5471             {
5472               /* PART_DIE was probably the last thing allocated on the
5473                  comp_unit_obstack, so we could call obstack_free
5474                  here.  We don't do that because the waste is small,
5475                  and will be cleaned up when we're done with this
5476                  compilation unit.  This way, we're also more robust
5477                  against other users of the comp_unit_obstack.  */
5478               return first_die;
5479             }
5480           info_ptr += bytes_read;
5481           last_die = parent_die;
5482           parent_die = parent_die->die_parent;
5483           continue;
5484         }
5485
5486       /* Check whether this DIE is interesting enough to save.  Normally
5487          we would not be interested in members here, but there may be
5488          later variables referencing them via DW_AT_specification (for
5489          static members).  */
5490       if (!load_all
5491           && !is_type_tag_for_partial (abbrev->tag)
5492           && abbrev->tag != DW_TAG_enumerator
5493           && abbrev->tag != DW_TAG_subprogram
5494           && abbrev->tag != DW_TAG_variable
5495           && abbrev->tag != DW_TAG_namespace
5496           && abbrev->tag != DW_TAG_member)
5497         {
5498           /* Otherwise we skip to the next sibling, if any.  */
5499           info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu);
5500           continue;
5501         }
5502
5503       info_ptr = read_partial_die (part_die, abbrev, bytes_read,
5504                                    abfd, info_ptr, cu);
5505
5506       /* This two-pass algorithm for processing partial symbols has a
5507          high cost in cache pressure.  Thus, handle some simple cases
5508          here which cover the majority of C partial symbols.  DIEs
5509          which neither have specification tags in them, nor could have
5510          specification tags elsewhere pointing at them, can simply be
5511          processed and discarded.
5512
5513          This segment is also optional; scan_partial_symbols and
5514          add_partial_symbol will handle these DIEs if we chain
5515          them in normally.  When compilers which do not emit large
5516          quantities of duplicate debug information are more common,
5517          this code can probably be removed.  */
5518
5519       /* Any complete simple types at the top level (pretty much all
5520          of them, for a language without namespaces), can be processed
5521          directly.  */
5522       if (parent_die == NULL
5523           && part_die->has_specification == 0
5524           && part_die->is_declaration == 0
5525           && (part_die->tag == DW_TAG_typedef
5526               || part_die->tag == DW_TAG_base_type
5527               || part_die->tag == DW_TAG_subrange_type))
5528         {
5529           if (building_psymtab && part_die->name != NULL)
5530             add_psymbol_to_list (part_die->name, strlen (part_die->name),
5531                                  VAR_DOMAIN, LOC_TYPEDEF,
5532                                  &cu->objfile->static_psymbols,
5533                                  0, (CORE_ADDR) 0, cu->language, cu->objfile);
5534           info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5535           continue;
5536         }
5537
5538       /* If we're at the second level, and we're an enumerator, and
5539          our parent has no specification (meaning possibly lives in a
5540          namespace elsewhere), then we can add the partial symbol now
5541          instead of queueing it.  */
5542       if (part_die->tag == DW_TAG_enumerator
5543           && parent_die != NULL
5544           && parent_die->die_parent == NULL
5545           && parent_die->tag == DW_TAG_enumeration_type
5546           && parent_die->has_specification == 0)
5547         {
5548           if (part_die->name == NULL)
5549             complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
5550           else if (building_psymtab)
5551             add_psymbol_to_list (part_die->name, strlen (part_die->name),
5552                                  VAR_DOMAIN, LOC_CONST,
5553                                  (cu->language == language_cplus
5554                                   || cu->language == language_java)
5555                                  ? &cu->objfile->global_psymbols
5556                                  : &cu->objfile->static_psymbols,
5557                                  0, (CORE_ADDR) 0, cu->language, cu->objfile);
5558
5559           info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu);
5560           continue;
5561         }
5562
5563       /* We'll save this DIE so link it in.  */
5564       part_die->die_parent = parent_die;
5565       part_die->die_sibling = NULL;
5566       part_die->die_child = NULL;
5567
5568       if (last_die && last_die == parent_die)
5569         last_die->die_child = part_die;
5570       else if (last_die)
5571         last_die->die_sibling = part_die;
5572
5573       last_die = part_die;
5574
5575       if (first_die == NULL)
5576         first_die = part_die;
5577
5578       /* Maybe add the DIE to the hash table.  Not all DIEs that we
5579          find interesting need to be in the hash table, because we
5580          also have the parent/sibling/child chains; only those that we
5581          might refer to by offset later during partial symbol reading.
5582
5583          For now this means things that might have be the target of a
5584          DW_AT_specification, DW_AT_abstract_origin, or
5585          DW_AT_extension.  DW_AT_extension will refer only to
5586          namespaces; DW_AT_abstract_origin refers to functions (and
5587          many things under the function DIE, but we do not recurse
5588          into function DIEs during partial symbol reading) and
5589          possibly variables as well; DW_AT_specification refers to
5590          declarations.  Declarations ought to have the DW_AT_declaration
5591          flag.  It happens that GCC forgets to put it in sometimes, but
5592          only for functions, not for types.
5593
5594          Adding more things than necessary to the hash table is harmless
5595          except for the performance cost.  Adding too few will result in
5596          wasted time in find_partial_die, when we reread the compilation
5597          unit with load_all_dies set.  */
5598
5599       if (load_all
5600           || abbrev->tag == DW_TAG_subprogram
5601           || abbrev->tag == DW_TAG_variable
5602           || abbrev->tag == DW_TAG_namespace
5603           || part_die->is_declaration)
5604         {
5605           void **slot;
5606
5607           slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
5608                                            part_die->offset, INSERT);
5609           *slot = part_die;
5610         }
5611
5612       part_die = obstack_alloc (&cu->comp_unit_obstack,
5613                                 sizeof (struct partial_die_info));
5614
5615       /* For some DIEs we want to follow their children (if any).  For C
5616          we have no reason to follow the children of structures; for other
5617          languages we have to, both so that we can get at method physnames
5618          to infer fully qualified class names, and for DW_AT_specification.  */
5619       if (last_die->has_children
5620           && (load_all
5621               || last_die->tag == DW_TAG_namespace
5622               || last_die->tag == DW_TAG_enumeration_type
5623               || (cu->language != language_c
5624                   && (last_die->tag == DW_TAG_class_type
5625                       || last_die->tag == DW_TAG_interface_type
5626                       || last_die->tag == DW_TAG_structure_type
5627                       || last_die->tag == DW_TAG_union_type))))
5628         {
5629           nesting_level++;
5630           parent_die = last_die;
5631           continue;
5632         }
5633
5634       /* Otherwise we skip to the next sibling, if any.  */
5635       info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu);
5636
5637       /* Back to the top, do it again.  */
5638     }
5639 }
5640
5641 /* Read a minimal amount of information into the minimal die structure.  */
5642
5643 static gdb_byte *
5644 read_partial_die (struct partial_die_info *part_die,
5645                   struct abbrev_info *abbrev,
5646                   unsigned int abbrev_len, bfd *abfd,
5647                   gdb_byte *info_ptr, struct dwarf2_cu *cu)
5648 {
5649   unsigned int bytes_read, i;
5650   struct attribute attr;
5651   int has_low_pc_attr = 0;
5652   int has_high_pc_attr = 0;
5653
5654   memset (part_die, 0, sizeof (struct partial_die_info));
5655
5656   part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer;
5657
5658   info_ptr += abbrev_len;
5659
5660   if (abbrev == NULL)
5661     return info_ptr;
5662
5663   part_die->tag = abbrev->tag;
5664   part_die->has_children = abbrev->has_children;
5665
5666   for (i = 0; i < abbrev->num_attrs; ++i)
5667     {
5668       info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
5669
5670       /* Store the data if it is of an attribute we want to keep in a
5671          partial symbol table.  */
5672       switch (attr.name)
5673         {
5674         case DW_AT_name:
5675
5676           /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
5677           if (part_die->name == NULL)
5678             part_die->name = DW_STRING (&attr);
5679           break;
5680         case DW_AT_comp_dir:
5681           if (part_die->dirname == NULL)
5682             part_die->dirname = DW_STRING (&attr);
5683           break;
5684         case DW_AT_MIPS_linkage_name:
5685           part_die->name = DW_STRING (&attr);
5686           break;
5687         case DW_AT_low_pc:
5688           has_low_pc_attr = 1;
5689           part_die->lowpc = DW_ADDR (&attr);
5690           break;
5691         case DW_AT_high_pc:
5692           has_high_pc_attr = 1;
5693           part_die->highpc = DW_ADDR (&attr);
5694           break;
5695         case DW_AT_ranges:
5696           if (dwarf2_ranges_read (DW_UNSND (&attr), &part_die->lowpc,
5697                                   &part_die->highpc, cu))
5698             has_low_pc_attr = has_high_pc_attr = 1;
5699           break;
5700         case DW_AT_location:
5701           /* Support the .debug_loc offsets */
5702           if (attr_form_is_block (&attr))
5703             {
5704                part_die->locdesc = DW_BLOCK (&attr);
5705             }
5706           else if (attr_form_is_section_offset (&attr))
5707             {
5708               dwarf2_complex_location_expr_complaint ();
5709             }
5710           else
5711             {
5712               dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5713                                                      "partial symbol information");
5714             }
5715           break;
5716         case DW_AT_language:
5717           part_die->language = DW_UNSND (&attr);
5718           break;
5719         case DW_AT_external:
5720           part_die->is_external = DW_UNSND (&attr);
5721           break;
5722         case DW_AT_declaration:
5723           part_die->is_declaration = DW_UNSND (&attr);
5724           break;
5725         case DW_AT_type:
5726           part_die->has_type = 1;
5727           break;
5728         case DW_AT_abstract_origin:
5729         case DW_AT_specification:
5730         case DW_AT_extension:
5731           part_die->has_specification = 1;
5732           part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu);
5733           break;
5734         case DW_AT_sibling:
5735           /* Ignore absolute siblings, they might point outside of
5736              the current compile unit.  */
5737           if (attr.form == DW_FORM_ref_addr)
5738             complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
5739           else
5740             part_die->sibling = dwarf2_per_objfile->info_buffer
5741               + dwarf2_get_ref_die_offset (&attr, cu);
5742           break;
5743         case DW_AT_stmt_list:
5744           part_die->has_stmt_list = 1;
5745           part_die->line_offset = DW_UNSND (&attr);
5746           break;
5747         case DW_AT_byte_size:
5748           part_die->has_byte_size = 1;
5749           break;
5750         case DW_AT_calling_convention:
5751           /* DWARF doesn't provide a way to identify a program's source-level
5752              entry point.  DW_AT_calling_convention attributes are only meant
5753              to describe functions' calling conventions.
5754
5755              However, because it's a necessary piece of information in
5756              Fortran, and because DW_CC_program is the only piece of debugging
5757              information whose definition refers to a 'main program' at all,
5758              several compilers have begun marking Fortran main programs with
5759              DW_CC_program --- even when those functions use the standard
5760              calling conventions.
5761
5762              So until DWARF specifies a way to provide this information and
5763              compilers pick up the new representation, we'll support this
5764              practice.  */
5765           if (DW_UNSND (&attr) == DW_CC_program
5766               && cu->language == language_fortran)
5767             set_main_name (part_die->name);
5768           break;
5769         default:
5770           break;
5771         }
5772     }
5773
5774   /* When using the GNU linker, .gnu.linkonce. sections are used to
5775      eliminate duplicate copies of functions and vtables and such.
5776      The linker will arbitrarily choose one and discard the others.
5777      The AT_*_pc values for such functions refer to local labels in
5778      these sections.  If the section from that file was discarded, the
5779      labels are not in the output, so the relocs get a value of 0.
5780      If this is a discarded function, mark the pc bounds as invalid,
5781      so that GDB will ignore it.  */
5782   if (has_low_pc_attr && has_high_pc_attr
5783       && part_die->lowpc < part_die->highpc
5784       && (part_die->lowpc != 0
5785           || dwarf2_per_objfile->has_section_at_zero))
5786     part_die->has_pc_info = 1;
5787   return info_ptr;
5788 }
5789
5790 /* Find a cached partial DIE at OFFSET in CU.  */
5791
5792 static struct partial_die_info *
5793 find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu)
5794 {
5795   struct partial_die_info *lookup_die = NULL;
5796   struct partial_die_info part_die;
5797
5798   part_die.offset = offset;
5799   lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
5800
5801   return lookup_die;
5802 }
5803
5804 /* Find a partial DIE at OFFSET, which may or may not be in CU.  */
5805
5806 static struct partial_die_info *
5807 find_partial_die (unsigned long offset, struct dwarf2_cu *cu)
5808 {
5809   struct dwarf2_per_cu_data *per_cu = NULL;
5810   struct partial_die_info *pd = NULL;
5811
5812   if (offset >= cu->header.offset
5813       && offset < cu->header.offset + cu->header.length)
5814     {
5815       pd = find_partial_die_in_comp_unit (offset, cu);
5816       if (pd != NULL)
5817         return pd;
5818     }
5819
5820   per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
5821
5822   if (per_cu->cu == NULL)
5823     {
5824       load_comp_unit (per_cu, cu->objfile);
5825       per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5826       dwarf2_per_objfile->read_in_chain = per_cu;
5827     }
5828
5829   per_cu->cu->last_used = 0;
5830   pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5831
5832   if (pd == NULL && per_cu->load_all_dies == 0)
5833     {
5834       struct cleanup *back_to;
5835       struct partial_die_info comp_unit_die;
5836       struct abbrev_info *abbrev;
5837       unsigned int bytes_read;
5838       char *info_ptr;
5839
5840       per_cu->load_all_dies = 1;
5841
5842       /* Re-read the DIEs.  */
5843       back_to = make_cleanup (null_cleanup, 0);
5844       if (per_cu->cu->dwarf2_abbrevs == NULL)
5845         {
5846           dwarf2_read_abbrevs (per_cu->cu->objfile->obfd, per_cu->cu);
5847           back_to = make_cleanup (dwarf2_free_abbrev_table, per_cu->cu);
5848         }
5849       info_ptr = per_cu->cu->header.first_die_ptr;
5850       abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu);
5851       info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
5852                                    per_cu->cu->objfile->obfd, info_ptr,
5853                                    per_cu->cu);
5854       if (comp_unit_die.has_children)
5855         load_partial_dies (per_cu->cu->objfile->obfd, info_ptr, 0, per_cu->cu);
5856       do_cleanups (back_to);
5857
5858       pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
5859     }
5860
5861   if (pd == NULL)
5862     internal_error (__FILE__, __LINE__,
5863                     _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5864                     offset, bfd_get_filename (cu->objfile->obfd));
5865   return pd;
5866 }
5867
5868 /* Adjust PART_DIE before generating a symbol for it.  This function
5869    may set the is_external flag or change the DIE's name.  */
5870
5871 static void
5872 fixup_partial_die (struct partial_die_info *part_die,
5873                    struct dwarf2_cu *cu)
5874 {
5875   /* If we found a reference attribute and the DIE has no name, try
5876      to find a name in the referred to DIE.  */
5877
5878   if (part_die->name == NULL && part_die->has_specification)
5879     {
5880       struct partial_die_info *spec_die;
5881
5882       spec_die = find_partial_die (part_die->spec_offset, cu);
5883
5884       fixup_partial_die (spec_die, cu);
5885
5886       if (spec_die->name)
5887         {
5888           part_die->name = spec_die->name;
5889
5890           /* Copy DW_AT_external attribute if it is set.  */
5891           if (spec_die->is_external)
5892             part_die->is_external = spec_die->is_external;
5893         }
5894     }
5895
5896   /* Set default names for some unnamed DIEs.  */
5897   if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type
5898                                  || part_die->tag == DW_TAG_class_type))
5899     part_die->name = "(anonymous class)";
5900
5901   if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
5902     part_die->name = "(anonymous namespace)";
5903
5904   if (part_die->tag == DW_TAG_structure_type
5905       || part_die->tag == DW_TAG_class_type
5906       || part_die->tag == DW_TAG_union_type)
5907     guess_structure_name (part_die, cu);
5908 }
5909
5910 /* Read the die from the .debug_info section buffer.  Set DIEP to
5911    point to a newly allocated die with its information, except for its
5912    child, sibling, and parent fields.  Set HAS_CHILDREN to tell
5913    whether the die has children or not.  */
5914
5915 static gdb_byte *
5916 read_full_die (struct die_info **diep, bfd *abfd, gdb_byte *info_ptr,
5917                struct dwarf2_cu *cu, int *has_children)
5918 {
5919   unsigned int abbrev_number, bytes_read, i, offset;
5920   struct abbrev_info *abbrev;
5921   struct die_info *die;
5922
5923   offset = info_ptr - dwarf2_per_objfile->info_buffer;
5924   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5925   info_ptr += bytes_read;
5926   if (!abbrev_number)
5927     {
5928       die = dwarf_alloc_die ();
5929       die->tag = 0;
5930       die->abbrev = abbrev_number;
5931       die->type = NULL;
5932       *diep = die;
5933       *has_children = 0;
5934       return info_ptr;
5935     }
5936
5937   abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
5938   if (!abbrev)
5939     {
5940       error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5941              abbrev_number,
5942              bfd_get_filename (abfd));
5943     }
5944   die = dwarf_alloc_die ();
5945   die->offset = offset;
5946   die->tag = abbrev->tag;
5947   die->abbrev = abbrev_number;
5948   die->type = NULL;
5949
5950   die->num_attrs = abbrev->num_attrs;
5951   die->attrs = (struct attribute *)
5952     xmalloc (die->num_attrs * sizeof (struct attribute));
5953
5954   for (i = 0; i < abbrev->num_attrs; ++i)
5955     {
5956       info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
5957                                  abfd, info_ptr, cu);
5958
5959       /* If this attribute is an absolute reference to a different
5960          compilation unit, make sure that compilation unit is loaded
5961          also.  */
5962       if (die->attrs[i].form == DW_FORM_ref_addr
5963           && (DW_ADDR (&die->attrs[i]) < cu->header.offset
5964               || (DW_ADDR (&die->attrs[i])
5965                   >= cu->header.offset + cu->header.length)))
5966         {
5967           struct dwarf2_per_cu_data *per_cu;
5968           per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]),
5969                                                      cu->objfile);
5970
5971           /* Mark the dependence relation so that we don't flush PER_CU
5972              too early.  */
5973           dwarf2_add_dependence (cu, per_cu);
5974
5975           /* If it's already on the queue, we have nothing to do.  */
5976           if (per_cu->queued)
5977             continue;
5978
5979           /* If the compilation unit is already loaded, just mark it as
5980              used.  */
5981           if (per_cu->cu != NULL)
5982             {
5983               per_cu->cu->last_used = 0;
5984               continue;
5985             }
5986
5987           /* Add it to the queue.  */
5988           queue_comp_unit (per_cu);
5989        }
5990     }
5991
5992   *diep = die;
5993   *has_children = abbrev->has_children;
5994   return info_ptr;
5995 }
5996
5997 /* Read an attribute value described by an attribute form.  */
5998
5999 static gdb_byte *
6000 read_attribute_value (struct attribute *attr, unsigned form,
6001                       bfd *abfd, gdb_byte *info_ptr,
6002                       struct dwarf2_cu *cu)
6003 {
6004   struct comp_unit_head *cu_header = &cu->header;
6005   unsigned int bytes_read;
6006   struct dwarf_block *blk;
6007
6008   attr->form = form;
6009   switch (form)
6010     {
6011     case DW_FORM_addr:
6012     case DW_FORM_ref_addr:
6013       DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
6014       info_ptr += bytes_read;
6015       break;
6016     case DW_FORM_block2:
6017       blk = dwarf_alloc_block (cu);
6018       blk->size = read_2_bytes (abfd, info_ptr);
6019       info_ptr += 2;
6020       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
6021       info_ptr += blk->size;
6022       DW_BLOCK (attr) = blk;
6023       break;
6024     case DW_FORM_block4:
6025       blk = dwarf_alloc_block (cu);
6026       blk->size = read_4_bytes (abfd, info_ptr);
6027       info_ptr += 4;
6028       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
6029       info_ptr += blk->size;
6030       DW_BLOCK (attr) = blk;
6031       break;
6032     case DW_FORM_data2:
6033       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
6034       info_ptr += 2;
6035       break;
6036     case DW_FORM_data4:
6037       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
6038       info_ptr += 4;
6039       break;
6040     case DW_FORM_data8:
6041       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
6042       info_ptr += 8;
6043       break;
6044     case DW_FORM_string:
6045       DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
6046       info_ptr += bytes_read;
6047       break;
6048     case DW_FORM_strp:
6049       DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
6050                                                &bytes_read);
6051       info_ptr += bytes_read;
6052       break;
6053     case DW_FORM_block:
6054       blk = dwarf_alloc_block (cu);
6055       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
6056       info_ptr += bytes_read;
6057       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
6058       info_ptr += blk->size;
6059       DW_BLOCK (attr) = blk;
6060       break;
6061     case DW_FORM_block1:
6062       blk = dwarf_alloc_block (cu);
6063       blk->size = read_1_byte (abfd, info_ptr);
6064       info_ptr += 1;
6065       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
6066       info_ptr += blk->size;
6067       DW_BLOCK (attr) = blk;
6068       break;
6069     case DW_FORM_data1:
6070       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
6071       info_ptr += 1;
6072       break;
6073     case DW_FORM_flag:
6074       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
6075       info_ptr += 1;
6076       break;
6077     case DW_FORM_sdata:
6078       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
6079       info_ptr += bytes_read;
6080       break;
6081     case DW_FORM_udata:
6082       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
6083       info_ptr += bytes_read;
6084       break;
6085     case DW_FORM_ref1:
6086       DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
6087       info_ptr += 1;
6088       break;
6089     case DW_FORM_ref2:
6090       DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
6091       info_ptr += 2;
6092       break;
6093     case DW_FORM_ref4:
6094       DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
6095       info_ptr += 4;
6096       break;
6097     case DW_FORM_ref8:
6098       DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
6099       info_ptr += 8;
6100       break;
6101     case DW_FORM_ref_udata:
6102       DW_ADDR (attr) = (cu->header.offset
6103                         + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
6104       info_ptr += bytes_read;
6105       break;
6106     case DW_FORM_indirect:
6107       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
6108       info_ptr += bytes_read;
6109       info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
6110       break;
6111     default:
6112       error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
6113              dwarf_form_name (form),
6114              bfd_get_filename (abfd));
6115     }
6116   return info_ptr;
6117 }
6118
6119 /* Read an attribute described by an abbreviated attribute.  */
6120
6121 static gdb_byte *
6122 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
6123                 bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
6124 {
6125   attr->name = abbrev->name;
6126   return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
6127 }
6128
6129 /* read dwarf information from a buffer */
6130
6131 static unsigned int
6132 read_1_byte (bfd *abfd, gdb_byte *buf)
6133 {
6134   return bfd_get_8 (abfd, buf);
6135 }
6136
6137 static int
6138 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
6139 {
6140   return bfd_get_signed_8 (abfd, buf);
6141 }
6142
6143 static unsigned int
6144 read_2_bytes (bfd *abfd, gdb_byte *buf)
6145 {
6146   return bfd_get_16 (abfd, buf);
6147 }
6148
6149 static int
6150 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
6151 {
6152   return bfd_get_signed_16 (abfd, buf);
6153 }
6154
6155 static unsigned int
6156 read_4_bytes (bfd *abfd, gdb_byte *buf)
6157 {
6158   return bfd_get_32 (abfd, buf);
6159 }
6160
6161 static int
6162 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
6163 {
6164   return bfd_get_signed_32 (abfd, buf);
6165 }
6166
6167 static unsigned long
6168 read_8_bytes (bfd *abfd, gdb_byte *buf)
6169 {
6170   return bfd_get_64 (abfd, buf);
6171 }
6172
6173 static CORE_ADDR
6174 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
6175               unsigned int *bytes_read)
6176 {
6177   struct comp_unit_head *cu_header = &cu->header;
6178   CORE_ADDR retval = 0;
6179
6180   if (cu_header->signed_addr_p)
6181     {
6182       switch (cu_header->addr_size)
6183         {
6184         case 2:
6185           retval = bfd_get_signed_16 (abfd, buf);
6186           break;
6187         case 4:
6188           retval = bfd_get_signed_32 (abfd, buf);
6189           break;
6190         case 8:
6191           retval = bfd_get_signed_64 (abfd, buf);
6192           break;
6193         default:
6194           internal_error (__FILE__, __LINE__,
6195                           _("read_address: bad switch, signed [in module %s]"),
6196                           bfd_get_filename (abfd));
6197         }
6198     }
6199   else
6200     {
6201       switch (cu_header->addr_size)
6202         {
6203         case 2:
6204           retval = bfd_get_16 (abfd, buf);
6205           break;
6206         case 4:
6207           retval = bfd_get_32 (abfd, buf);
6208           break;
6209         case 8:
6210           retval = bfd_get_64 (abfd, buf);
6211           break;
6212         default:
6213           internal_error (__FILE__, __LINE__,
6214                           _("read_address: bad switch, unsigned [in module %s]"),
6215                           bfd_get_filename (abfd));
6216         }
6217     }
6218
6219   *bytes_read = cu_header->addr_size;
6220   return retval;
6221 }
6222
6223 /* Read the initial length from a section.  The (draft) DWARF 3
6224    specification allows the initial length to take up either 4 bytes
6225    or 12 bytes.  If the first 4 bytes are 0xffffffff, then the next 8
6226    bytes describe the length and all offsets will be 8 bytes in length
6227    instead of 4.
6228
6229    An older, non-standard 64-bit format is also handled by this
6230    function.  The older format in question stores the initial length
6231    as an 8-byte quantity without an escape value.  Lengths greater
6232    than 2^32 aren't very common which means that the initial 4 bytes
6233    is almost always zero.  Since a length value of zero doesn't make
6234    sense for the 32-bit format, this initial zero can be considered to
6235    be an escape value which indicates the presence of the older 64-bit
6236    format.  As written, the code can't detect (old format) lengths
6237    greater than 4GB.  If it becomes necessary to handle lengths
6238    somewhat larger than 4GB, we could allow other small values (such
6239    as the non-sensical values of 1, 2, and 3) to also be used as
6240    escape values indicating the presence of the old format.
6241
6242    The value returned via bytes_read should be used to increment the
6243    relevant pointer after calling read_initial_length().
6244
6245    As a side effect, this function sets the fields initial_length_size
6246    and offset_size in cu_header to the values appropriate for the
6247    length field.  (The format of the initial length field determines
6248    the width of file offsets to be fetched later with read_offset().)
6249
6250    [ Note:  read_initial_length() and read_offset() are based on the
6251      document entitled "DWARF Debugging Information Format", revision
6252      3, draft 8, dated November 19, 2001.  This document was obtained
6253      from:
6254
6255         http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6256
6257      This document is only a draft and is subject to change.  (So beware.)
6258
6259      Details regarding the older, non-standard 64-bit format were
6260      determined empirically by examining 64-bit ELF files produced by
6261      the SGI toolchain on an IRIX 6.5 machine.
6262
6263      - Kevin, July 16, 2002
6264    ] */
6265
6266 static LONGEST
6267 read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header,
6268                      unsigned int *bytes_read)
6269 {
6270   LONGEST length = bfd_get_32 (abfd, buf);
6271
6272   if (length == 0xffffffff)
6273     {
6274       length = bfd_get_64 (abfd, buf + 4);
6275       *bytes_read = 12;
6276     }
6277   else if (length == 0)
6278     {
6279       /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX.  */
6280       length = bfd_get_64 (abfd, buf);
6281       *bytes_read = 8;
6282     }
6283   else
6284     {
6285       *bytes_read = 4;
6286     }
6287
6288   if (cu_header)
6289     {
6290       gdb_assert (cu_header->initial_length_size == 0
6291                   || cu_header->initial_length_size == 4
6292                   || cu_header->initial_length_size == 8
6293                   || cu_header->initial_length_size == 12);
6294
6295       if (cu_header->initial_length_size != 0
6296           && cu_header->initial_length_size != *bytes_read)
6297         complaint (&symfile_complaints,
6298                    _("intermixed 32-bit and 64-bit DWARF sections"));
6299
6300       cu_header->initial_length_size = *bytes_read;
6301       cu_header->offset_size = (*bytes_read == 4) ? 4 : 8;
6302     }
6303
6304   return length;
6305 }
6306
6307 /* Read an offset from the data stream.  The size of the offset is
6308    given by cu_header->offset_size.  */
6309
6310 static LONGEST
6311 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
6312              unsigned int *bytes_read)
6313 {
6314   LONGEST retval = 0;
6315
6316   switch (cu_header->offset_size)
6317     {
6318     case 4:
6319       retval = bfd_get_32 (abfd, buf);
6320       *bytes_read = 4;
6321       break;
6322     case 8:
6323       retval = bfd_get_64 (abfd, buf);
6324       *bytes_read = 8;
6325       break;
6326     default:
6327       internal_error (__FILE__, __LINE__,
6328                       _("read_offset: bad switch [in module %s]"),
6329                       bfd_get_filename (abfd));
6330     }
6331
6332   return retval;
6333 }
6334
6335 static gdb_byte *
6336 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
6337 {
6338   /* If the size of a host char is 8 bits, we can return a pointer
6339      to the buffer, otherwise we have to copy the data to a buffer
6340      allocated on the temporary obstack.  */
6341   gdb_assert (HOST_CHAR_BIT == 8);
6342   return buf;
6343 }
6344
6345 static char *
6346 read_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6347 {
6348   /* If the size of a host char is 8 bits, we can return a pointer
6349      to the string, otherwise we have to copy the string to a buffer
6350      allocated on the temporary obstack.  */
6351   gdb_assert (HOST_CHAR_BIT == 8);
6352   if (*buf == '\0')
6353     {
6354       *bytes_read_ptr = 1;
6355       return NULL;
6356     }
6357   *bytes_read_ptr = strlen ((char *) buf) + 1;
6358   return (char *) buf;
6359 }
6360
6361 static char *
6362 read_indirect_string (bfd *abfd, gdb_byte *buf,
6363                       const struct comp_unit_head *cu_header,
6364                       unsigned int *bytes_read_ptr)
6365 {
6366   LONGEST str_offset = read_offset (abfd, buf, cu_header,
6367                                     bytes_read_ptr);
6368
6369   if (dwarf2_per_objfile->str_buffer == NULL)
6370     {
6371       error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6372                       bfd_get_filename (abfd));
6373       return NULL;
6374     }
6375   if (str_offset >= dwarf2_per_objfile->str_size)
6376     {
6377       error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6378                       bfd_get_filename (abfd));
6379       return NULL;
6380     }
6381   gdb_assert (HOST_CHAR_BIT == 8);
6382   if (dwarf2_per_objfile->str_buffer[str_offset] == '\0')
6383     return NULL;
6384   return (char *) (dwarf2_per_objfile->str_buffer + str_offset);
6385 }
6386
6387 static unsigned long
6388 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6389 {
6390   unsigned long result;
6391   unsigned int num_read;
6392   int i, shift;
6393   unsigned char byte;
6394
6395   result = 0;
6396   shift = 0;
6397   num_read = 0;
6398   i = 0;
6399   while (1)
6400     {
6401       byte = bfd_get_8 (abfd, buf);
6402       buf++;
6403       num_read++;
6404       result |= ((unsigned long)(byte & 127) << shift);
6405       if ((byte & 128) == 0)
6406         {
6407           break;
6408         }
6409       shift += 7;
6410     }
6411   *bytes_read_ptr = num_read;
6412   return result;
6413 }
6414
6415 static long
6416 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
6417 {
6418   long result;
6419   int i, shift, num_read;
6420   unsigned char byte;
6421
6422   result = 0;
6423   shift = 0;
6424   num_read = 0;
6425   i = 0;
6426   while (1)
6427     {
6428       byte = bfd_get_8 (abfd, buf);
6429       buf++;
6430       num_read++;
6431       result |= ((long)(byte & 127) << shift);
6432       shift += 7;
6433       if ((byte & 128) == 0)
6434         {
6435           break;
6436         }
6437     }
6438   if ((shift < 8 * sizeof (result)) && (byte & 0x40))
6439     result |= -(((long)1) << shift);
6440   *bytes_read_ptr = num_read;
6441   return result;
6442 }
6443
6444 /* Return a pointer to just past the end of an LEB128 number in BUF.  */
6445
6446 static gdb_byte *
6447 skip_leb128 (bfd *abfd, gdb_byte *buf)
6448 {
6449   int byte;
6450
6451   while (1)
6452     {
6453       byte = bfd_get_8 (abfd, buf);
6454       buf++;
6455       if ((byte & 128) == 0)
6456         return buf;
6457     }
6458 }
6459
6460 static void
6461 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
6462 {
6463   switch (lang)
6464     {
6465     case DW_LANG_C89:
6466     case DW_LANG_C:
6467       cu->language = language_c;
6468       break;
6469     case DW_LANG_C_plus_plus:
6470       cu->language = language_cplus;
6471       break;
6472     case DW_LANG_Fortran77:
6473     case DW_LANG_Fortran90:
6474     case DW_LANG_Fortran95:
6475       cu->language = language_fortran;
6476       break;
6477     case DW_LANG_Mips_Assembler:
6478       cu->language = language_asm;
6479       break;
6480     case DW_LANG_Java:
6481       cu->language = language_java;
6482       break;
6483     case DW_LANG_Ada83:
6484     case DW_LANG_Ada95:
6485       cu->language = language_ada;
6486       break;
6487     case DW_LANG_Modula2:
6488       cu->language = language_m2;
6489       break;
6490     case DW_LANG_Pascal83:
6491       cu->language = language_pascal;
6492       break;
6493     case DW_LANG_Cobol74:
6494     case DW_LANG_Cobol85:
6495     default:
6496       cu->language = language_minimal;
6497       break;
6498     }
6499   cu->language_defn = language_def (cu->language);
6500 }
6501
6502 /* Return the named attribute or NULL if not there.  */
6503
6504 static struct attribute *
6505 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
6506 {
6507   unsigned int i;
6508   struct attribute *spec = NULL;
6509
6510   for (i = 0; i < die->num_attrs; ++i)
6511     {
6512       if (die->attrs[i].name == name)
6513         return &die->attrs[i];
6514       if (die->attrs[i].name == DW_AT_specification
6515           || die->attrs[i].name == DW_AT_abstract_origin)
6516         spec = &die->attrs[i];
6517     }
6518
6519   if (spec)
6520     return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu);
6521
6522   return NULL;
6523 }
6524
6525 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6526    and holds a non-zero value.  This function should only be used for
6527    DW_FORM_flag attributes.  */
6528
6529 static int
6530 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
6531 {
6532   struct attribute *attr = dwarf2_attr (die, name, cu);
6533
6534   return (attr && DW_UNSND (attr));
6535 }
6536
6537 static int
6538 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
6539 {
6540   /* A DIE is a declaration if it has a DW_AT_declaration attribute
6541      which value is non-zero.  However, we have to be careful with
6542      DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6543      (via dwarf2_flag_true_p) follows this attribute.  So we may
6544      end up accidently finding a declaration attribute that belongs
6545      to a different DIE referenced by the specification attribute,
6546      even though the given DIE does not have a declaration attribute.  */
6547   return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
6548           && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
6549 }
6550
6551 /* Return the die giving the specification for DIE, if there is
6552    one.  */
6553
6554 static struct die_info *
6555 die_specification (struct die_info *die, struct dwarf2_cu *cu)
6556 {
6557   struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
6558
6559   if (spec_attr == NULL)
6560     return NULL;
6561   else
6562     return follow_die_ref (die, spec_attr, cu);
6563 }
6564
6565 /* Free the line_header structure *LH, and any arrays and strings it
6566    refers to.  */
6567 static void
6568 free_line_header (struct line_header *lh)
6569 {
6570   if (lh->standard_opcode_lengths)
6571     xfree (lh->standard_opcode_lengths);
6572
6573   /* Remember that all the lh->file_names[i].name pointers are
6574      pointers into debug_line_buffer, and don't need to be freed.  */
6575   if (lh->file_names)
6576     xfree (lh->file_names);
6577
6578   /* Similarly for the include directory names.  */
6579   if (lh->include_dirs)
6580     xfree (lh->include_dirs);
6581
6582   xfree (lh);
6583 }
6584
6585
6586 /* Add an entry to LH's include directory table.  */
6587 static void
6588 add_include_dir (struct line_header *lh, char *include_dir)
6589 {
6590   /* Grow the array if necessary.  */
6591   if (lh->include_dirs_size == 0)
6592     {
6593       lh->include_dirs_size = 1; /* for testing */
6594       lh->include_dirs = xmalloc (lh->include_dirs_size
6595                                   * sizeof (*lh->include_dirs));
6596     }
6597   else if (lh->num_include_dirs >= lh->include_dirs_size)
6598     {
6599       lh->include_dirs_size *= 2;
6600       lh->include_dirs = xrealloc (lh->include_dirs,
6601                                    (lh->include_dirs_size
6602                                     * sizeof (*lh->include_dirs)));
6603     }
6604
6605   lh->include_dirs[lh->num_include_dirs++] = include_dir;
6606 }
6607
6608
6609 /* Add an entry to LH's file name table.  */
6610 static void
6611 add_file_name (struct line_header *lh,
6612                char *name,
6613                unsigned int dir_index,
6614                unsigned int mod_time,
6615                unsigned int length)
6616 {
6617   struct file_entry *fe;
6618
6619   /* Grow the array if necessary.  */
6620   if (lh->file_names_size == 0)
6621     {
6622       lh->file_names_size = 1; /* for testing */
6623       lh->file_names = xmalloc (lh->file_names_size
6624                                 * sizeof (*lh->file_names));
6625     }
6626   else if (lh->num_file_names >= lh->file_names_size)
6627     {
6628       lh->file_names_size *= 2;
6629       lh->file_names = xrealloc (lh->file_names,
6630                                  (lh->file_names_size
6631                                   * sizeof (*lh->file_names)));
6632     }
6633
6634   fe = &lh->file_names[lh->num_file_names++];
6635   fe->name = name;
6636   fe->dir_index = dir_index;
6637   fe->mod_time = mod_time;
6638   fe->length = length;
6639   fe->included_p = 0;
6640   fe->symtab = NULL;
6641 }
6642
6643
6644 /* Read the statement program header starting at OFFSET in
6645    .debug_line, according to the endianness of ABFD.  Return a pointer
6646    to a struct line_header, allocated using xmalloc.
6647
6648    NOTE: the strings in the include directory and file name tables of
6649    the returned object point into debug_line_buffer, and must not be
6650    freed.  */
6651 static struct line_header *
6652 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
6653                           struct dwarf2_cu *cu)
6654 {
6655   struct cleanup *back_to;
6656   struct line_header *lh;
6657   gdb_byte *line_ptr;
6658   unsigned int bytes_read;
6659   int i;
6660   char *cur_dir, *cur_file;
6661
6662   if (dwarf2_per_objfile->line_buffer == NULL)
6663     {
6664       complaint (&symfile_complaints, _("missing .debug_line section"));
6665       return 0;
6666     }
6667
6668   /* Make sure that at least there's room for the total_length field.
6669      That could be 12 bytes long, but we're just going to fudge that.  */
6670   if (offset + 4 >= dwarf2_per_objfile->line_size)
6671     {
6672       dwarf2_statement_list_fits_in_line_number_section_complaint ();
6673       return 0;
6674     }
6675
6676   lh = xmalloc (sizeof (*lh));
6677   memset (lh, 0, sizeof (*lh));
6678   back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
6679                           (void *) lh);
6680
6681   line_ptr = dwarf2_per_objfile->line_buffer + offset;
6682
6683   /* Read in the header.  */
6684   lh->total_length =
6685     read_initial_length (abfd, line_ptr, &cu->header, &bytes_read);
6686   line_ptr += bytes_read;
6687   if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer
6688                                      + dwarf2_per_objfile->line_size))
6689     {
6690       dwarf2_statement_list_fits_in_line_number_section_complaint ();
6691       return 0;
6692     }
6693   lh->statement_program_end = line_ptr + lh->total_length;
6694   lh->version = read_2_bytes (abfd, line_ptr);
6695   line_ptr += 2;
6696   lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read);
6697   line_ptr += bytes_read;
6698   lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
6699   line_ptr += 1;
6700   lh->default_is_stmt = read_1_byte (abfd, line_ptr);
6701   line_ptr += 1;
6702   lh->line_base = read_1_signed_byte (abfd, line_ptr);
6703   line_ptr += 1;
6704   lh->line_range = read_1_byte (abfd, line_ptr);
6705   line_ptr += 1;
6706   lh->opcode_base = read_1_byte (abfd, line_ptr);
6707   line_ptr += 1;
6708   lh->standard_opcode_lengths
6709     = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
6710
6711   lh->standard_opcode_lengths[0] = 1;  /* This should never be used anyway.  */
6712   for (i = 1; i < lh->opcode_base; ++i)
6713     {
6714       lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
6715       line_ptr += 1;
6716     }
6717
6718   /* Read directory table.  */
6719   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6720     {
6721       line_ptr += bytes_read;
6722       add_include_dir (lh, cur_dir);
6723     }
6724   line_ptr += bytes_read;
6725
6726   /* Read file name table.  */
6727   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
6728     {
6729       unsigned int dir_index, mod_time, length;
6730
6731       line_ptr += bytes_read;
6732       dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6733       line_ptr += bytes_read;
6734       mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6735       line_ptr += bytes_read;
6736       length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6737       line_ptr += bytes_read;
6738
6739       add_file_name (lh, cur_file, dir_index, mod_time, length);
6740     }
6741   line_ptr += bytes_read;
6742   lh->statement_program_start = line_ptr;
6743
6744   if (line_ptr > (dwarf2_per_objfile->line_buffer
6745                   + dwarf2_per_objfile->line_size))
6746     complaint (&symfile_complaints,
6747                _("line number info header doesn't fit in `.debug_line' section"));
6748
6749   discard_cleanups (back_to);
6750   return lh;
6751 }
6752
6753 /* This function exists to work around a bug in certain compilers
6754    (particularly GCC 2.95), in which the first line number marker of a
6755    function does not show up until after the prologue, right before
6756    the second line number marker.  This function shifts ADDRESS down
6757    to the beginning of the function if necessary, and is called on
6758    addresses passed to record_line.  */
6759
6760 static CORE_ADDR
6761 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
6762 {
6763   struct function_range *fn;
6764
6765   /* Find the function_range containing address.  */
6766   if (!cu->first_fn)
6767     return address;
6768
6769   if (!cu->cached_fn)
6770     cu->cached_fn = cu->first_fn;
6771
6772   fn = cu->cached_fn;
6773   while (fn)
6774     if (fn->lowpc <= address && fn->highpc > address)
6775       goto found;
6776     else
6777       fn = fn->next;
6778
6779   fn = cu->first_fn;
6780   while (fn && fn != cu->cached_fn)
6781     if (fn->lowpc <= address && fn->highpc > address)
6782       goto found;
6783     else
6784       fn = fn->next;
6785
6786   return address;
6787
6788  found:
6789   if (fn->seen_line)
6790     return address;
6791   if (address != fn->lowpc)
6792     complaint (&symfile_complaints,
6793                _("misplaced first line number at 0x%lx for '%s'"),
6794                (unsigned long) address, fn->name);
6795   fn->seen_line = 1;
6796   return fn->lowpc;
6797 }
6798
6799 /* Decode the Line Number Program (LNP) for the given line_header
6800    structure and CU.  The actual information extracted and the type
6801    of structures created from the LNP depends on the value of PST.
6802
6803    1. If PST is NULL, then this procedure uses the data from the program
6804       to create all necessary symbol tables, and their linetables.
6805       The compilation directory of the file is passed in COMP_DIR,
6806       and must not be NULL.
6807
6808    2. If PST is not NULL, this procedure reads the program to determine
6809       the list of files included by the unit represented by PST, and
6810       builds all the associated partial symbol tables.  In this case,
6811       the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6812       is not used to compute the full name of the symtab, and therefore
6813       omitting it when building the partial symtab does not introduce
6814       the potential for inconsistency - a partial symtab and its associated
6815       symbtab having a different fullname -).  */
6816
6817 static void
6818 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
6819                     struct dwarf2_cu *cu, struct partial_symtab *pst)
6820 {
6821   gdb_byte *line_ptr, *extended_end;
6822   gdb_byte *line_end;
6823   unsigned int bytes_read, extended_len;
6824   unsigned char op_code, extended_op, adj_opcode;
6825   CORE_ADDR baseaddr;
6826   struct objfile *objfile = cu->objfile;
6827   const int decode_for_pst_p = (pst != NULL);
6828   struct subfile *last_subfile = NULL, *first_subfile = current_subfile;
6829
6830   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6831
6832   line_ptr = lh->statement_program_start;
6833   line_end = lh->statement_program_end;
6834
6835   /* Read the statement sequences until there's nothing left.  */
6836   while (line_ptr < line_end)
6837     {
6838       /* state machine registers  */
6839       CORE_ADDR address = 0;
6840       unsigned int file = 1;
6841       unsigned int line = 1;
6842       unsigned int column = 0;
6843       int is_stmt = lh->default_is_stmt;
6844       int basic_block = 0;
6845       int end_sequence = 0;
6846
6847       if (!decode_for_pst_p && lh->num_file_names >= file)
6848         {
6849           /* Start a subfile for the current file of the state machine.  */
6850           /* lh->include_dirs and lh->file_names are 0-based, but the
6851              directory and file name numbers in the statement program
6852              are 1-based.  */
6853           struct file_entry *fe = &lh->file_names[file - 1];
6854           char *dir = NULL;
6855
6856           if (fe->dir_index)
6857             dir = lh->include_dirs[fe->dir_index - 1];
6858
6859           dwarf2_start_subfile (fe->name, dir, comp_dir);
6860         }
6861
6862       /* Decode the table.  */
6863       while (!end_sequence)
6864         {
6865           op_code = read_1_byte (abfd, line_ptr);
6866           line_ptr += 1;
6867
6868           if (op_code >= lh->opcode_base)
6869             {
6870               /* Special operand.  */
6871               adj_opcode = op_code - lh->opcode_base;
6872               address += (adj_opcode / lh->line_range)
6873                 * lh->minimum_instruction_length;
6874               line += lh->line_base + (adj_opcode % lh->line_range);
6875               if (lh->num_file_names < file)
6876                 dwarf2_debug_line_missing_file_complaint ();
6877               else
6878                 {
6879                   lh->file_names[file - 1].included_p = 1;
6880                   if (!decode_for_pst_p)
6881                     {
6882                       if (last_subfile != current_subfile)
6883                         {
6884                           if (last_subfile)
6885                             record_line (last_subfile, 0, address);
6886                           last_subfile = current_subfile;
6887                         }
6888                       /* Append row to matrix using current values.  */
6889                       record_line (current_subfile, line,
6890                                    check_cu_functions (address, cu));
6891                     }
6892                 }
6893               basic_block = 1;
6894             }
6895           else switch (op_code)
6896             {
6897             case DW_LNS_extended_op:
6898               extended_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6899               line_ptr += bytes_read;
6900               extended_end = line_ptr + extended_len;
6901               extended_op = read_1_byte (abfd, line_ptr);
6902               line_ptr += 1;
6903               switch (extended_op)
6904                 {
6905                 case DW_LNE_end_sequence:
6906                   end_sequence = 1;
6907
6908                   if (lh->num_file_names < file)
6909                     dwarf2_debug_line_missing_file_complaint ();
6910                   else
6911                     {
6912                       lh->file_names[file - 1].included_p = 1;
6913                       if (!decode_for_pst_p)
6914                         record_line (current_subfile, 0, address);
6915                     }
6916                   break;
6917                 case DW_LNE_set_address:
6918                   address = read_address (abfd, line_ptr, cu, &bytes_read);
6919                   line_ptr += bytes_read;
6920                   address += baseaddr;
6921                   break;
6922                 case DW_LNE_define_file:
6923                   {
6924                     char *cur_file;
6925                     unsigned int dir_index, mod_time, length;
6926
6927                     cur_file = read_string (abfd, line_ptr, &bytes_read);
6928                     line_ptr += bytes_read;
6929                     dir_index =
6930                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6931                     line_ptr += bytes_read;
6932                     mod_time =
6933                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6934                     line_ptr += bytes_read;
6935                     length =
6936                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6937                     line_ptr += bytes_read;
6938                     add_file_name (lh, cur_file, dir_index, mod_time, length);
6939                   }
6940                   break;
6941                 default:
6942                   complaint (&symfile_complaints,
6943                              _("mangled .debug_line section"));
6944                   return;
6945                 }
6946               /* Make sure that we parsed the extended op correctly.  If e.g.
6947                  we expected a different address size than the producer used,
6948                  we may have read the wrong number of bytes.  */
6949               if (line_ptr != extended_end)
6950                 {
6951                   complaint (&symfile_complaints,
6952                              _("mangled .debug_line section"));
6953                   return;
6954                 }
6955               break;
6956             case DW_LNS_copy:
6957               if (lh->num_file_names < file)
6958                 dwarf2_debug_line_missing_file_complaint ();
6959               else
6960                 {
6961                   lh->file_names[file - 1].included_p = 1;
6962                   if (!decode_for_pst_p)
6963                     {
6964                       if (last_subfile != current_subfile)
6965                         {
6966                           if (last_subfile)
6967                             record_line (last_subfile, 0, address);
6968                           last_subfile = current_subfile;
6969                         }
6970                       record_line (current_subfile, line,
6971                                    check_cu_functions (address, cu));
6972                     }
6973                 }
6974               basic_block = 0;
6975               break;
6976             case DW_LNS_advance_pc:
6977               address += lh->minimum_instruction_length
6978                 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6979               line_ptr += bytes_read;
6980               break;
6981             case DW_LNS_advance_line:
6982               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
6983               line_ptr += bytes_read;
6984               break;
6985             case DW_LNS_set_file:
6986               {
6987                 /* The arrays lh->include_dirs and lh->file_names are
6988                    0-based, but the directory and file name numbers in
6989                    the statement program are 1-based.  */
6990                 struct file_entry *fe;
6991                 char *dir = NULL;
6992
6993                 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
6994                 line_ptr += bytes_read;
6995                 if (lh->num_file_names < file)
6996                   dwarf2_debug_line_missing_file_complaint ();
6997                 else
6998                   {
6999                     fe = &lh->file_names[file - 1];
7000                     if (fe->dir_index)
7001                       dir = lh->include_dirs[fe->dir_index - 1];
7002                     if (!decode_for_pst_p)
7003                       {
7004                         last_subfile = current_subfile;
7005                         dwarf2_start_subfile (fe->name, dir, comp_dir);
7006                       }
7007                   }
7008               }
7009               break;
7010             case DW_LNS_set_column:
7011               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
7012               line_ptr += bytes_read;
7013               break;
7014             case DW_LNS_negate_stmt:
7015               is_stmt = (!is_stmt);
7016               break;
7017             case DW_LNS_set_basic_block:
7018               basic_block = 1;
7019               break;
7020             /* Add to the address register of the state machine the
7021                address increment value corresponding to special opcode
7022                255.  I.e., this value is scaled by the minimum
7023                instruction length since special opcode 255 would have
7024                scaled the the increment.  */
7025             case DW_LNS_const_add_pc:
7026               address += (lh->minimum_instruction_length
7027                           * ((255 - lh->opcode_base) / lh->line_range));
7028               break;
7029             case DW_LNS_fixed_advance_pc:
7030               address += read_2_bytes (abfd, line_ptr);
7031               line_ptr += 2;
7032               break;
7033             default:
7034               {
7035                 /* Unknown standard opcode, ignore it.  */
7036                 int i;
7037
7038                 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
7039                   {
7040                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
7041                     line_ptr += bytes_read;
7042                   }
7043               }
7044             }
7045         }
7046     }
7047
7048   if (decode_for_pst_p)
7049     {
7050       int file_index;
7051
7052       /* Now that we're done scanning the Line Header Program, we can
7053          create the psymtab of each included file.  */
7054       for (file_index = 0; file_index < lh->num_file_names; file_index++)
7055         if (lh->file_names[file_index].included_p == 1)
7056           {
7057             const struct file_entry fe = lh->file_names [file_index];
7058             char *include_name = fe.name;
7059             char *dir_name = NULL;
7060             char *pst_filename = pst->filename;
7061
7062             if (fe.dir_index)
7063               dir_name = lh->include_dirs[fe.dir_index - 1];
7064
7065             if (!IS_ABSOLUTE_PATH (include_name) && dir_name != NULL)
7066               {
7067                 include_name = concat (dir_name, SLASH_STRING,
7068                                        include_name, (char *)NULL);
7069                 make_cleanup (xfree, include_name);
7070               }
7071
7072             if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
7073               {
7074                 pst_filename = concat (pst->dirname, SLASH_STRING,
7075                                        pst_filename, (char *)NULL);
7076                 make_cleanup (xfree, pst_filename);
7077               }
7078
7079             if (strcmp (include_name, pst_filename) != 0)
7080               dwarf2_create_include_psymtab (include_name, pst, objfile);
7081           }
7082     }
7083   else
7084     {
7085       /* Make sure a symtab is created for every file, even files
7086          which contain only variables (i.e. no code with associated
7087          line numbers).  */
7088
7089       int i;
7090       struct file_entry *fe;
7091
7092       for (i = 0; i < lh->num_file_names; i++)
7093         {
7094           char *dir = NULL;
7095           fe = &lh->file_names[i];
7096           if (fe->dir_index)
7097             dir = lh->include_dirs[fe->dir_index - 1];
7098           dwarf2_start_subfile (fe->name, dir, comp_dir);
7099
7100           /* Skip the main file; we don't need it, and it must be
7101              allocated last, so that it will show up before the
7102              non-primary symtabs in the objfile's symtab list.  */
7103           if (current_subfile == first_subfile)
7104             continue;
7105
7106           if (current_subfile->symtab == NULL)
7107             current_subfile->symtab = allocate_symtab (current_subfile->name,
7108                                                        cu->objfile);
7109           fe->symtab = current_subfile->symtab;
7110         }
7111     }
7112 }
7113
7114 /* Start a subfile for DWARF.  FILENAME is the name of the file and
7115    DIRNAME the name of the source directory which contains FILENAME
7116    or NULL if not known.  COMP_DIR is the compilation directory for the
7117    linetable's compilation unit or NULL if not known.
7118    This routine tries to keep line numbers from identical absolute and
7119    relative file names in a common subfile.
7120
7121    Using the `list' example from the GDB testsuite, which resides in
7122    /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
7123    of /srcdir/list0.c yields the following debugging information for list0.c:
7124
7125    DW_AT_name:          /srcdir/list0.c
7126    DW_AT_comp_dir:              /compdir
7127    files.files[0].name: list0.h
7128    files.files[0].dir:  /srcdir
7129    files.files[1].name: list0.c
7130    files.files[1].dir:  /srcdir
7131
7132    The line number information for list0.c has to end up in a single
7133    subfile, so that `break /srcdir/list0.c:1' works as expected.
7134    start_subfile will ensure that this happens provided that we pass the
7135    concatenation of files.files[1].dir and files.files[1].name as the
7136    subfile's name.  */
7137
7138 static void
7139 dwarf2_start_subfile (char *filename, char *dirname, char *comp_dir)
7140 {
7141   char *fullname;
7142
7143   /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
7144      `start_symtab' will always pass the contents of DW_AT_comp_dir as
7145      second argument to start_subfile.  To be consistent, we do the
7146      same here.  In order not to lose the line information directory,
7147      we concatenate it to the filename when it makes sense.
7148      Note that the Dwarf3 standard says (speaking of filenames in line
7149      information): ``The directory index is ignored for file names
7150      that represent full path names''.  Thus ignoring dirname in the
7151      `else' branch below isn't an issue.  */
7152
7153   if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
7154     fullname = concat (dirname, SLASH_STRING, filename, (char *)NULL);
7155   else
7156     fullname = filename;
7157
7158   start_subfile (fullname, comp_dir);
7159
7160   if (fullname != filename)
7161     xfree (fullname);
7162 }
7163
7164 static void
7165 var_decode_location (struct attribute *attr, struct symbol *sym,
7166                      struct dwarf2_cu *cu)
7167 {
7168   struct objfile *objfile = cu->objfile;
7169   struct comp_unit_head *cu_header = &cu->header;
7170
7171   /* NOTE drow/2003-01-30: There used to be a comment and some special
7172      code here to turn a symbol with DW_AT_external and a
7173      SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol.  This was
7174      necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
7175      with some versions of binutils) where shared libraries could have
7176      relocations against symbols in their debug information - the
7177      minimal symbol would have the right address, but the debug info
7178      would not.  It's no longer necessary, because we will explicitly
7179      apply relocations when we read in the debug information now.  */
7180
7181   /* A DW_AT_location attribute with no contents indicates that a
7182      variable has been optimized away.  */
7183   if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
7184     {
7185       SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
7186       return;
7187     }
7188
7189   /* Handle one degenerate form of location expression specially, to
7190      preserve GDB's previous behavior when section offsets are
7191      specified.  If this is just a DW_OP_addr then mark this symbol
7192      as LOC_STATIC.  */
7193
7194   if (attr_form_is_block (attr)
7195       && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
7196       && DW_BLOCK (attr)->data[0] == DW_OP_addr)
7197     {
7198       unsigned int dummy;
7199
7200       SYMBOL_VALUE_ADDRESS (sym) =
7201         read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
7202       fixup_symbol_section (sym, objfile);
7203       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
7204                                               SYMBOL_SECTION (sym));
7205       SYMBOL_CLASS (sym) = LOC_STATIC;
7206       return;
7207     }
7208
7209   /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7210      expression evaluator, and use LOC_COMPUTED only when necessary
7211      (i.e. when the value of a register or memory location is
7212      referenced, or a thread-local block, etc.).  Then again, it might
7213      not be worthwhile.  I'm assuming that it isn't unless performance
7214      or memory numbers show me otherwise.  */
7215
7216   dwarf2_symbol_mark_computed (attr, sym, cu);
7217   SYMBOL_CLASS (sym) = LOC_COMPUTED;
7218 }
7219
7220 /* Given a pointer to a DWARF information entry, figure out if we need
7221    to make a symbol table entry for it, and if so, create a new entry
7222    and return a pointer to it.
7223    If TYPE is NULL, determine symbol type from the die, otherwise
7224    used the passed type.  */
7225
7226 static struct symbol *
7227 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
7228 {
7229   struct objfile *objfile = cu->objfile;
7230   struct symbol *sym = NULL;
7231   char *name;
7232   struct attribute *attr = NULL;
7233   struct attribute *attr2 = NULL;
7234   CORE_ADDR baseaddr;
7235
7236   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7237
7238   if (die->tag != DW_TAG_namespace)
7239     name = dwarf2_linkage_name (die, cu);
7240   else
7241     name = TYPE_NAME (type);
7242
7243   if (name)
7244     {
7245       sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
7246                                              sizeof (struct symbol));
7247       OBJSTAT (objfile, n_syms++);
7248       memset (sym, 0, sizeof (struct symbol));
7249
7250       /* Cache this symbol's name and the name's demangled form (if any).  */
7251       SYMBOL_LANGUAGE (sym) = cu->language;
7252       SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
7253
7254       /* Default assumptions.
7255          Use the passed type or decode it from the die.  */
7256       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7257       SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
7258       if (type != NULL)
7259         SYMBOL_TYPE (sym) = type;
7260       else
7261         SYMBOL_TYPE (sym) = die_type (die, cu);
7262       attr = dwarf2_attr (die, DW_AT_decl_line, cu);
7263       if (attr)
7264         {
7265           SYMBOL_LINE (sym) = DW_UNSND (attr);
7266         }
7267
7268       attr = dwarf2_attr (die, DW_AT_decl_file, cu);
7269       if (attr)
7270         {
7271           int file_index = DW_UNSND (attr);
7272           if (cu->line_header == NULL
7273               || file_index > cu->line_header->num_file_names)
7274             complaint (&symfile_complaints,
7275                        _("file index out of range"));
7276           else if (file_index > 0)
7277             {
7278               struct file_entry *fe;
7279               fe = &cu->line_header->file_names[file_index - 1];
7280               SYMBOL_SYMTAB (sym) = fe->symtab;
7281             }
7282         }
7283
7284       switch (die->tag)
7285         {
7286         case DW_TAG_label:
7287           attr = dwarf2_attr (die, DW_AT_low_pc, cu);
7288           if (attr)
7289             {
7290               SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
7291             }
7292           SYMBOL_CLASS (sym) = LOC_LABEL;
7293           break;
7294         case DW_TAG_subprogram:
7295           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7296              finish_block.  */
7297           SYMBOL_CLASS (sym) = LOC_BLOCK;
7298           attr2 = dwarf2_attr (die, DW_AT_external, cu);
7299           if (attr2 && (DW_UNSND (attr2) != 0))
7300             {
7301               add_symbol_to_list (sym, &global_symbols);
7302             }
7303           else
7304             {
7305               add_symbol_to_list (sym, cu->list_in_scope);
7306             }
7307           break;
7308         case DW_TAG_variable:
7309           /* Compilation with minimal debug info may result in variables
7310              with missing type entries. Change the misleading `void' type
7311              to something sensible.  */
7312           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
7313             SYMBOL_TYPE (sym)
7314               = builtin_type (current_gdbarch)->nodebug_data_symbol;
7315
7316           attr = dwarf2_attr (die, DW_AT_const_value, cu);
7317           if (attr)
7318             {
7319               dwarf2_const_value (attr, sym, cu);
7320               attr2 = dwarf2_attr (die, DW_AT_external, cu);
7321               if (attr2 && (DW_UNSND (attr2) != 0))
7322                 add_symbol_to_list (sym, &global_symbols);
7323               else
7324                 add_symbol_to_list (sym, cu->list_in_scope);
7325               break;
7326             }
7327           attr = dwarf2_attr (die, DW_AT_location, cu);
7328           if (attr)
7329             {
7330               var_decode_location (attr, sym, cu);
7331               attr2 = dwarf2_attr (die, DW_AT_external, cu);
7332               if (attr2 && (DW_UNSND (attr2) != 0))
7333                 add_symbol_to_list (sym, &global_symbols);
7334               else
7335                 add_symbol_to_list (sym, cu->list_in_scope);
7336             }
7337           else
7338             {
7339               /* We do not know the address of this symbol.
7340                  If it is an external symbol and we have type information
7341                  for it, enter the symbol as a LOC_UNRESOLVED symbol.
7342                  The address of the variable will then be determined from
7343                  the minimal symbol table whenever the variable is
7344                  referenced.  */
7345               attr2 = dwarf2_attr (die, DW_AT_external, cu);
7346               if (attr2 && (DW_UNSND (attr2) != 0)
7347                   && dwarf2_attr (die, DW_AT_type, cu) != NULL)
7348                 {
7349                   SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
7350                   add_symbol_to_list (sym, &global_symbols);
7351                 }
7352             }
7353           break;
7354         case DW_TAG_formal_parameter:
7355           attr = dwarf2_attr (die, DW_AT_location, cu);
7356           if (attr)
7357             {
7358               var_decode_location (attr, sym, cu);
7359               /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary?  */
7360               if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
7361                 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
7362             }
7363           attr = dwarf2_attr (die, DW_AT_const_value, cu);
7364           if (attr)
7365             {
7366               dwarf2_const_value (attr, sym, cu);
7367             }
7368           add_symbol_to_list (sym, cu->list_in_scope);
7369           break;
7370         case DW_TAG_unspecified_parameters:
7371           /* From varargs functions; gdb doesn't seem to have any
7372              interest in this information, so just ignore it for now.
7373              (FIXME?) */
7374           break;
7375         case DW_TAG_class_type:
7376         case DW_TAG_interface_type:
7377         case DW_TAG_structure_type:
7378         case DW_TAG_union_type:
7379         case DW_TAG_set_type:
7380         case DW_TAG_enumeration_type:
7381           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7382           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7383
7384           /* Make sure that the symbol includes appropriate enclosing
7385              classes/namespaces in its name.  These are calculated in
7386              read_structure_type, and the correct name is saved in
7387              the type.  */
7388
7389           if (cu->language == language_cplus
7390               || cu->language == language_java)
7391             {
7392               struct type *type = SYMBOL_TYPE (sym);
7393
7394               if (TYPE_TAG_NAME (type) != NULL)
7395                 {
7396                   /* FIXME: carlton/2003-11-10: Should this use
7397                      SYMBOL_SET_NAMES instead?  (The same problem also
7398                      arises further down in this function.)  */
7399                   /* The type's name is already allocated along with
7400                      this objfile, so we don't need to duplicate it
7401                      for the symbol.  */
7402                   SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type);
7403                 }
7404             }
7405
7406           {
7407             /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7408                really ever be static objects: otherwise, if you try
7409                to, say, break of a class's method and you're in a file
7410                which doesn't mention that class, it won't work unless
7411                the check for all static symbols in lookup_symbol_aux
7412                saves you.  See the OtherFileClass tests in
7413                gdb.c++/namespace.exp.  */
7414
7415             struct pending **list_to_add;
7416
7417             list_to_add = (cu->list_in_scope == &file_symbols
7418                            && (cu->language == language_cplus
7419                                || cu->language == language_java)
7420                            ? &global_symbols : cu->list_in_scope);
7421
7422             add_symbol_to_list (sym, list_to_add);
7423
7424             /* The semantics of C++ state that "struct foo { ... }" also
7425                defines a typedef for "foo".  A Java class declaration also
7426                defines a typedef for the class.  Synthesize a typedef symbol
7427                so that "ptype foo" works as expected.  */
7428             if (cu->language == language_cplus
7429                 || cu->language == language_java
7430                 || cu->language == language_ada)
7431               {
7432                 struct symbol *typedef_sym = (struct symbol *)
7433                   obstack_alloc (&objfile->objfile_obstack,
7434                                  sizeof (struct symbol));
7435                 *typedef_sym = *sym;
7436                 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
7437                 /* The symbol's name is already allocated along with
7438                    this objfile, so we don't need to duplicate it for
7439                    the type.  */
7440                 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
7441                   TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
7442                 add_symbol_to_list (typedef_sym, list_to_add);
7443               }
7444           }
7445           break;
7446         case DW_TAG_typedef:
7447           if (processing_has_namespace_info
7448               && processing_current_prefix[0] != '\0')
7449             {
7450               SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7451                                                            processing_current_prefix,
7452                                                            name, cu);
7453             }
7454           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7455           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7456           add_symbol_to_list (sym, cu->list_in_scope);
7457           break;
7458         case DW_TAG_base_type:
7459         case DW_TAG_subrange_type:
7460           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7461           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
7462           add_symbol_to_list (sym, cu->list_in_scope);
7463           break;
7464         case DW_TAG_enumerator:
7465           if (processing_has_namespace_info
7466               && processing_current_prefix[0] != '\0')
7467             {
7468               SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack,
7469                                                            processing_current_prefix,
7470                                                            name, cu);
7471             }
7472           attr = dwarf2_attr (die, DW_AT_const_value, cu);
7473           if (attr)
7474             {
7475               dwarf2_const_value (attr, sym, cu);
7476             }
7477           {
7478             /* NOTE: carlton/2003-11-10: See comment above in the
7479                DW_TAG_class_type, etc. block.  */
7480
7481             struct pending **list_to_add;
7482
7483             list_to_add = (cu->list_in_scope == &file_symbols
7484                            && (cu->language == language_cplus
7485                                || cu->language == language_java)
7486                            ? &global_symbols : cu->list_in_scope);
7487
7488             add_symbol_to_list (sym, list_to_add);
7489           }
7490           break;
7491         case DW_TAG_namespace:
7492           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
7493           add_symbol_to_list (sym, &global_symbols);
7494           break;
7495         default:
7496           /* Not a tag we recognize.  Hopefully we aren't processing
7497              trash data, but since we must specifically ignore things
7498              we don't recognize, there is nothing else we should do at
7499              this point. */
7500           complaint (&symfile_complaints, _("unsupported tag: '%s'"),
7501                      dwarf_tag_name (die->tag));
7502           break;
7503         }
7504     }
7505   return (sym);
7506 }
7507
7508 /* Copy constant value from an attribute to a symbol.  */
7509
7510 static void
7511 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
7512                     struct dwarf2_cu *cu)
7513 {
7514   struct objfile *objfile = cu->objfile;
7515   struct comp_unit_head *cu_header = &cu->header;
7516   struct dwarf_block *blk;
7517
7518   switch (attr->form)
7519     {
7520     case DW_FORM_addr:
7521       if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
7522         dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7523                                                       cu_header->addr_size,
7524                                                       TYPE_LENGTH (SYMBOL_TYPE
7525                                                                    (sym)));
7526       SYMBOL_VALUE_BYTES (sym) =
7527         obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size);
7528       /* NOTE: cagney/2003-05-09: In-lined store_address call with
7529          it's body - store_unsigned_integer.  */
7530       store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
7531                               DW_ADDR (attr));
7532       SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7533       break;
7534     case DW_FORM_block1:
7535     case DW_FORM_block2:
7536     case DW_FORM_block4:
7537     case DW_FORM_block:
7538       blk = DW_BLOCK (attr);
7539       if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
7540         dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
7541                                                       blk->size,
7542                                                       TYPE_LENGTH (SYMBOL_TYPE
7543                                                                    (sym)));
7544       SYMBOL_VALUE_BYTES (sym) =
7545         obstack_alloc (&objfile->objfile_obstack, blk->size);
7546       memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
7547       SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
7548       break;
7549
7550       /* The DW_AT_const_value attributes are supposed to carry the
7551          symbol's value "represented as it would be on the target
7552          architecture."  By the time we get here, it's already been
7553          converted to host endianness, so we just need to sign- or
7554          zero-extend it as appropriate.  */
7555     case DW_FORM_data1:
7556       dwarf2_const_value_data (attr, sym, 8);
7557       break;
7558     case DW_FORM_data2:
7559       dwarf2_const_value_data (attr, sym, 16);
7560       break;
7561     case DW_FORM_data4:
7562       dwarf2_const_value_data (attr, sym, 32);
7563       break;
7564     case DW_FORM_data8:
7565       dwarf2_const_value_data (attr, sym, 64);
7566       break;
7567
7568     case DW_FORM_sdata:
7569       SYMBOL_VALUE (sym) = DW_SND (attr);
7570       SYMBOL_CLASS (sym) = LOC_CONST;
7571       break;
7572
7573     case DW_FORM_udata:
7574       SYMBOL_VALUE (sym) = DW_UNSND (attr);
7575       SYMBOL_CLASS (sym) = LOC_CONST;
7576       break;
7577
7578     default:
7579       complaint (&symfile_complaints,
7580                  _("unsupported const value attribute form: '%s'"),
7581                  dwarf_form_name (attr->form));
7582       SYMBOL_VALUE (sym) = 0;
7583       SYMBOL_CLASS (sym) = LOC_CONST;
7584       break;
7585     }
7586 }
7587
7588
7589 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7590    or zero-extend it as appropriate for the symbol's type.  */
7591 static void
7592 dwarf2_const_value_data (struct attribute *attr,
7593                          struct symbol *sym,
7594                          int bits)
7595 {
7596   LONGEST l = DW_UNSND (attr);
7597
7598   if (bits < sizeof (l) * 8)
7599     {
7600       if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
7601         l &= ((LONGEST) 1 << bits) - 1;
7602       else
7603         l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
7604     }
7605
7606   SYMBOL_VALUE (sym) = l;
7607   SYMBOL_CLASS (sym) = LOC_CONST;
7608 }
7609
7610
7611 /* Return the type of the die in question using its DW_AT_type attribute.  */
7612
7613 static struct type *
7614 die_type (struct die_info *die, struct dwarf2_cu *cu)
7615 {
7616   struct type *type;
7617   struct attribute *type_attr;
7618   struct die_info *type_die;
7619
7620   type_attr = dwarf2_attr (die, DW_AT_type, cu);
7621   if (!type_attr)
7622     {
7623       /* A missing DW_AT_type represents a void type.  */
7624       return builtin_type (current_gdbarch)->builtin_void;
7625     }
7626   else
7627     type_die = follow_die_ref (die, type_attr, cu);
7628
7629   type = tag_type_to_type (type_die, cu);
7630   if (!type)
7631     {
7632       dump_die (type_die);
7633       error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7634                       cu->objfile->name);
7635     }
7636   return type;
7637 }
7638
7639 /* Return the containing type of the die in question using its
7640    DW_AT_containing_type attribute.  */
7641
7642 static struct type *
7643 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
7644 {
7645   struct type *type = NULL;
7646   struct attribute *type_attr;
7647   struct die_info *type_die = NULL;
7648
7649   type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
7650   if (type_attr)
7651     {
7652       type_die = follow_die_ref (die, type_attr, cu);
7653       type = tag_type_to_type (type_die, cu);
7654     }
7655   if (!type)
7656     {
7657       if (type_die)
7658         dump_die (type_die);
7659       error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7660                       cu->objfile->name);
7661     }
7662   return type;
7663 }
7664
7665 static struct type *
7666 tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
7667 {
7668   if (die->type)
7669     {
7670       return die->type;
7671     }
7672   else
7673     {
7674       read_type_die (die, cu);
7675       if (!die->type)
7676         {
7677           dump_die (die);
7678           error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7679                           cu->objfile->name);
7680         }
7681       return die->type;
7682     }
7683 }
7684
7685 static void
7686 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
7687 {
7688   char *prefix = determine_prefix (die, cu);
7689   const char *old_prefix = processing_current_prefix;
7690   struct cleanup *back_to = make_cleanup (xfree, prefix);
7691   processing_current_prefix = prefix;
7692
7693   switch (die->tag)
7694     {
7695     case DW_TAG_class_type:
7696     case DW_TAG_interface_type:
7697     case DW_TAG_structure_type:
7698     case DW_TAG_union_type:
7699       read_structure_type (die, cu);
7700       break;
7701     case DW_TAG_enumeration_type:
7702       read_enumeration_type (die, cu);
7703       break;
7704     case DW_TAG_subprogram:
7705     case DW_TAG_subroutine_type:
7706       read_subroutine_type (die, cu);
7707       break;
7708     case DW_TAG_array_type:
7709       read_array_type (die, cu);
7710       break;
7711     case DW_TAG_set_type:
7712       read_set_type (die, cu);
7713       break;
7714     case DW_TAG_pointer_type:
7715       read_tag_pointer_type (die, cu);
7716       break;
7717     case DW_TAG_ptr_to_member_type:
7718       read_tag_ptr_to_member_type (die, cu);
7719       break;
7720     case DW_TAG_reference_type:
7721       read_tag_reference_type (die, cu);
7722       break;
7723     case DW_TAG_const_type:
7724       read_tag_const_type (die, cu);
7725       break;
7726     case DW_TAG_volatile_type:
7727       read_tag_volatile_type (die, cu);
7728       break;
7729     case DW_TAG_string_type:
7730       read_tag_string_type (die, cu);
7731       break;
7732     case DW_TAG_typedef:
7733       read_typedef (die, cu);
7734       break;
7735     case DW_TAG_subrange_type:
7736       read_subrange_type (die, cu);
7737       break;
7738     case DW_TAG_base_type:
7739       read_base_type (die, cu);
7740       break;
7741     case DW_TAG_unspecified_type:
7742       read_unspecified_type (die, cu);
7743       break;
7744     default:
7745       complaint (&symfile_complaints, _("unexpected tag in read_type_die: '%s'"),
7746                  dwarf_tag_name (die->tag));
7747       break;
7748     }
7749
7750   processing_current_prefix = old_prefix;
7751   do_cleanups (back_to);
7752 }
7753
7754 /* Return the name of the namespace/class that DIE is defined within,
7755    or "" if we can't tell.  The caller should xfree the result.  */
7756
7757 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7758    therein) for an example of how to use this function to deal with
7759    DW_AT_specification.  */
7760
7761 static char *
7762 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
7763 {
7764   struct die_info *parent;
7765
7766   if (cu->language != language_cplus
7767       && cu->language != language_java)
7768     return NULL;
7769
7770   parent = die->parent;
7771
7772   if (parent == NULL)
7773     {
7774       return xstrdup ("");
7775     }
7776   else
7777     {
7778       switch (parent->tag) {
7779       case DW_TAG_namespace:
7780         {
7781           /* FIXME: carlton/2004-03-05: Should I follow extension dies
7782              before doing this check?  */
7783           if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7784             {
7785               return xstrdup (TYPE_TAG_NAME (parent->type));
7786             }
7787           else
7788             {
7789               int dummy;
7790               char *parent_prefix = determine_prefix (parent, cu);
7791               char *retval = typename_concat (NULL, parent_prefix,
7792                                               namespace_name (parent, &dummy,
7793                                                               cu),
7794                                               cu);
7795               xfree (parent_prefix);
7796               return retval;
7797             }
7798         }
7799         break;
7800       case DW_TAG_class_type:
7801       case DW_TAG_interface_type:
7802       case DW_TAG_structure_type:
7803         {
7804           if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL)
7805             {
7806               return xstrdup (TYPE_TAG_NAME (parent->type));
7807             }
7808           else
7809             {
7810               const char *old_prefix = processing_current_prefix;
7811               char *new_prefix = determine_prefix (parent, cu);
7812               char *retval;
7813
7814               processing_current_prefix = new_prefix;
7815               retval = determine_class_name (parent, cu);
7816               processing_current_prefix = old_prefix;
7817
7818               xfree (new_prefix);
7819               return retval;
7820             }
7821         }
7822       default:
7823         return determine_prefix (parent, cu);
7824       }
7825     }
7826 }
7827
7828 /* Return a newly-allocated string formed by concatenating PREFIX and
7829    SUFFIX with appropriate separator.  If PREFIX or SUFFIX is NULL or empty, then
7830    simply copy the SUFFIX or PREFIX, respectively.  If OBS is non-null,
7831    perform an obconcat, otherwise allocate storage for the result.  The CU argument
7832    is used to determine the language and hence, the appropriate separator.  */
7833
7834 #define MAX_SEP_LEN 2  /* sizeof ("::")  */
7835
7836 static char *
7837 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
7838                  struct dwarf2_cu *cu)
7839 {
7840   char *sep;
7841
7842   if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
7843     sep = "";
7844   else if (cu->language == language_java)
7845     sep = ".";
7846   else
7847     sep = "::";
7848
7849   if (obs == NULL)
7850     {
7851       char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
7852       retval[0] = '\0';
7853
7854       if (prefix)
7855         {
7856           strcpy (retval, prefix);
7857           strcat (retval, sep);
7858         }
7859       if (suffix)
7860         strcat (retval, suffix);
7861
7862       return retval;
7863     }
7864   else
7865     {
7866       /* We have an obstack.  */
7867       return obconcat (obs, prefix, sep, suffix);
7868     }
7869 }
7870
7871 #if 0
7872 struct die_info *
7873 copy_die (struct die_info *old_die)
7874 {
7875   struct die_info *new_die;
7876   int i, num_attrs;
7877
7878   new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
7879   memset (new_die, 0, sizeof (struct die_info));
7880
7881   new_die->tag = old_die->tag;
7882   new_die->has_children = old_die->has_children;
7883   new_die->abbrev = old_die->abbrev;
7884   new_die->offset = old_die->offset;
7885   new_die->type = NULL;
7886
7887   num_attrs = old_die->num_attrs;
7888   new_die->num_attrs = num_attrs;
7889   new_die->attrs = (struct attribute *)
7890     xmalloc (num_attrs * sizeof (struct attribute));
7891
7892   for (i = 0; i < old_die->num_attrs; ++i)
7893     {
7894       new_die->attrs[i].name = old_die->attrs[i].name;
7895       new_die->attrs[i].form = old_die->attrs[i].form;
7896       new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
7897     }
7898
7899   new_die->next = NULL;
7900   return new_die;
7901 }
7902 #endif
7903
7904 /* Return sibling of die, NULL if no sibling.  */
7905
7906 static struct die_info *
7907 sibling_die (struct die_info *die)
7908 {
7909   return die->sibling;
7910 }
7911
7912 /* Get linkage name of a die, return NULL if not found.  */
7913
7914 static char *
7915 dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
7916 {
7917   struct attribute *attr;
7918
7919   attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
7920   if (attr && DW_STRING (attr))
7921     return DW_STRING (attr);
7922   attr = dwarf2_attr (die, DW_AT_name, cu);
7923   if (attr && DW_STRING (attr))
7924     return DW_STRING (attr);
7925   return NULL;
7926 }
7927
7928 /* Get name of a die, return NULL if not found.  */
7929
7930 static char *
7931 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
7932 {
7933   struct attribute *attr;
7934
7935   attr = dwarf2_attr (die, DW_AT_name, cu);
7936   if (attr && DW_STRING (attr))
7937     return DW_STRING (attr);
7938   return NULL;
7939 }
7940
7941 /* Return the die that this die in an extension of, or NULL if there
7942    is none.  */
7943
7944 static struct die_info *
7945 dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
7946 {
7947   struct attribute *attr;
7948
7949   attr = dwarf2_attr (die, DW_AT_extension, cu);
7950   if (attr == NULL)
7951     return NULL;
7952
7953   return follow_die_ref (die, attr, cu);
7954 }
7955
7956 /* Convert a DIE tag into its string name.  */
7957
7958 static char *
7959 dwarf_tag_name (unsigned tag)
7960 {
7961   switch (tag)
7962     {
7963     case DW_TAG_padding:
7964       return "DW_TAG_padding";
7965     case DW_TAG_array_type:
7966       return "DW_TAG_array_type";
7967     case DW_TAG_class_type:
7968       return "DW_TAG_class_type";
7969     case DW_TAG_entry_point:
7970       return "DW_TAG_entry_point";
7971     case DW_TAG_enumeration_type:
7972       return "DW_TAG_enumeration_type";
7973     case DW_TAG_formal_parameter:
7974       return "DW_TAG_formal_parameter";
7975     case DW_TAG_imported_declaration:
7976       return "DW_TAG_imported_declaration";
7977     case DW_TAG_label:
7978       return "DW_TAG_label";
7979     case DW_TAG_lexical_block:
7980       return "DW_TAG_lexical_block";
7981     case DW_TAG_member:
7982       return "DW_TAG_member";
7983     case DW_TAG_pointer_type:
7984       return "DW_TAG_pointer_type";
7985     case DW_TAG_reference_type:
7986       return "DW_TAG_reference_type";
7987     case DW_TAG_compile_unit:
7988       return "DW_TAG_compile_unit";
7989     case DW_TAG_string_type:
7990       return "DW_TAG_string_type";
7991     case DW_TAG_structure_type:
7992       return "DW_TAG_structure_type";
7993     case DW_TAG_subroutine_type:
7994       return "DW_TAG_subroutine_type";
7995     case DW_TAG_typedef:
7996       return "DW_TAG_typedef";
7997     case DW_TAG_union_type:
7998       return "DW_TAG_union_type";
7999     case DW_TAG_unspecified_parameters:
8000       return "DW_TAG_unspecified_parameters";
8001     case DW_TAG_variant:
8002       return "DW_TAG_variant";
8003     case DW_TAG_common_block:
8004       return "DW_TAG_common_block";
8005     case DW_TAG_common_inclusion:
8006       return "DW_TAG_common_inclusion";
8007     case DW_TAG_inheritance:
8008       return "DW_TAG_inheritance";
8009     case DW_TAG_inlined_subroutine:
8010       return "DW_TAG_inlined_subroutine";
8011     case DW_TAG_module:
8012       return "DW_TAG_module";
8013     case DW_TAG_ptr_to_member_type:
8014       return "DW_TAG_ptr_to_member_type";
8015     case DW_TAG_set_type:
8016       return "DW_TAG_set_type";
8017     case DW_TAG_subrange_type:
8018       return "DW_TAG_subrange_type";
8019     case DW_TAG_with_stmt:
8020       return "DW_TAG_with_stmt";
8021     case DW_TAG_access_declaration:
8022       return "DW_TAG_access_declaration";
8023     case DW_TAG_base_type:
8024       return "DW_TAG_base_type";
8025     case DW_TAG_catch_block:
8026       return "DW_TAG_catch_block";
8027     case DW_TAG_const_type:
8028       return "DW_TAG_const_type";
8029     case DW_TAG_constant:
8030       return "DW_TAG_constant";
8031     case DW_TAG_enumerator:
8032       return "DW_TAG_enumerator";
8033     case DW_TAG_file_type:
8034       return "DW_TAG_file_type";
8035     case DW_TAG_friend:
8036       return "DW_TAG_friend";
8037     case DW_TAG_namelist:
8038       return "DW_TAG_namelist";
8039     case DW_TAG_namelist_item:
8040       return "DW_TAG_namelist_item";
8041     case DW_TAG_packed_type:
8042       return "DW_TAG_packed_type";
8043     case DW_TAG_subprogram:
8044       return "DW_TAG_subprogram";
8045     case DW_TAG_template_type_param:
8046       return "DW_TAG_template_type_param";
8047     case DW_TAG_template_value_param:
8048       return "DW_TAG_template_value_param";
8049     case DW_TAG_thrown_type:
8050       return "DW_TAG_thrown_type";
8051     case DW_TAG_try_block:
8052       return "DW_TAG_try_block";
8053     case DW_TAG_variant_part:
8054       return "DW_TAG_variant_part";
8055     case DW_TAG_variable:
8056       return "DW_TAG_variable";
8057     case DW_TAG_volatile_type:
8058       return "DW_TAG_volatile_type";
8059     case DW_TAG_dwarf_procedure:
8060       return "DW_TAG_dwarf_procedure";
8061     case DW_TAG_restrict_type:
8062       return "DW_TAG_restrict_type";
8063     case DW_TAG_interface_type:
8064       return "DW_TAG_interface_type";
8065     case DW_TAG_namespace:
8066       return "DW_TAG_namespace";
8067     case DW_TAG_imported_module:
8068       return "DW_TAG_imported_module";
8069     case DW_TAG_unspecified_type:
8070       return "DW_TAG_unspecified_type";
8071     case DW_TAG_partial_unit:
8072       return "DW_TAG_partial_unit";
8073     case DW_TAG_imported_unit:
8074       return "DW_TAG_imported_unit";
8075     case DW_TAG_condition:
8076       return "DW_TAG_condition";
8077     case DW_TAG_shared_type:
8078       return "DW_TAG_shared_type";
8079     case DW_TAG_MIPS_loop:
8080       return "DW_TAG_MIPS_loop";
8081     case DW_TAG_HP_array_descriptor:
8082       return "DW_TAG_HP_array_descriptor";
8083     case DW_TAG_format_label:
8084       return "DW_TAG_format_label";
8085     case DW_TAG_function_template:
8086       return "DW_TAG_function_template";
8087     case DW_TAG_class_template:
8088       return "DW_TAG_class_template";
8089     case DW_TAG_GNU_BINCL:
8090       return "DW_TAG_GNU_BINCL";
8091     case DW_TAG_GNU_EINCL:
8092       return "DW_TAG_GNU_EINCL";
8093     case DW_TAG_upc_shared_type:
8094       return "DW_TAG_upc_shared_type";
8095     case DW_TAG_upc_strict_type:
8096       return "DW_TAG_upc_strict_type";
8097     case DW_TAG_upc_relaxed_type:
8098       return "DW_TAG_upc_relaxed_type";
8099     case DW_TAG_PGI_kanji_type:
8100       return "DW_TAG_PGI_kanji_type";
8101     case DW_TAG_PGI_interface_block:
8102       return "DW_TAG_PGI_interface_block";
8103     default:
8104       return "DW_TAG_<unknown>";
8105     }
8106 }
8107
8108 /* Convert a DWARF attribute code into its string name.  */
8109
8110 static char *
8111 dwarf_attr_name (unsigned attr)
8112 {
8113   switch (attr)
8114     {
8115     case DW_AT_sibling:
8116       return "DW_AT_sibling";
8117     case DW_AT_location:
8118       return "DW_AT_location";
8119     case DW_AT_name:
8120       return "DW_AT_name";
8121     case DW_AT_ordering:
8122       return "DW_AT_ordering";
8123     case DW_AT_subscr_data:
8124       return "DW_AT_subscr_data";
8125     case DW_AT_byte_size:
8126       return "DW_AT_byte_size";
8127     case DW_AT_bit_offset:
8128       return "DW_AT_bit_offset";
8129     case DW_AT_bit_size:
8130       return "DW_AT_bit_size";
8131     case DW_AT_element_list:
8132       return "DW_AT_element_list";
8133     case DW_AT_stmt_list:
8134       return "DW_AT_stmt_list";
8135     case DW_AT_low_pc:
8136       return "DW_AT_low_pc";
8137     case DW_AT_high_pc:
8138       return "DW_AT_high_pc";
8139     case DW_AT_language:
8140       return "DW_AT_language";
8141     case DW_AT_member:
8142       return "DW_AT_member";
8143     case DW_AT_discr:
8144       return "DW_AT_discr";
8145     case DW_AT_discr_value:
8146       return "DW_AT_discr_value";
8147     case DW_AT_visibility:
8148       return "DW_AT_visibility";
8149     case DW_AT_import:
8150       return "DW_AT_import";
8151     case DW_AT_string_length:
8152       return "DW_AT_string_length";
8153     case DW_AT_common_reference:
8154       return "DW_AT_common_reference";
8155     case DW_AT_comp_dir:
8156       return "DW_AT_comp_dir";
8157     case DW_AT_const_value:
8158       return "DW_AT_const_value";
8159     case DW_AT_containing_type:
8160       return "DW_AT_containing_type";
8161     case DW_AT_default_value:
8162       return "DW_AT_default_value";
8163     case DW_AT_inline:
8164       return "DW_AT_inline";
8165     case DW_AT_is_optional:
8166       return "DW_AT_is_optional";
8167     case DW_AT_lower_bound:
8168       return "DW_AT_lower_bound";
8169     case DW_AT_producer:
8170       return "DW_AT_producer";
8171     case DW_AT_prototyped:
8172       return "DW_AT_prototyped";
8173     case DW_AT_return_addr:
8174       return "DW_AT_return_addr";
8175     case DW_AT_start_scope:
8176       return "DW_AT_start_scope";
8177     case DW_AT_bit_stride:
8178       return "DW_AT_bit_stride";
8179     case DW_AT_upper_bound:
8180       return "DW_AT_upper_bound";
8181     case DW_AT_abstract_origin:
8182       return "DW_AT_abstract_origin";
8183     case DW_AT_accessibility:
8184       return "DW_AT_accessibility";
8185     case DW_AT_address_class:
8186       return "DW_AT_address_class";
8187     case DW_AT_artificial:
8188       return "DW_AT_artificial";
8189     case DW_AT_base_types:
8190       return "DW_AT_base_types";
8191     case DW_AT_calling_convention:
8192       return "DW_AT_calling_convention";
8193     case DW_AT_count:
8194       return "DW_AT_count";
8195     case DW_AT_data_member_location:
8196       return "DW_AT_data_member_location";
8197     case DW_AT_decl_column:
8198       return "DW_AT_decl_column";
8199     case DW_AT_decl_file:
8200       return "DW_AT_decl_file";
8201     case DW_AT_decl_line:
8202       return "DW_AT_decl_line";
8203     case DW_AT_declaration:
8204       return "DW_AT_declaration";
8205     case DW_AT_discr_list:
8206       return "DW_AT_discr_list";
8207     case DW_AT_encoding:
8208       return "DW_AT_encoding";
8209     case DW_AT_external:
8210       return "DW_AT_external";
8211     case DW_AT_frame_base:
8212       return "DW_AT_frame_base";
8213     case DW_AT_friend:
8214       return "DW_AT_friend";
8215     case DW_AT_identifier_case:
8216       return "DW_AT_identifier_case";
8217     case DW_AT_macro_info:
8218       return "DW_AT_macro_info";
8219     case DW_AT_namelist_items:
8220       return "DW_AT_namelist_items";
8221     case DW_AT_priority:
8222       return "DW_AT_priority";
8223     case DW_AT_segment:
8224       return "DW_AT_segment";
8225     case DW_AT_specification:
8226       return "DW_AT_specification";
8227     case DW_AT_static_link:
8228       return "DW_AT_static_link";
8229     case DW_AT_type:
8230       return "DW_AT_type";
8231     case DW_AT_use_location:
8232       return "DW_AT_use_location";
8233     case DW_AT_variable_parameter:
8234       return "DW_AT_variable_parameter";
8235     case DW_AT_virtuality:
8236       return "DW_AT_virtuality";
8237     case DW_AT_vtable_elem_location:
8238       return "DW_AT_vtable_elem_location";
8239     /* DWARF 3 values.  */
8240     case DW_AT_allocated:
8241       return "DW_AT_allocated";
8242     case DW_AT_associated:
8243       return "DW_AT_associated";
8244     case DW_AT_data_location:
8245       return "DW_AT_data_location";
8246     case DW_AT_byte_stride:
8247       return "DW_AT_byte_stride";
8248     case DW_AT_entry_pc:
8249       return "DW_AT_entry_pc";
8250     case DW_AT_use_UTF8:
8251       return "DW_AT_use_UTF8";
8252     case DW_AT_extension:
8253       return "DW_AT_extension";
8254     case DW_AT_ranges:
8255       return "DW_AT_ranges";
8256     case DW_AT_trampoline:
8257       return "DW_AT_trampoline";
8258     case DW_AT_call_column:
8259       return "DW_AT_call_column";
8260     case DW_AT_call_file:
8261       return "DW_AT_call_file";
8262     case DW_AT_call_line:
8263       return "DW_AT_call_line";
8264     case DW_AT_description:
8265       return "DW_AT_description";
8266     case DW_AT_binary_scale:
8267       return "DW_AT_binary_scale";
8268     case DW_AT_decimal_scale:
8269       return "DW_AT_decimal_scale";
8270     case DW_AT_small:
8271       return "DW_AT_small";
8272     case DW_AT_decimal_sign:
8273       return "DW_AT_decimal_sign";
8274     case DW_AT_digit_count:
8275       return "DW_AT_digit_count";
8276     case DW_AT_picture_string:
8277       return "DW_AT_picture_string";
8278     case DW_AT_mutable:
8279       return "DW_AT_mutable";
8280     case DW_AT_threads_scaled:
8281       return "DW_AT_threads_scaled";
8282     case DW_AT_explicit:
8283       return "DW_AT_explicit";
8284     case DW_AT_object_pointer:
8285       return "DW_AT_object_pointer";
8286     case DW_AT_endianity:
8287       return "DW_AT_endianity";
8288     case DW_AT_elemental:
8289       return "DW_AT_elemental";
8290     case DW_AT_pure:
8291       return "DW_AT_pure";
8292     case DW_AT_recursive:
8293       return "DW_AT_recursive";
8294 #ifdef MIPS
8295     /* SGI/MIPS extensions.  */
8296     case DW_AT_MIPS_fde:
8297       return "DW_AT_MIPS_fde";
8298     case DW_AT_MIPS_loop_begin:
8299       return "DW_AT_MIPS_loop_begin";
8300     case DW_AT_MIPS_tail_loop_begin:
8301       return "DW_AT_MIPS_tail_loop_begin";
8302     case DW_AT_MIPS_epilog_begin:
8303       return "DW_AT_MIPS_epilog_begin";
8304     case DW_AT_MIPS_loop_unroll_factor:
8305       return "DW_AT_MIPS_loop_unroll_factor";
8306     case DW_AT_MIPS_software_pipeline_depth:
8307       return "DW_AT_MIPS_software_pipeline_depth";
8308     case DW_AT_MIPS_linkage_name:
8309       return "DW_AT_MIPS_linkage_name";
8310     case DW_AT_MIPS_stride:
8311       return "DW_AT_MIPS_stride";
8312     case DW_AT_MIPS_abstract_name:
8313       return "DW_AT_MIPS_abstract_name";
8314     case DW_AT_MIPS_clone_origin:
8315       return "DW_AT_MIPS_clone_origin";
8316     case DW_AT_MIPS_has_inlines:
8317       return "DW_AT_MIPS_has_inlines";
8318 #endif
8319     /* HP extensions.  */
8320     case DW_AT_HP_block_index:
8321       return "DW_AT_HP_block_index";
8322     case DW_AT_HP_unmodifiable:
8323       return "DW_AT_HP_unmodifiable";
8324     case DW_AT_HP_actuals_stmt_list:
8325       return "DW_AT_HP_actuals_stmt_list";
8326     case DW_AT_HP_proc_per_section:
8327       return "DW_AT_HP_proc_per_section";
8328     case DW_AT_HP_raw_data_ptr:
8329       return "DW_AT_HP_raw_data_ptr";
8330     case DW_AT_HP_pass_by_reference:
8331       return "DW_AT_HP_pass_by_reference";
8332     case DW_AT_HP_opt_level:
8333       return "DW_AT_HP_opt_level";
8334     case DW_AT_HP_prof_version_id:
8335       return "DW_AT_HP_prof_version_id";
8336     case DW_AT_HP_opt_flags:
8337       return "DW_AT_HP_opt_flags";
8338     case DW_AT_HP_cold_region_low_pc:
8339       return "DW_AT_HP_cold_region_low_pc";
8340     case DW_AT_HP_cold_region_high_pc:
8341       return "DW_AT_HP_cold_region_high_pc";
8342     case DW_AT_HP_all_variables_modifiable:
8343       return "DW_AT_HP_all_variables_modifiable";
8344     case DW_AT_HP_linkage_name:
8345       return "DW_AT_HP_linkage_name";
8346     case DW_AT_HP_prof_flags:
8347       return "DW_AT_HP_prof_flags";
8348     /* GNU extensions.  */
8349     case DW_AT_sf_names:
8350       return "DW_AT_sf_names";
8351     case DW_AT_src_info:
8352       return "DW_AT_src_info";
8353     case DW_AT_mac_info:
8354       return "DW_AT_mac_info";
8355     case DW_AT_src_coords:
8356       return "DW_AT_src_coords";
8357     case DW_AT_body_begin:
8358       return "DW_AT_body_begin";
8359     case DW_AT_body_end:
8360       return "DW_AT_body_end";
8361     case DW_AT_GNU_vector:
8362       return "DW_AT_GNU_vector";
8363     /* VMS extensions.  */
8364     case DW_AT_VMS_rtnbeg_pd_address:
8365       return "DW_AT_VMS_rtnbeg_pd_address";
8366     /* UPC extension.  */
8367     case DW_AT_upc_threads_scaled:
8368       return "DW_AT_upc_threads_scaled";
8369     /* PGI (STMicroelectronics) extensions.  */
8370     case DW_AT_PGI_lbase:
8371       return "DW_AT_PGI_lbase";
8372     case DW_AT_PGI_soffset:
8373       return "DW_AT_PGI_soffset";
8374     case DW_AT_PGI_lstride:
8375       return "DW_AT_PGI_lstride";
8376     default:
8377       return "DW_AT_<unknown>";
8378     }
8379 }
8380
8381 /* Convert a DWARF value form code into its string name.  */
8382
8383 static char *
8384 dwarf_form_name (unsigned form)
8385 {
8386   switch (form)
8387     {
8388     case DW_FORM_addr:
8389       return "DW_FORM_addr";
8390     case DW_FORM_block2:
8391       return "DW_FORM_block2";
8392     case DW_FORM_block4:
8393       return "DW_FORM_block4";
8394     case DW_FORM_data2:
8395       return "DW_FORM_data2";
8396     case DW_FORM_data4:
8397       return "DW_FORM_data4";
8398     case DW_FORM_data8:
8399       return "DW_FORM_data8";
8400     case DW_FORM_string:
8401       return "DW_FORM_string";
8402     case DW_FORM_block:
8403       return "DW_FORM_block";
8404     case DW_FORM_block1:
8405       return "DW_FORM_block1";
8406     case DW_FORM_data1:
8407       return "DW_FORM_data1";
8408     case DW_FORM_flag:
8409       return "DW_FORM_flag";
8410     case DW_FORM_sdata:
8411       return "DW_FORM_sdata";
8412     case DW_FORM_strp:
8413       return "DW_FORM_strp";
8414     case DW_FORM_udata:
8415       return "DW_FORM_udata";
8416     case DW_FORM_ref_addr:
8417       return "DW_FORM_ref_addr";
8418     case DW_FORM_ref1:
8419       return "DW_FORM_ref1";
8420     case DW_FORM_ref2:
8421       return "DW_FORM_ref2";
8422     case DW_FORM_ref4:
8423       return "DW_FORM_ref4";
8424     case DW_FORM_ref8:
8425       return "DW_FORM_ref8";
8426     case DW_FORM_ref_udata:
8427       return "DW_FORM_ref_udata";
8428     case DW_FORM_indirect:
8429       return "DW_FORM_indirect";
8430     default:
8431       return "DW_FORM_<unknown>";
8432     }
8433 }
8434
8435 /* Convert a DWARF stack opcode into its string name.  */
8436
8437 static char *
8438 dwarf_stack_op_name (unsigned op)
8439 {
8440   switch (op)
8441     {
8442     case DW_OP_addr:
8443       return "DW_OP_addr";
8444     case DW_OP_deref:
8445       return "DW_OP_deref";
8446     case DW_OP_const1u:
8447       return "DW_OP_const1u";
8448     case DW_OP_const1s:
8449       return "DW_OP_const1s";
8450     case DW_OP_const2u:
8451       return "DW_OP_const2u";
8452     case DW_OP_const2s:
8453       return "DW_OP_const2s";
8454     case DW_OP_const4u:
8455       return "DW_OP_const4u";
8456     case DW_OP_const4s:
8457       return "DW_OP_const4s";
8458     case DW_OP_const8u:
8459       return "DW_OP_const8u";
8460     case DW_OP_const8s:
8461       return "DW_OP_const8s";
8462     case DW_OP_constu:
8463       return "DW_OP_constu";
8464     case DW_OP_consts:
8465       return "DW_OP_consts";
8466     case DW_OP_dup:
8467       return "DW_OP_dup";
8468     case DW_OP_drop:
8469       return "DW_OP_drop";
8470     case DW_OP_over:
8471       return "DW_OP_over";
8472     case DW_OP_pick:
8473       return "DW_OP_pick";
8474     case DW_OP_swap:
8475       return "DW_OP_swap";
8476     case DW_OP_rot:
8477       return "DW_OP_rot";
8478     case DW_OP_xderef:
8479       return "DW_OP_xderef";
8480     case DW_OP_abs:
8481       return "DW_OP_abs";
8482     case DW_OP_and:
8483       return "DW_OP_and";
8484     case DW_OP_div:
8485       return "DW_OP_div";
8486     case DW_OP_minus:
8487       return "DW_OP_minus";
8488     case DW_OP_mod:
8489       return "DW_OP_mod";
8490     case DW_OP_mul:
8491       return "DW_OP_mul";
8492     case DW_OP_neg:
8493       return "DW_OP_neg";
8494     case DW_OP_not:
8495       return "DW_OP_not";
8496     case DW_OP_or:
8497       return "DW_OP_or";
8498     case DW_OP_plus:
8499       return "DW_OP_plus";
8500     case DW_OP_plus_uconst:
8501       return "DW_OP_plus_uconst";
8502     case DW_OP_shl:
8503       return "DW_OP_shl";
8504     case DW_OP_shr:
8505       return "DW_OP_shr";
8506     case DW_OP_shra:
8507       return "DW_OP_shra";
8508     case DW_OP_xor:
8509       return "DW_OP_xor";
8510     case DW_OP_bra:
8511       return "DW_OP_bra";
8512     case DW_OP_eq:
8513       return "DW_OP_eq";
8514     case DW_OP_ge:
8515       return "DW_OP_ge";
8516     case DW_OP_gt:
8517       return "DW_OP_gt";
8518     case DW_OP_le:
8519       return "DW_OP_le";
8520     case DW_OP_lt:
8521       return "DW_OP_lt";
8522     case DW_OP_ne:
8523       return "DW_OP_ne";
8524     case DW_OP_skip:
8525       return "DW_OP_skip";
8526     case DW_OP_lit0:
8527       return "DW_OP_lit0";
8528     case DW_OP_lit1:
8529       return "DW_OP_lit1";
8530     case DW_OP_lit2:
8531       return "DW_OP_lit2";
8532     case DW_OP_lit3:
8533       return "DW_OP_lit3";
8534     case DW_OP_lit4:
8535       return "DW_OP_lit4";
8536     case DW_OP_lit5:
8537       return "DW_OP_lit5";
8538     case DW_OP_lit6:
8539       return "DW_OP_lit6";
8540     case DW_OP_lit7:
8541       return "DW_OP_lit7";
8542     case DW_OP_lit8:
8543       return "DW_OP_lit8";
8544     case DW_OP_lit9:
8545       return "DW_OP_lit9";
8546     case DW_OP_lit10:
8547       return "DW_OP_lit10";
8548     case DW_OP_lit11:
8549       return "DW_OP_lit11";
8550     case DW_OP_lit12:
8551       return "DW_OP_lit12";
8552     case DW_OP_lit13:
8553       return "DW_OP_lit13";
8554     case DW_OP_lit14:
8555       return "DW_OP_lit14";
8556     case DW_OP_lit15:
8557       return "DW_OP_lit15";
8558     case DW_OP_lit16:
8559       return "DW_OP_lit16";
8560     case DW_OP_lit17:
8561       return "DW_OP_lit17";
8562     case DW_OP_lit18:
8563       return "DW_OP_lit18";
8564     case DW_OP_lit19:
8565       return "DW_OP_lit19";
8566     case DW_OP_lit20:
8567       return "DW_OP_lit20";
8568     case DW_OP_lit21:
8569       return "DW_OP_lit21";
8570     case DW_OP_lit22:
8571       return "DW_OP_lit22";
8572     case DW_OP_lit23:
8573       return "DW_OP_lit23";
8574     case DW_OP_lit24:
8575       return "DW_OP_lit24";
8576     case DW_OP_lit25:
8577       return "DW_OP_lit25";
8578     case DW_OP_lit26:
8579       return "DW_OP_lit26";
8580     case DW_OP_lit27:
8581       return "DW_OP_lit27";
8582     case DW_OP_lit28:
8583       return "DW_OP_lit28";
8584     case DW_OP_lit29:
8585       return "DW_OP_lit29";
8586     case DW_OP_lit30:
8587       return "DW_OP_lit30";
8588     case DW_OP_lit31:
8589       return "DW_OP_lit31";
8590     case DW_OP_reg0:
8591       return "DW_OP_reg0";
8592     case DW_OP_reg1:
8593       return "DW_OP_reg1";
8594     case DW_OP_reg2:
8595       return "DW_OP_reg2";
8596     case DW_OP_reg3:
8597       return "DW_OP_reg3";
8598     case DW_OP_reg4:
8599       return "DW_OP_reg4";
8600     case DW_OP_reg5:
8601       return "DW_OP_reg5";
8602     case DW_OP_reg6:
8603       return "DW_OP_reg6";
8604     case DW_OP_reg7:
8605       return "DW_OP_reg7";
8606     case DW_OP_reg8:
8607       return "DW_OP_reg8";
8608     case DW_OP_reg9:
8609       return "DW_OP_reg9";
8610     case DW_OP_reg10:
8611       return "DW_OP_reg10";
8612     case DW_OP_reg11:
8613       return "DW_OP_reg11";
8614     case DW_OP_reg12:
8615       return "DW_OP_reg12";
8616     case DW_OP_reg13:
8617       return "DW_OP_reg13";
8618     case DW_OP_reg14:
8619       return "DW_OP_reg14";
8620     case DW_OP_reg15:
8621       return "DW_OP_reg15";
8622     case DW_OP_reg16:
8623       return "DW_OP_reg16";
8624     case DW_OP_reg17:
8625       return "DW_OP_reg17";
8626     case DW_OP_reg18:
8627       return "DW_OP_reg18";
8628     case DW_OP_reg19:
8629       return "DW_OP_reg19";
8630     case DW_OP_reg20:
8631       return "DW_OP_reg20";
8632     case DW_OP_reg21:
8633       return "DW_OP_reg21";
8634     case DW_OP_reg22:
8635       return "DW_OP_reg22";
8636     case DW_OP_reg23:
8637       return "DW_OP_reg23";
8638     case DW_OP_reg24:
8639       return "DW_OP_reg24";
8640     case DW_OP_reg25:
8641       return "DW_OP_reg25";
8642     case DW_OP_reg26:
8643       return "DW_OP_reg26";
8644     case DW_OP_reg27:
8645       return "DW_OP_reg27";
8646     case DW_OP_reg28:
8647       return "DW_OP_reg28";
8648     case DW_OP_reg29:
8649       return "DW_OP_reg29";
8650     case DW_OP_reg30:
8651       return "DW_OP_reg30";
8652     case DW_OP_reg31:
8653       return "DW_OP_reg31";
8654     case DW_OP_breg0:
8655       return "DW_OP_breg0";
8656     case DW_OP_breg1:
8657       return "DW_OP_breg1";
8658     case DW_OP_breg2:
8659       return "DW_OP_breg2";
8660     case DW_OP_breg3:
8661       return "DW_OP_breg3";
8662     case DW_OP_breg4:
8663       return "DW_OP_breg4";
8664     case DW_OP_breg5:
8665       return "DW_OP_breg5";
8666     case DW_OP_breg6:
8667       return "DW_OP_breg6";
8668     case DW_OP_breg7:
8669       return "DW_OP_breg7";
8670     case DW_OP_breg8:
8671       return "DW_OP_breg8";
8672     case DW_OP_breg9:
8673       return "DW_OP_breg9";
8674     case DW_OP_breg10:
8675       return "DW_OP_breg10";
8676     case DW_OP_breg11:
8677       return "DW_OP_breg11";
8678     case DW_OP_breg12:
8679       return "DW_OP_breg12";
8680     case DW_OP_breg13:
8681       return "DW_OP_breg13";
8682     case DW_OP_breg14:
8683       return "DW_OP_breg14";
8684     case DW_OP_breg15:
8685       return "DW_OP_breg15";
8686     case DW_OP_breg16:
8687       return "DW_OP_breg16";
8688     case DW_OP_breg17:
8689       return "DW_OP_breg17";
8690     case DW_OP_breg18:
8691       return "DW_OP_breg18";
8692     case DW_OP_breg19:
8693       return "DW_OP_breg19";
8694     case DW_OP_breg20:
8695       return "DW_OP_breg20";
8696     case DW_OP_breg21:
8697       return "DW_OP_breg21";
8698     case DW_OP_breg22:
8699       return "DW_OP_breg22";
8700     case DW_OP_breg23:
8701       return "DW_OP_breg23";
8702     case DW_OP_breg24:
8703       return "DW_OP_breg24";
8704     case DW_OP_breg25:
8705       return "DW_OP_breg25";
8706     case DW_OP_breg26:
8707       return "DW_OP_breg26";
8708     case DW_OP_breg27:
8709       return "DW_OP_breg27";
8710     case DW_OP_breg28:
8711       return "DW_OP_breg28";
8712     case DW_OP_breg29:
8713       return "DW_OP_breg29";
8714     case DW_OP_breg30:
8715       return "DW_OP_breg30";
8716     case DW_OP_breg31:
8717       return "DW_OP_breg31";
8718     case DW_OP_regx:
8719       return "DW_OP_regx";
8720     case DW_OP_fbreg:
8721       return "DW_OP_fbreg";
8722     case DW_OP_bregx:
8723       return "DW_OP_bregx";
8724     case DW_OP_piece:
8725       return "DW_OP_piece";
8726     case DW_OP_deref_size:
8727       return "DW_OP_deref_size";
8728     case DW_OP_xderef_size:
8729       return "DW_OP_xderef_size";
8730     case DW_OP_nop:
8731       return "DW_OP_nop";
8732     /* DWARF 3 extensions.  */
8733     case DW_OP_push_object_address:
8734       return "DW_OP_push_object_address";
8735     case DW_OP_call2:
8736       return "DW_OP_call2";
8737     case DW_OP_call4:
8738       return "DW_OP_call4";
8739     case DW_OP_call_ref:
8740       return "DW_OP_call_ref";
8741     /* GNU extensions.  */
8742     case DW_OP_form_tls_address:
8743       return "DW_OP_form_tls_address";
8744     case DW_OP_call_frame_cfa:
8745       return "DW_OP_call_frame_cfa";
8746     case DW_OP_bit_piece:
8747       return "DW_OP_bit_piece";
8748     case DW_OP_GNU_push_tls_address:
8749       return "DW_OP_GNU_push_tls_address";
8750     case DW_OP_GNU_uninit:
8751       return "DW_OP_GNU_uninit";
8752     /* HP extensions. */
8753     case DW_OP_HP_is_value:
8754       return "DW_OP_HP_is_value";
8755     case DW_OP_HP_fltconst4:
8756       return "DW_OP_HP_fltconst4";
8757     case DW_OP_HP_fltconst8:
8758       return "DW_OP_HP_fltconst8";
8759     case DW_OP_HP_mod_range:
8760       return "DW_OP_HP_mod_range";
8761     case DW_OP_HP_unmod_range:
8762       return "DW_OP_HP_unmod_range";
8763     case DW_OP_HP_tls:
8764       return "DW_OP_HP_tls";
8765     default:
8766       return "OP_<unknown>";
8767     }
8768 }
8769
8770 static char *
8771 dwarf_bool_name (unsigned mybool)
8772 {
8773   if (mybool)
8774     return "TRUE";
8775   else
8776     return "FALSE";
8777 }
8778
8779 /* Convert a DWARF type code into its string name.  */
8780
8781 static char *
8782 dwarf_type_encoding_name (unsigned enc)
8783 {
8784   switch (enc)
8785     {
8786     case DW_ATE_void:
8787       return "DW_ATE_void";
8788     case DW_ATE_address:
8789       return "DW_ATE_address";
8790     case DW_ATE_boolean:
8791       return "DW_ATE_boolean";
8792     case DW_ATE_complex_float:
8793       return "DW_ATE_complex_float";
8794     case DW_ATE_float:
8795       return "DW_ATE_float";
8796     case DW_ATE_signed:
8797       return "DW_ATE_signed";
8798     case DW_ATE_signed_char:
8799       return "DW_ATE_signed_char";
8800     case DW_ATE_unsigned:
8801       return "DW_ATE_unsigned";
8802     case DW_ATE_unsigned_char:
8803       return "DW_ATE_unsigned_char";
8804     /* DWARF 3.  */
8805     case DW_ATE_imaginary_float:
8806       return "DW_ATE_imaginary_float";
8807     case DW_ATE_packed_decimal:
8808       return "DW_ATE_packed_decimal";
8809     case DW_ATE_numeric_string:
8810       return "DW_ATE_numeric_string";
8811     case DW_ATE_edited:
8812       return "DW_ATE_edited";
8813     case DW_ATE_signed_fixed:
8814       return "DW_ATE_signed_fixed";
8815     case DW_ATE_unsigned_fixed:
8816       return "DW_ATE_unsigned_fixed";
8817     case DW_ATE_decimal_float:
8818       return "DW_ATE_decimal_float";
8819     /* HP extensions.  */
8820     case DW_ATE_HP_float80:
8821       return "DW_ATE_HP_float80";
8822     case DW_ATE_HP_complex_float80:
8823       return "DW_ATE_HP_complex_float80";
8824     case DW_ATE_HP_float128:
8825       return "DW_ATE_HP_float128";
8826     case DW_ATE_HP_complex_float128:
8827       return "DW_ATE_HP_complex_float128";
8828     case DW_ATE_HP_floathpintel:
8829       return "DW_ATE_HP_floathpintel";
8830     case DW_ATE_HP_imaginary_float80:
8831       return "DW_ATE_HP_imaginary_float80";
8832     case DW_ATE_HP_imaginary_float128:
8833       return "DW_ATE_HP_imaginary_float128";
8834     default:
8835       return "DW_ATE_<unknown>";
8836     }
8837 }
8838
8839 /* Convert a DWARF call frame info operation to its string name. */
8840
8841 #if 0
8842 static char *
8843 dwarf_cfi_name (unsigned cfi_opc)
8844 {
8845   switch (cfi_opc)
8846     {
8847     case DW_CFA_advance_loc:
8848       return "DW_CFA_advance_loc";
8849     case DW_CFA_offset:
8850       return "DW_CFA_offset";
8851     case DW_CFA_restore:
8852       return "DW_CFA_restore";
8853     case DW_CFA_nop:
8854       return "DW_CFA_nop";
8855     case DW_CFA_set_loc:
8856       return "DW_CFA_set_loc";
8857     case DW_CFA_advance_loc1:
8858       return "DW_CFA_advance_loc1";
8859     case DW_CFA_advance_loc2:
8860       return "DW_CFA_advance_loc2";
8861     case DW_CFA_advance_loc4:
8862       return "DW_CFA_advance_loc4";
8863     case DW_CFA_offset_extended:
8864       return "DW_CFA_offset_extended";
8865     case DW_CFA_restore_extended:
8866       return "DW_CFA_restore_extended";
8867     case DW_CFA_undefined:
8868       return "DW_CFA_undefined";
8869     case DW_CFA_same_value:
8870       return "DW_CFA_same_value";
8871     case DW_CFA_register:
8872       return "DW_CFA_register";
8873     case DW_CFA_remember_state:
8874       return "DW_CFA_remember_state";
8875     case DW_CFA_restore_state:
8876       return "DW_CFA_restore_state";
8877     case DW_CFA_def_cfa:
8878       return "DW_CFA_def_cfa";
8879     case DW_CFA_def_cfa_register:
8880       return "DW_CFA_def_cfa_register";
8881     case DW_CFA_def_cfa_offset:
8882       return "DW_CFA_def_cfa_offset";
8883     /* DWARF 3.  */
8884     case DW_CFA_def_cfa_expression:
8885       return "DW_CFA_def_cfa_expression";
8886     case DW_CFA_expression:
8887       return "DW_CFA_expression";
8888     case DW_CFA_offset_extended_sf:
8889       return "DW_CFA_offset_extended_sf";
8890     case DW_CFA_def_cfa_sf:
8891       return "DW_CFA_def_cfa_sf";
8892     case DW_CFA_def_cfa_offset_sf:
8893       return "DW_CFA_def_cfa_offset_sf";
8894     case DW_CFA_val_offset:
8895       return "DW_CFA_val_offset";
8896     case DW_CFA_val_offset_sf:
8897       return "DW_CFA_val_offset_sf";
8898     case DW_CFA_val_expression:
8899       return "DW_CFA_val_expression";
8900     /* SGI/MIPS specific.  */
8901     case DW_CFA_MIPS_advance_loc8:
8902       return "DW_CFA_MIPS_advance_loc8";
8903     /* GNU extensions.  */
8904     case DW_CFA_GNU_window_save:
8905       return "DW_CFA_GNU_window_save";
8906     case DW_CFA_GNU_args_size:
8907       return "DW_CFA_GNU_args_size";
8908     case DW_CFA_GNU_negative_offset_extended:
8909       return "DW_CFA_GNU_negative_offset_extended";
8910     default:
8911       return "DW_CFA_<unknown>";
8912     }
8913 }
8914 #endif
8915
8916 static void
8917 dump_die (struct die_info *die)
8918 {
8919   unsigned int i;
8920
8921   fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
8922            dwarf_tag_name (die->tag), die->abbrev, die->offset);
8923   fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
8924            dwarf_bool_name (die->child != NULL));
8925
8926   fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
8927   for (i = 0; i < die->num_attrs; ++i)
8928     {
8929       fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
8930                dwarf_attr_name (die->attrs[i].name),
8931                dwarf_form_name (die->attrs[i].form));
8932       switch (die->attrs[i].form)
8933         {
8934         case DW_FORM_ref_addr:
8935         case DW_FORM_addr:
8936           fprintf_unfiltered (gdb_stderr, "address: ");
8937           fputs_filtered (paddress (DW_ADDR (&die->attrs[i])), gdb_stderr);
8938           break;
8939         case DW_FORM_block2:
8940         case DW_FORM_block4:
8941         case DW_FORM_block:
8942         case DW_FORM_block1:
8943           fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
8944           break;
8945         case DW_FORM_ref1:
8946         case DW_FORM_ref2:
8947         case DW_FORM_ref4:
8948           fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)",
8949                               (long) (DW_ADDR (&die->attrs[i])));
8950           break;
8951         case DW_FORM_data1:
8952         case DW_FORM_data2:
8953         case DW_FORM_data4:
8954         case DW_FORM_data8:
8955         case DW_FORM_udata:
8956         case DW_FORM_sdata:
8957           fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
8958           break;
8959         case DW_FORM_string:
8960         case DW_FORM_strp:
8961           fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
8962                    DW_STRING (&die->attrs[i])
8963                    ? DW_STRING (&die->attrs[i]) : "");
8964           break;
8965         case DW_FORM_flag:
8966           if (DW_UNSND (&die->attrs[i]))
8967             fprintf_unfiltered (gdb_stderr, "flag: TRUE");
8968           else
8969             fprintf_unfiltered (gdb_stderr, "flag: FALSE");
8970           break;
8971         case DW_FORM_indirect:
8972           /* the reader will have reduced the indirect form to
8973              the "base form" so this form should not occur */
8974           fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
8975           break;
8976         default:
8977           fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
8978                    die->attrs[i].form);
8979         }
8980       fprintf_unfiltered (gdb_stderr, "\n");
8981     }
8982 }
8983
8984 static void
8985 dump_die_list (struct die_info *die)
8986 {
8987   while (die)
8988     {
8989       dump_die (die);
8990       if (die->child != NULL)
8991         dump_die_list (die->child);
8992       if (die->sibling != NULL)
8993         dump_die_list (die->sibling);
8994     }
8995 }
8996
8997 static void
8998 store_in_ref_table (unsigned int offset, struct die_info *die,
8999                     struct dwarf2_cu *cu)
9000 {
9001   int h;
9002   struct die_info *old;
9003
9004   h = (offset % REF_HASH_SIZE);
9005   old = cu->die_ref_table[h];
9006   die->next_ref = old;
9007   cu->die_ref_table[h] = die;
9008 }
9009
9010 static unsigned int
9011 dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
9012 {
9013   unsigned int result = 0;
9014
9015   switch (attr->form)
9016     {
9017     case DW_FORM_ref_addr:
9018     case DW_FORM_ref1:
9019     case DW_FORM_ref2:
9020     case DW_FORM_ref4:
9021     case DW_FORM_ref8:
9022     case DW_FORM_ref_udata:
9023       result = DW_ADDR (attr);
9024       break;
9025     default:
9026       complaint (&symfile_complaints,
9027                  _("unsupported die ref attribute form: '%s'"),
9028                  dwarf_form_name (attr->form));
9029     }
9030   return result;
9031 }
9032
9033 /* Return the constant value held by the given attribute.  Return -1
9034    if the value held by the attribute is not constant.  */
9035
9036 static int
9037 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
9038 {
9039   if (attr->form == DW_FORM_sdata)
9040     return DW_SND (attr);
9041   else if (attr->form == DW_FORM_udata
9042            || attr->form == DW_FORM_data1
9043            || attr->form == DW_FORM_data2
9044            || attr->form == DW_FORM_data4
9045            || attr->form == DW_FORM_data8)
9046     return DW_UNSND (attr);
9047   else
9048     {
9049       complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
9050                  dwarf_form_name (attr->form));
9051       return default_value;
9052     }
9053 }
9054
9055 static struct die_info *
9056 follow_die_ref (struct die_info *src_die, struct attribute *attr,
9057                 struct dwarf2_cu *cu)
9058 {
9059   struct die_info *die;
9060   unsigned int offset;
9061   int h;
9062   struct die_info temp_die;
9063   struct dwarf2_cu *target_cu;
9064
9065   offset = dwarf2_get_ref_die_offset (attr, cu);
9066
9067   if (DW_ADDR (attr) < cu->header.offset
9068       || DW_ADDR (attr) >= cu->header.offset + cu->header.length)
9069     {
9070       struct dwarf2_per_cu_data *per_cu;
9071       per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr),
9072                                                  cu->objfile);
9073       target_cu = per_cu->cu;
9074     }
9075   else
9076     target_cu = cu;
9077
9078   h = (offset % REF_HASH_SIZE);
9079   die = target_cu->die_ref_table[h];
9080   while (die)
9081     {
9082       if (die->offset == offset)
9083         return die;
9084       die = die->next_ref;
9085     }
9086
9087   error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
9088          "at 0x%lx [in module %s]"),
9089          (long) src_die->offset, (long) offset, cu->objfile->name);
9090
9091   return NULL;
9092 }
9093
9094 /* Decode simple location descriptions.
9095    Given a pointer to a dwarf block that defines a location, compute
9096    the location and return the value.
9097
9098    NOTE drow/2003-11-18: This function is called in two situations
9099    now: for the address of static or global variables (partial symbols
9100    only) and for offsets into structures which are expected to be
9101    (more or less) constant.  The partial symbol case should go away,
9102    and only the constant case should remain.  That will let this
9103    function complain more accurately.  A few special modes are allowed
9104    without complaint for global variables (for instance, global
9105    register values and thread-local values).
9106
9107    A location description containing no operations indicates that the
9108    object is optimized out.  The return value is 0 for that case.
9109    FIXME drow/2003-11-16: No callers check for this case any more; soon all
9110    callers will only want a very basic result and this can become a
9111    complaint.
9112
9113    Note that stack[0] is unused except as a default error return.
9114    Note that stack overflow is not yet handled.  */
9115
9116 static CORE_ADDR
9117 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
9118 {
9119   struct objfile *objfile = cu->objfile;
9120   struct comp_unit_head *cu_header = &cu->header;
9121   int i;
9122   int size = blk->size;
9123   gdb_byte *data = blk->data;
9124   CORE_ADDR stack[64];
9125   int stacki;
9126   unsigned int bytes_read, unsnd;
9127   gdb_byte op;
9128
9129   i = 0;
9130   stacki = 0;
9131   stack[stacki] = 0;
9132
9133   while (i < size)
9134     {
9135       op = data[i++];
9136       switch (op)
9137         {
9138         case DW_OP_lit0:
9139         case DW_OP_lit1:
9140         case DW_OP_lit2:
9141         case DW_OP_lit3:
9142         case DW_OP_lit4:
9143         case DW_OP_lit5:
9144         case DW_OP_lit6:
9145         case DW_OP_lit7:
9146         case DW_OP_lit8:
9147         case DW_OP_lit9:
9148         case DW_OP_lit10:
9149         case DW_OP_lit11:
9150         case DW_OP_lit12:
9151         case DW_OP_lit13:
9152         case DW_OP_lit14:
9153         case DW_OP_lit15:
9154         case DW_OP_lit16:
9155         case DW_OP_lit17:
9156         case DW_OP_lit18:
9157         case DW_OP_lit19:
9158         case DW_OP_lit20:
9159         case DW_OP_lit21:
9160         case DW_OP_lit22:
9161         case DW_OP_lit23:
9162         case DW_OP_lit24:
9163         case DW_OP_lit25:
9164         case DW_OP_lit26:
9165         case DW_OP_lit27:
9166         case DW_OP_lit28:
9167         case DW_OP_lit29:
9168         case DW_OP_lit30:
9169         case DW_OP_lit31:
9170           stack[++stacki] = op - DW_OP_lit0;
9171           break;
9172
9173         case DW_OP_reg0:
9174         case DW_OP_reg1:
9175         case DW_OP_reg2:
9176         case DW_OP_reg3:
9177         case DW_OP_reg4:
9178         case DW_OP_reg5:
9179         case DW_OP_reg6:
9180         case DW_OP_reg7:
9181         case DW_OP_reg8:
9182         case DW_OP_reg9:
9183         case DW_OP_reg10:
9184         case DW_OP_reg11:
9185         case DW_OP_reg12:
9186         case DW_OP_reg13:
9187         case DW_OP_reg14:
9188         case DW_OP_reg15:
9189         case DW_OP_reg16:
9190         case DW_OP_reg17:
9191         case DW_OP_reg18:
9192         case DW_OP_reg19:
9193         case DW_OP_reg20:
9194         case DW_OP_reg21:
9195         case DW_OP_reg22:
9196         case DW_OP_reg23:
9197         case DW_OP_reg24:
9198         case DW_OP_reg25:
9199         case DW_OP_reg26:
9200         case DW_OP_reg27:
9201         case DW_OP_reg28:
9202         case DW_OP_reg29:
9203         case DW_OP_reg30:
9204         case DW_OP_reg31:
9205           stack[++stacki] = op - DW_OP_reg0;
9206           if (i < size)
9207             dwarf2_complex_location_expr_complaint ();
9208           break;
9209
9210         case DW_OP_regx:
9211           unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
9212           i += bytes_read;
9213           stack[++stacki] = unsnd;
9214           if (i < size)
9215             dwarf2_complex_location_expr_complaint ();
9216           break;
9217
9218         case DW_OP_addr:
9219           stack[++stacki] = read_address (objfile->obfd, &data[i],
9220                                           cu, &bytes_read);
9221           i += bytes_read;
9222           break;
9223
9224         case DW_OP_const1u:
9225           stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
9226           i += 1;
9227           break;
9228
9229         case DW_OP_const1s:
9230           stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
9231           i += 1;
9232           break;
9233
9234         case DW_OP_const2u:
9235           stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
9236           i += 2;
9237           break;
9238
9239         case DW_OP_const2s:
9240           stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
9241           i += 2;
9242           break;
9243
9244         case DW_OP_const4u:
9245           stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
9246           i += 4;
9247           break;
9248
9249         case DW_OP_const4s:
9250           stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
9251           i += 4;
9252           break;
9253
9254         case DW_OP_constu:
9255           stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
9256                                                   &bytes_read);
9257           i += bytes_read;
9258           break;
9259
9260         case DW_OP_consts:
9261           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
9262           i += bytes_read;
9263           break;
9264
9265         case DW_OP_dup:
9266           stack[stacki + 1] = stack[stacki];
9267           stacki++;
9268           break;
9269
9270         case DW_OP_plus:
9271           stack[stacki - 1] += stack[stacki];
9272           stacki--;
9273           break;
9274
9275         case DW_OP_plus_uconst:
9276           stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
9277           i += bytes_read;
9278           break;
9279
9280         case DW_OP_minus:
9281           stack[stacki - 1] -= stack[stacki];
9282           stacki--;
9283           break;
9284
9285         case DW_OP_deref:
9286           /* If we're not the last op, then we definitely can't encode
9287              this using GDB's address_class enum.  This is valid for partial
9288              global symbols, although the variable's address will be bogus
9289              in the psymtab.  */
9290           if (i < size)
9291             dwarf2_complex_location_expr_complaint ();
9292           break;
9293
9294         case DW_OP_GNU_push_tls_address:
9295           /* The top of the stack has the offset from the beginning
9296              of the thread control block at which the variable is located.  */
9297           /* Nothing should follow this operator, so the top of stack would
9298              be returned.  */
9299           /* This is valid for partial global symbols, but the variable's
9300              address will be bogus in the psymtab.  */
9301           if (i < size)
9302             dwarf2_complex_location_expr_complaint ();
9303           break;
9304
9305         case DW_OP_GNU_uninit:
9306           break;
9307
9308         default:
9309           complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
9310                      dwarf_stack_op_name (op));
9311           return (stack[stacki]);
9312         }
9313     }
9314   return (stack[stacki]);
9315 }
9316
9317 /* memory allocation interface */
9318
9319 static struct dwarf_block *
9320 dwarf_alloc_block (struct dwarf2_cu *cu)
9321 {
9322   struct dwarf_block *blk;
9323
9324   blk = (struct dwarf_block *)
9325     obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
9326   return (blk);
9327 }
9328
9329 static struct abbrev_info *
9330 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
9331 {
9332   struct abbrev_info *abbrev;
9333
9334   abbrev = (struct abbrev_info *)
9335     obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
9336   memset (abbrev, 0, sizeof (struct abbrev_info));
9337   return (abbrev);
9338 }
9339
9340 static struct die_info *
9341 dwarf_alloc_die (void)
9342 {
9343   struct die_info *die;
9344
9345   die = (struct die_info *) xmalloc (sizeof (struct die_info));
9346   memset (die, 0, sizeof (struct die_info));
9347   return (die);
9348 }
9349
9350 \f
9351 /* Macro support.  */
9352
9353
9354 /* Return the full name of file number I in *LH's file name table.
9355    Use COMP_DIR as the name of the current directory of the
9356    compilation.  The result is allocated using xmalloc; the caller is
9357    responsible for freeing it.  */
9358 static char *
9359 file_full_name (int file, struct line_header *lh, const char *comp_dir)
9360 {
9361   /* Is the file number a valid index into the line header's file name
9362      table?  Remember that file numbers start with one, not zero.  */
9363   if (1 <= file && file <= lh->num_file_names)
9364     {
9365       struct file_entry *fe = &lh->file_names[file - 1];
9366
9367       if (IS_ABSOLUTE_PATH (fe->name))
9368         return xstrdup (fe->name);
9369       else
9370         {
9371           const char *dir;
9372           int dir_len;
9373           char *full_name;
9374
9375           if (fe->dir_index)
9376             dir = lh->include_dirs[fe->dir_index - 1];
9377           else
9378             dir = comp_dir;
9379
9380           if (dir)
9381             {
9382               dir_len = strlen (dir);
9383               full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
9384               strcpy (full_name, dir);
9385               full_name[dir_len] = '/';
9386               strcpy (full_name + dir_len + 1, fe->name);
9387               return full_name;
9388             }
9389           else
9390             return xstrdup (fe->name);
9391         }
9392     }
9393   else
9394     {
9395       /* The compiler produced a bogus file number.  We can at least
9396          record the macro definitions made in the file, even if we
9397          won't be able to find the file by name.  */
9398       char fake_name[80];
9399       sprintf (fake_name, "<bad macro file number %d>", file);
9400
9401       complaint (&symfile_complaints,
9402                  _("bad file number in macro information (%d)"),
9403                  file);
9404
9405       return xstrdup (fake_name);
9406     }
9407 }
9408
9409
9410 static struct macro_source_file *
9411 macro_start_file (int file, int line,
9412                   struct macro_source_file *current_file,
9413                   const char *comp_dir,
9414                   struct line_header *lh, struct objfile *objfile)
9415 {
9416   /* The full name of this source file.  */
9417   char *full_name = file_full_name (file, lh, comp_dir);
9418
9419   /* We don't create a macro table for this compilation unit
9420      at all until we actually get a filename.  */
9421   if (! pending_macros)
9422     pending_macros = new_macro_table (&objfile->objfile_obstack,
9423                                       objfile->macro_cache);
9424
9425   if (! current_file)
9426     /* If we have no current file, then this must be the start_file
9427        directive for the compilation unit's main source file.  */
9428     current_file = macro_set_main (pending_macros, full_name);
9429   else
9430     current_file = macro_include (current_file, line, full_name);
9431
9432   xfree (full_name);
9433
9434   return current_file;
9435 }
9436
9437
9438 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9439    followed by a null byte.  */
9440 static char *
9441 copy_string (const char *buf, int len)
9442 {
9443   char *s = xmalloc (len + 1);
9444   memcpy (s, buf, len);
9445   s[len] = '\0';
9446
9447   return s;
9448 }
9449
9450
9451 static const char *
9452 consume_improper_spaces (const char *p, const char *body)
9453 {
9454   if (*p == ' ')
9455     {
9456       complaint (&symfile_complaints,
9457                  _("macro definition contains spaces in formal argument list:\n`%s'"),
9458                  body);
9459
9460       while (*p == ' ')
9461         p++;
9462     }
9463
9464   return p;
9465 }
9466
9467
9468 static void
9469 parse_macro_definition (struct macro_source_file *file, int line,
9470                         const char *body)
9471 {
9472   const char *p;
9473
9474   /* The body string takes one of two forms.  For object-like macro
9475      definitions, it should be:
9476
9477         <macro name> " " <definition>
9478
9479      For function-like macro definitions, it should be:
9480
9481         <macro name> "() " <definition>
9482      or
9483         <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9484
9485      Spaces may appear only where explicitly indicated, and in the
9486      <definition>.
9487
9488      The Dwarf 2 spec says that an object-like macro's name is always
9489      followed by a space, but versions of GCC around March 2002 omit
9490      the space when the macro's definition is the empty string.
9491
9492      The Dwarf 2 spec says that there should be no spaces between the
9493      formal arguments in a function-like macro's formal argument list,
9494      but versions of GCC around March 2002 include spaces after the
9495      commas.  */
9496
9497
9498   /* Find the extent of the macro name.  The macro name is terminated
9499      by either a space or null character (for an object-like macro) or
9500      an opening paren (for a function-like macro).  */
9501   for (p = body; *p; p++)
9502     if (*p == ' ' || *p == '(')
9503       break;
9504
9505   if (*p == ' ' || *p == '\0')
9506     {
9507       /* It's an object-like macro.  */
9508       int name_len = p - body;
9509       char *name = copy_string (body, name_len);
9510       const char *replacement;
9511
9512       if (*p == ' ')
9513         replacement = body + name_len + 1;
9514       else
9515         {
9516           dwarf2_macro_malformed_definition_complaint (body);
9517           replacement = body + name_len;
9518         }
9519
9520       macro_define_object (file, line, name, replacement);
9521
9522       xfree (name);
9523     }
9524   else if (*p == '(')
9525     {
9526       /* It's a function-like macro.  */
9527       char *name = copy_string (body, p - body);
9528       int argc = 0;
9529       int argv_size = 1;
9530       char **argv = xmalloc (argv_size * sizeof (*argv));
9531
9532       p++;
9533
9534       p = consume_improper_spaces (p, body);
9535
9536       /* Parse the formal argument list.  */
9537       while (*p && *p != ')')
9538         {
9539           /* Find the extent of the current argument name.  */
9540           const char *arg_start = p;
9541
9542           while (*p && *p != ',' && *p != ')' && *p != ' ')
9543             p++;
9544
9545           if (! *p || p == arg_start)
9546             dwarf2_macro_malformed_definition_complaint (body);
9547           else
9548             {
9549               /* Make sure argv has room for the new argument.  */
9550               if (argc >= argv_size)
9551                 {
9552                   argv_size *= 2;
9553                   argv = xrealloc (argv, argv_size * sizeof (*argv));
9554                 }
9555
9556               argv[argc++] = copy_string (arg_start, p - arg_start);
9557             }
9558
9559           p = consume_improper_spaces (p, body);
9560
9561           /* Consume the comma, if present.  */
9562           if (*p == ',')
9563             {
9564               p++;
9565
9566               p = consume_improper_spaces (p, body);
9567             }
9568         }
9569
9570       if (*p == ')')
9571         {
9572           p++;
9573
9574           if (*p == ' ')
9575             /* Perfectly formed definition, no complaints.  */
9576             macro_define_function (file, line, name,
9577                                    argc, (const char **) argv,
9578                                    p + 1);
9579           else if (*p == '\0')
9580             {
9581               /* Complain, but do define it.  */
9582               dwarf2_macro_malformed_definition_complaint (body);
9583               macro_define_function (file, line, name,
9584                                      argc, (const char **) argv,
9585                                      p);
9586             }
9587           else
9588             /* Just complain.  */
9589             dwarf2_macro_malformed_definition_complaint (body);
9590         }
9591       else
9592         /* Just complain.  */
9593         dwarf2_macro_malformed_definition_complaint (body);
9594
9595       xfree (name);
9596       {
9597         int i;
9598
9599         for (i = 0; i < argc; i++)
9600           xfree (argv[i]);
9601       }
9602       xfree (argv);
9603     }
9604   else
9605     dwarf2_macro_malformed_definition_complaint (body);
9606 }
9607
9608
9609 static void
9610 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
9611                      char *comp_dir, bfd *abfd,
9612                      struct dwarf2_cu *cu)
9613 {
9614   gdb_byte *mac_ptr, *mac_end;
9615   struct macro_source_file *current_file = 0;
9616
9617   if (dwarf2_per_objfile->macinfo_buffer == NULL)
9618     {
9619       complaint (&symfile_complaints, _("missing .debug_macinfo section"));
9620       return;
9621     }
9622
9623   mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset;
9624   mac_end = dwarf2_per_objfile->macinfo_buffer
9625     + dwarf2_per_objfile->macinfo_size;
9626
9627   for (;;)
9628     {
9629       enum dwarf_macinfo_record_type macinfo_type;
9630
9631       /* Do we at least have room for a macinfo type byte?  */
9632       if (mac_ptr >= mac_end)
9633         {
9634           dwarf2_macros_too_long_complaint ();
9635           return;
9636         }
9637
9638       macinfo_type = read_1_byte (abfd, mac_ptr);
9639       mac_ptr++;
9640
9641       switch (macinfo_type)
9642         {
9643           /* A zero macinfo type indicates the end of the macro
9644              information.  */
9645         case 0:
9646           return;
9647
9648         case DW_MACINFO_define:
9649         case DW_MACINFO_undef:
9650           {
9651             unsigned int bytes_read;
9652             int line;
9653             char *body;
9654
9655             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9656             mac_ptr += bytes_read;
9657             body = read_string (abfd, mac_ptr, &bytes_read);
9658             mac_ptr += bytes_read;
9659
9660             if (! current_file)
9661               complaint (&symfile_complaints,
9662                          _("debug info gives macro %s outside of any file: %s"),
9663                          macinfo_type ==
9664                          DW_MACINFO_define ? "definition" : macinfo_type ==
9665                          DW_MACINFO_undef ? "undefinition" :
9666                          "something-or-other", body);
9667             else
9668               {
9669                 if (macinfo_type == DW_MACINFO_define)
9670                   parse_macro_definition (current_file, line, body);
9671                 else if (macinfo_type == DW_MACINFO_undef)
9672                   macro_undef (current_file, line, body);
9673               }
9674           }
9675           break;
9676
9677         case DW_MACINFO_start_file:
9678           {
9679             unsigned int bytes_read;
9680             int line, file;
9681
9682             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9683             mac_ptr += bytes_read;
9684             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9685             mac_ptr += bytes_read;
9686
9687             current_file = macro_start_file (file, line,
9688                                              current_file, comp_dir,
9689                                              lh, cu->objfile);
9690           }
9691           break;
9692
9693         case DW_MACINFO_end_file:
9694           if (! current_file)
9695             complaint (&symfile_complaints,
9696                        _("macro debug info has an unmatched `close_file' directive"));
9697           else
9698             {
9699               current_file = current_file->included_by;
9700               if (! current_file)
9701                 {
9702                   enum dwarf_macinfo_record_type next_type;
9703
9704                   /* GCC circa March 2002 doesn't produce the zero
9705                      type byte marking the end of the compilation
9706                      unit.  Complain if it's not there, but exit no
9707                      matter what.  */
9708
9709                   /* Do we at least have room for a macinfo type byte?  */
9710                   if (mac_ptr >= mac_end)
9711                     {
9712                       dwarf2_macros_too_long_complaint ();
9713                       return;
9714                     }
9715
9716                   /* We don't increment mac_ptr here, so this is just
9717                      a look-ahead.  */
9718                   next_type = read_1_byte (abfd, mac_ptr);
9719                   if (next_type != 0)
9720                     complaint (&symfile_complaints,
9721                                _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9722
9723                   return;
9724                 }
9725             }
9726           break;
9727
9728         case DW_MACINFO_vendor_ext:
9729           {
9730             unsigned int bytes_read;
9731             int constant;
9732             char *string;
9733
9734             constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
9735             mac_ptr += bytes_read;
9736             string = read_string (abfd, mac_ptr, &bytes_read);
9737             mac_ptr += bytes_read;
9738
9739             /* We don't recognize any vendor extensions.  */
9740           }
9741           break;
9742         }
9743     }
9744 }
9745
9746 /* Check if the attribute's form is a DW_FORM_block*
9747    if so return true else false. */
9748 static int
9749 attr_form_is_block (struct attribute *attr)
9750 {
9751   return (attr == NULL ? 0 :
9752       attr->form == DW_FORM_block1
9753       || attr->form == DW_FORM_block2
9754       || attr->form == DW_FORM_block4
9755       || attr->form == DW_FORM_block);
9756 }
9757
9758 /* Return non-zero if ATTR's value is a section offset --- classes
9759    lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
9760    You may use DW_UNSND (attr) to retrieve such offsets.
9761
9762    Section 7.5.4, "Attribute Encodings", explains that no attribute
9763    may have a value that belongs to more than one of these classes; it
9764    would be ambiguous if we did, because we use the same forms for all
9765    of them.  */
9766 static int
9767 attr_form_is_section_offset (struct attribute *attr)
9768 {
9769   return (attr->form == DW_FORM_data4
9770           || attr->form == DW_FORM_data8);
9771 }
9772
9773
9774 /* Return non-zero if ATTR's value falls in the 'constant' class, or
9775    zero otherwise.  When this function returns true, you can apply
9776    dwarf2_get_attr_constant_value to it.
9777
9778    However, note that for some attributes you must check
9779    attr_form_is_section_offset before using this test.  DW_FORM_data4
9780    and DW_FORM_data8 are members of both the constant class, and of
9781    the classes that contain offsets into other debug sections
9782    (lineptr, loclistptr, macptr or rangelistptr).  The DWARF spec says
9783    that, if an attribute's can be either a constant or one of the
9784    section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
9785    taken as section offsets, not constants.  */
9786 static int
9787 attr_form_is_constant (struct attribute *attr)
9788 {
9789   switch (attr->form)
9790     {
9791     case DW_FORM_sdata:
9792     case DW_FORM_udata:
9793     case DW_FORM_data1:
9794     case DW_FORM_data2:
9795     case DW_FORM_data4:
9796     case DW_FORM_data8:
9797       return 1;
9798     default:
9799       return 0;
9800     }
9801 }
9802
9803 static void
9804 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
9805                              struct dwarf2_cu *cu)
9806 {
9807   struct objfile *objfile = cu->objfile;
9808
9809   /* Save the master objfile, so that we can report and look up the
9810      correct file containing this variable.  */
9811   if (objfile->separate_debug_objfile_backlink)
9812     objfile = objfile->separate_debug_objfile_backlink;
9813
9814   if (attr_form_is_section_offset (attr)
9815       /* ".debug_loc" may not exist at all, or the offset may be outside
9816          the section.  If so, fall through to the complaint in the
9817          other branch.  */
9818       && DW_UNSND (attr) < dwarf2_per_objfile->loc_size)
9819     {
9820       struct dwarf2_loclist_baton *baton;
9821
9822       baton = obstack_alloc (&cu->objfile->objfile_obstack,
9823                              sizeof (struct dwarf2_loclist_baton));
9824       baton->objfile = objfile;
9825
9826       /* We don't know how long the location list is, but make sure we
9827          don't run off the edge of the section.  */
9828       baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr);
9829       baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr);
9830       baton->base_address = cu->header.base_address;
9831       if (cu->header.base_known == 0)
9832         complaint (&symfile_complaints,
9833                    _("Location list used without specifying the CU base address."));
9834
9835       SYMBOL_OPS (sym) = &dwarf2_loclist_funcs;
9836       SYMBOL_LOCATION_BATON (sym) = baton;
9837     }
9838   else
9839     {
9840       struct dwarf2_locexpr_baton *baton;
9841
9842       baton = obstack_alloc (&cu->objfile->objfile_obstack,
9843                              sizeof (struct dwarf2_locexpr_baton));
9844       baton->objfile = objfile;
9845
9846       if (attr_form_is_block (attr))
9847         {
9848           /* Note that we're just copying the block's data pointer
9849              here, not the actual data.  We're still pointing into the
9850              info_buffer for SYM's objfile; right now we never release
9851              that buffer, but when we do clean up properly this may
9852              need to change.  */
9853           baton->size = DW_BLOCK (attr)->size;
9854           baton->data = DW_BLOCK (attr)->data;
9855         }
9856       else
9857         {
9858           dwarf2_invalid_attrib_class_complaint ("location description",
9859                                                  SYMBOL_NATURAL_NAME (sym));
9860           baton->size = 0;
9861           baton->data = NULL;
9862         }
9863
9864       SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs;
9865       SYMBOL_LOCATION_BATON (sym) = baton;
9866     }
9867 }
9868
9869 /* Locate the compilation unit from CU's objfile which contains the
9870    DIE at OFFSET.  Raises an error on failure.  */
9871
9872 static struct dwarf2_per_cu_data *
9873 dwarf2_find_containing_comp_unit (unsigned long offset,
9874                                   struct objfile *objfile)
9875 {
9876   struct dwarf2_per_cu_data *this_cu;
9877   int low, high;
9878
9879   low = 0;
9880   high = dwarf2_per_objfile->n_comp_units - 1;
9881   while (high > low)
9882     {
9883       int mid = low + (high - low) / 2;
9884       if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
9885         high = mid;
9886       else
9887         low = mid + 1;
9888     }
9889   gdb_assert (low == high);
9890   if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
9891     {
9892       if (low == 0)
9893         error (_("Dwarf Error: could not find partial DIE containing "
9894                "offset 0x%lx [in module %s]"),
9895                (long) offset, bfd_get_filename (objfile->obfd));
9896
9897       gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
9898       return dwarf2_per_objfile->all_comp_units[low-1];
9899     }
9900   else
9901     {
9902       this_cu = dwarf2_per_objfile->all_comp_units[low];
9903       if (low == dwarf2_per_objfile->n_comp_units - 1
9904           && offset >= this_cu->offset + this_cu->length)
9905         error (_("invalid dwarf2 offset %ld"), offset);
9906       gdb_assert (offset < this_cu->offset + this_cu->length);
9907       return this_cu;
9908     }
9909 }
9910
9911 /* Locate the compilation unit from OBJFILE which is located at exactly
9912    OFFSET.  Raises an error on failure.  */
9913
9914 static struct dwarf2_per_cu_data *
9915 dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile)
9916 {
9917   struct dwarf2_per_cu_data *this_cu;
9918   this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
9919   if (this_cu->offset != offset)
9920     error (_("no compilation unit with offset %ld."), offset);
9921   return this_cu;
9922 }
9923
9924 /* Release one cached compilation unit, CU.  We unlink it from the tree
9925    of compilation units, but we don't remove it from the read_in_chain;
9926    the caller is responsible for that.  */
9927
9928 static void
9929 free_one_comp_unit (void *data)
9930 {
9931   struct dwarf2_cu *cu = data;
9932
9933   if (cu->per_cu != NULL)
9934     cu->per_cu->cu = NULL;
9935   cu->per_cu = NULL;
9936
9937   obstack_free (&cu->comp_unit_obstack, NULL);
9938   if (cu->dies)
9939     free_die_list (cu->dies);
9940
9941   xfree (cu);
9942 }
9943
9944 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9945    when we're finished with it.  We can't free the pointer itself, but be
9946    sure to unlink it from the cache.  Also release any associated storage
9947    and perform cache maintenance.
9948
9949    Only used during partial symbol parsing.  */
9950
9951 static void
9952 free_stack_comp_unit (void *data)
9953 {
9954   struct dwarf2_cu *cu = data;
9955
9956   obstack_free (&cu->comp_unit_obstack, NULL);
9957   cu->partial_dies = NULL;
9958
9959   if (cu->per_cu != NULL)
9960     {
9961       /* This compilation unit is on the stack in our caller, so we
9962          should not xfree it.  Just unlink it.  */
9963       cu->per_cu->cu = NULL;
9964       cu->per_cu = NULL;
9965
9966       /* If we had a per-cu pointer, then we may have other compilation
9967          units loaded, so age them now.  */
9968       age_cached_comp_units ();
9969     }
9970 }
9971
9972 /* Free all cached compilation units.  */
9973
9974 static void
9975 free_cached_comp_units (void *data)
9976 {
9977   struct dwarf2_per_cu_data *per_cu, **last_chain;
9978
9979   per_cu = dwarf2_per_objfile->read_in_chain;
9980   last_chain = &dwarf2_per_objfile->read_in_chain;
9981   while (per_cu != NULL)
9982     {
9983       struct dwarf2_per_cu_data *next_cu;
9984
9985       next_cu = per_cu->cu->read_in_chain;
9986
9987       free_one_comp_unit (per_cu->cu);
9988       *last_chain = next_cu;
9989
9990       per_cu = next_cu;
9991     }
9992 }
9993
9994 /* Increase the age counter on each cached compilation unit, and free
9995    any that are too old.  */
9996
9997 static void
9998 age_cached_comp_units (void)
9999 {
10000   struct dwarf2_per_cu_data *per_cu, **last_chain;
10001
10002   dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
10003   per_cu = dwarf2_per_objfile->read_in_chain;
10004   while (per_cu != NULL)
10005     {
10006       per_cu->cu->last_used ++;
10007       if (per_cu->cu->last_used <= dwarf2_max_cache_age)
10008         dwarf2_mark (per_cu->cu);
10009       per_cu = per_cu->cu->read_in_chain;
10010     }
10011
10012   per_cu = dwarf2_per_objfile->read_in_chain;
10013   last_chain = &dwarf2_per_objfile->read_in_chain;
10014   while (per_cu != NULL)
10015     {
10016       struct dwarf2_per_cu_data *next_cu;
10017
10018       next_cu = per_cu->cu->read_in_chain;
10019
10020       if (!per_cu->cu->mark)
10021         {
10022           free_one_comp_unit (per_cu->cu);
10023           *last_chain = next_cu;
10024         }
10025       else
10026         last_chain = &per_cu->cu->read_in_chain;
10027
10028       per_cu = next_cu;
10029     }
10030 }
10031
10032 /* Remove a single compilation unit from the cache.  */
10033
10034 static void
10035 free_one_cached_comp_unit (void *target_cu)
10036 {
10037   struct dwarf2_per_cu_data *per_cu, **last_chain;
10038
10039   per_cu = dwarf2_per_objfile->read_in_chain;
10040   last_chain = &dwarf2_per_objfile->read_in_chain;
10041   while (per_cu != NULL)
10042     {
10043       struct dwarf2_per_cu_data *next_cu;
10044
10045       next_cu = per_cu->cu->read_in_chain;
10046
10047       if (per_cu->cu == target_cu)
10048         {
10049           free_one_comp_unit (per_cu->cu);
10050           *last_chain = next_cu;
10051           break;
10052         }
10053       else
10054         last_chain = &per_cu->cu->read_in_chain;
10055
10056       per_cu = next_cu;
10057     }
10058 }
10059
10060 /* Release all extra memory associated with OBJFILE.  */
10061
10062 void
10063 dwarf2_free_objfile (struct objfile *objfile)
10064 {
10065   dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
10066
10067   if (dwarf2_per_objfile == NULL)
10068     return;
10069
10070   /* Cached DIE trees use xmalloc and the comp_unit_obstack.  */
10071   free_cached_comp_units (NULL);
10072
10073   /* Everything else should be on the objfile obstack.  */
10074 }
10075
10076 /* A pair of DIE offset and GDB type pointer.  We store these
10077    in a hash table separate from the DIEs, and preserve them
10078    when the DIEs are flushed out of cache.  */
10079
10080 struct dwarf2_offset_and_type
10081 {
10082   unsigned int offset;
10083   struct type *type;
10084 };
10085
10086 /* Hash function for a dwarf2_offset_and_type.  */
10087
10088 static hashval_t
10089 offset_and_type_hash (const void *item)
10090 {
10091   const struct dwarf2_offset_and_type *ofs = item;
10092   return ofs->offset;
10093 }
10094
10095 /* Equality function for a dwarf2_offset_and_type.  */
10096
10097 static int
10098 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
10099 {
10100   const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
10101   const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
10102   return ofs_lhs->offset == ofs_rhs->offset;
10103 }
10104
10105 /* Set the type associated with DIE to TYPE.  Save it in CU's hash
10106    table if necessary.  */
10107
10108 static void
10109 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
10110 {
10111   struct dwarf2_offset_and_type **slot, ofs;
10112
10113   die->type = type;
10114
10115   if (cu->per_cu == NULL)
10116     return;
10117
10118   if (cu->per_cu->type_hash == NULL)
10119     cu->per_cu->type_hash
10120       = htab_create_alloc_ex (cu->header.length / 24,
10121                               offset_and_type_hash,
10122                               offset_and_type_eq,
10123                               NULL,
10124                               &cu->objfile->objfile_obstack,
10125                               hashtab_obstack_allocate,
10126                               dummy_obstack_deallocate);
10127
10128   ofs.offset = die->offset;
10129   ofs.type = type;
10130   slot = (struct dwarf2_offset_and_type **)
10131     htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT);
10132   *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot));
10133   **slot = ofs;
10134 }
10135
10136 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
10137    have a saved type.  */
10138
10139 static struct type *
10140 get_die_type (struct die_info *die, htab_t type_hash)
10141 {
10142   struct dwarf2_offset_and_type *slot, ofs;
10143
10144   ofs.offset = die->offset;
10145   slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
10146   if (slot)
10147     return slot->type;
10148   else
10149     return NULL;
10150 }
10151
10152 /* Restore the types of the DIE tree starting at START_DIE from the hash
10153    table saved in CU.  */
10154
10155 static void
10156 reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu)
10157 {
10158   struct die_info *die;
10159
10160   if (cu->per_cu->type_hash == NULL)
10161     return;
10162
10163   for (die = start_die; die != NULL; die = die->sibling)
10164     {
10165       die->type = get_die_type (die, cu->per_cu->type_hash);
10166       if (die->child != NULL)
10167         reset_die_and_siblings_types (die->child, cu);
10168     }
10169 }
10170
10171 /* Set the mark field in CU and in every other compilation unit in the
10172    cache that we must keep because we are keeping CU.  */
10173
10174 /* Add a dependence relationship from CU to REF_PER_CU.  */
10175
10176 static void
10177 dwarf2_add_dependence (struct dwarf2_cu *cu,
10178                        struct dwarf2_per_cu_data *ref_per_cu)
10179 {
10180   void **slot;
10181
10182   if (cu->dependencies == NULL)
10183     cu->dependencies
10184       = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
10185                               NULL, &cu->comp_unit_obstack,
10186                               hashtab_obstack_allocate,
10187                               dummy_obstack_deallocate);
10188
10189   slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
10190   if (*slot == NULL)
10191     *slot = ref_per_cu;
10192 }
10193
10194 /* Set the mark field in CU and in every other compilation unit in the
10195    cache that we must keep because we are keeping CU.  */
10196
10197 static int
10198 dwarf2_mark_helper (void **slot, void *data)
10199 {
10200   struct dwarf2_per_cu_data *per_cu;
10201
10202   per_cu = (struct dwarf2_per_cu_data *) *slot;
10203   if (per_cu->cu->mark)
10204     return 1;
10205   per_cu->cu->mark = 1;
10206
10207   if (per_cu->cu->dependencies != NULL)
10208     htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
10209
10210   return 1;
10211 }
10212
10213 static void
10214 dwarf2_mark (struct dwarf2_cu *cu)
10215 {
10216   if (cu->mark)
10217     return;
10218   cu->mark = 1;
10219   if (cu->dependencies != NULL)
10220     htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
10221 }
10222
10223 static void
10224 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
10225 {
10226   while (per_cu)
10227     {
10228       per_cu->cu->mark = 0;
10229       per_cu = per_cu->cu->read_in_chain;
10230     }
10231 }
10232
10233 /* Trivial hash function for partial_die_info: the hash value of a DIE
10234    is its offset in .debug_info for this objfile.  */
10235
10236 static hashval_t
10237 partial_die_hash (const void *item)
10238 {
10239   const struct partial_die_info *part_die = item;
10240   return part_die->offset;
10241 }
10242
10243 /* Trivial comparison function for partial_die_info structures: two DIEs
10244    are equal if they have the same offset.  */
10245
10246 static int
10247 partial_die_eq (const void *item_lhs, const void *item_rhs)
10248 {
10249   const struct partial_die_info *part_die_lhs = item_lhs;
10250   const struct partial_die_info *part_die_rhs = item_rhs;
10251   return part_die_lhs->offset == part_die_rhs->offset;
10252 }
10253
10254 static struct cmd_list_element *set_dwarf2_cmdlist;
10255 static struct cmd_list_element *show_dwarf2_cmdlist;
10256
10257 static void
10258 set_dwarf2_cmd (char *args, int from_tty)
10259 {
10260   help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
10261 }
10262
10263 static void
10264 show_dwarf2_cmd (char *args, int from_tty)
10265 {
10266   cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
10267 }
10268
10269 void _initialize_dwarf2_read (void);
10270
10271 void
10272 _initialize_dwarf2_read (void)
10273 {
10274   dwarf2_objfile_data_key = register_objfile_data ();
10275
10276   add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
10277 Set DWARF 2 specific variables.\n\
10278 Configure DWARF 2 variables such as the cache size"),
10279                   &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
10280                   0/*allow-unknown*/, &maintenance_set_cmdlist);
10281
10282   add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
10283 Show DWARF 2 specific variables\n\
10284 Show DWARF 2 variables such as the cache size"),
10285                   &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
10286                   0/*allow-unknown*/, &maintenance_show_cmdlist);
10287
10288   add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
10289                             &dwarf2_max_cache_age, _("\
10290 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10291 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10292 A higher limit means that cached compilation units will be stored\n\
10293 in memory longer, and more total memory will be used.  Zero disables\n\
10294 caching, which can slow down startup."),
10295                             NULL,
10296                             show_dwarf2_max_cache_age,
10297                             &set_dwarf2_cmdlist,
10298                             &show_dwarf2_cmdlist);
10299 }