gdb/dwarf2read.c

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