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