gdb/dwarf2read.c

   1 /* DWARF 2 debugging format support for GDB.
   2    Copyright 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
   3
   4    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
   5    Inc.  with support from Florida State University (under contract
   6    with the Ada Joint Program Office), and Silicon Graphics, Inc.
   7    Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
   8    based on Fred Fish's (Cygnus Support) implementation of DWARF 1
   9    support in dwarfread.c
  10
  11 This file is part of GDB.
  12
  13 This program is free software; you can redistribute it and/or modify
  14 it under the terms of the GNU General Public License as published by
  15 the Free Software Foundation; either version 2 of the License, or (at
  16 your option) any later version.
  17
  18 This program is distributed in the hope that it will be useful, but
  19 WITHOUT ANY WARRANTY; without even the implied warranty of
  20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 General Public License for more details.
  22
  23 You should have received a copy of the GNU General Public License
  24 along with this program; if not, write to the Free Software
  25 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  26
  27 #include "defs.h"
  28 #include "bfd.h"
  29 #include "symtab.h"
  30 #include "gdbtypes.h"
  31 #include "symfile.h"
  32 #include "objfiles.h"
  33 #include "elf/dwarf2.h"
  34 #include "buildsym.h"
  35 #include "demangle.h"
  36 #include "expression.h"
  37 #include "language.h"
  38 #include "complaints.h"
  39
  40 #include <fcntl.h>
  41 #include "gdb_string.h"
  42 #include <sys/types.h>
  43
  44 /* .debug_info header for a compilation unit
  45    Because of alignment constraints, this structure has padding and cannot
  46    be mapped directly onto the beginning of the .debug_info section.  */
  47 typedef struct comp_unit_header
  48   {
  49     unsigned int length;        /* length of the .debug_info
  50                                    contribution */
  51     unsigned short version;     /* version number -- 2 for DWARF
  52                                    version 2 */
  53     unsigned int abbrev_offset; /* offset into .debug_abbrev section */
  54     unsigned char addr_size;    /* byte size of an address -- 4 */
  55   }
  56 _COMP_UNIT_HEADER;
  57 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
  58
  59 /* .debug_pubnames header
  60    Because of alignment constraints, this structure has padding and cannot
  61    be mapped directly onto the beginning of the .debug_info section.  */
  62 typedef struct pubnames_header
  63   {
  64     unsigned int length;        /* length of the .debug_pubnames
  65                                    contribution  */
  66     unsigned char version;      /* version number -- 2 for DWARF
  67                                    version 2 */
  68     unsigned int info_offset;   /* offset into .debug_info section */
  69     unsigned int info_size;     /* byte size of .debug_info section
  70                                    portion */
  71   }
  72 _PUBNAMES_HEADER;
  73 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
  74
  75 /* .debug_pubnames header
  76    Because of alignment constraints, this structure has padding and cannot
  77    be mapped directly onto the beginning of the .debug_info section.  */
  78 typedef struct aranges_header
  79   {
  80     unsigned int length;        /* byte len of the .debug_aranges
  81                                    contribution */
  82     unsigned short version;     /* version number -- 2 for DWARF
  83                                    version 2 */
  84     unsigned int info_offset;   /* offset into .debug_info section */
  85     unsigned char addr_size;    /* byte size of an address */
  86     unsigned char seg_size;     /* byte size of segment descriptor */
  87   }
  88 _ARANGES_HEADER;
  89 #define _ACTUAL_ARANGES_HEADER_SIZE 12
  90
  91 /* .debug_line statement program prologue
  92    Because of alignment constraints, this structure has padding and cannot
  93    be mapped directly onto the beginning of the .debug_info section.  */
  94 typedef struct statement_prologue
  95   {
  96     unsigned int total_length;  /* byte length of the statement
  97                                    information */
  98     unsigned short version;     /* version number -- 2 for DWARF
  99                                    version 2 */
 100     unsigned int prologue_length;       /* # bytes between prologue &
 101                                            stmt program */
 102     unsigned char minimum_instruction_length;   /* byte size of
 103                                                    smallest instr */
 104     unsigned char default_is_stmt;      /* initial value of is_stmt
 105                                            register */
 106     char line_base;
 107     unsigned char line_range;
 108     unsigned char opcode_base;  /* number assigned to first special
 109                                    opcode */
 110     unsigned char *standard_opcode_lengths;
 111   }
 112 _STATEMENT_PROLOGUE;
 113
 114 /* offsets and sizes of debugging sections */
 115
 116 static file_ptr dwarf_info_offset;
 117 static file_ptr dwarf_abbrev_offset;
 118 static file_ptr dwarf_line_offset;
 119 static file_ptr dwarf_pubnames_offset;
 120 static file_ptr dwarf_aranges_offset;
 121 static file_ptr dwarf_loc_offset;
 122 static file_ptr dwarf_macinfo_offset;
 123 static file_ptr dwarf_str_offset;
 124
 125 static unsigned int dwarf_info_size;
 126 static unsigned int dwarf_abbrev_size;
 127 static unsigned int dwarf_line_size;
 128 static unsigned int dwarf_pubnames_size;
 129 static unsigned int dwarf_aranges_size;
 130 static unsigned int dwarf_loc_size;
 131 static unsigned int dwarf_macinfo_size;
 132 static unsigned int dwarf_str_size;
 133
 134 /* names of the debugging sections */
 135
 136 #define INFO_SECTION     ".debug_info"
 137 #define ABBREV_SECTION   ".debug_abbrev"
 138 #define LINE_SECTION     ".debug_line"
 139 #define PUBNAMES_SECTION ".debug_pubnames"
 140 #define ARANGES_SECTION  ".debug_aranges"
 141 #define LOC_SECTION      ".debug_loc"
 142 #define MACINFO_SECTION  ".debug_macinfo"
 143 #define STR_SECTION      ".debug_str"
 144
 145 /* local data types */
 146
 147 /* The data in a compilation unit header looks like this.  */
 148 struct comp_unit_head
 149   {
 150     int length;
 151     short version;
 152     int abbrev_offset;
 153     unsigned char addr_size;
 154   };
 155
 156 /* The data in the .debug_line statement prologue looks like this.  */
 157 struct line_head
 158   {
 159     unsigned int total_length;
 160     unsigned short version;
 161     unsigned int prologue_length;
 162     unsigned char minimum_instruction_length;
 163     unsigned char default_is_stmt;
 164     int line_base;
 165     unsigned char line_range;
 166     unsigned char opcode_base;
 167     unsigned char *standard_opcode_lengths;
 168   };
 169
 170 /* When we construct a partial symbol table entry we only
 171    need this much information. */
 172 struct partial_die_info
 173   {
 174     enum dwarf_tag tag;
 175     unsigned char has_children;
 176     unsigned char is_external;
 177     unsigned char is_declaration;
 178     unsigned char has_type;
 179     unsigned int offset;
 180     unsigned int abbrev;
 181     char *name;
 182     CORE_ADDR lowpc;
 183     CORE_ADDR highpc;
 184     struct dwarf_block *locdesc;
 185     unsigned int language;
 186     char *sibling;
 187   };
 188
 189 /* This data structure holds the information of an abbrev. */
 190 struct abbrev_info
 191   {
 192     unsigned int number;        /* number identifying abbrev */
 193     enum dwarf_tag tag;         /* dwarf tag */
 194     int has_children;           /* boolean */
 195     unsigned int num_attrs;     /* number of attributes */
 196     struct attr_abbrev *attrs;  /* an array of attribute descriptions */
 197     struct abbrev_info *next;   /* next in chain */
 198   };
 199
 200 struct attr_abbrev
 201   {
 202     enum dwarf_attribute name;
 203     enum dwarf_form form;
 204   };
 205
 206 /* This data structure holds a complete die structure. */
 207 struct die_info
 208   {
 209     enum dwarf_tag tag;          /* Tag indicating type of die */
 210     unsigned short has_children; /* Does the die have children */
 211     unsigned int abbrev;         /* Abbrev number */
 212     unsigned int offset;         /* Offset in .debug_info section */
 213     unsigned int num_attrs;      /* Number of attributes */
 214     struct attribute *attrs;     /* An array of attributes */
 215     struct die_info *next_ref;   /* Next die in ref hash table */
 216     struct die_info *next;       /* Next die in linked list */
 217     struct type *type;           /* Cached type information */
 218   };
 219
 220 /* Attributes have a name and a value */
 221 struct attribute
 222   {
 223     enum dwarf_attribute name;
 224     enum dwarf_form form;
 225     union
 226       {
 227         char *str;
 228         struct dwarf_block *blk;
 229         unsigned int unsnd;
 230         int snd;
 231         CORE_ADDR addr;
 232       }
 233     u;
 234   };
 235
 236 /* Get at parts of an attribute structure */
 237
 238 #define DW_STRING(attr)    ((attr)->u.str)
 239 #define DW_UNSND(attr)     ((attr)->u.unsnd)
 240 #define DW_BLOCK(attr)     ((attr)->u.blk)
 241 #define DW_SND(attr)       ((attr)->u.snd)
 242 #define DW_ADDR(attr)      ((attr)->u.addr)
 243
 244 /* Blocks are a bunch of untyped bytes. */
 245 struct dwarf_block
 246   {
 247     unsigned int size;
 248     char *data;
 249   };
 250
 251 /* We only hold one compilation unit's abbrevs in
 252    memory at any one time.  */
 253 #ifndef ABBREV_HASH_SIZE
 254 #define ABBREV_HASH_SIZE 121
 255 #endif
 256 #ifndef ATTR_ALLOC_CHUNK
 257 #define ATTR_ALLOC_CHUNK 4
 258 #endif
 259
 260 static struct abbrev_info *dwarf2_abbrevs[ABBREV_HASH_SIZE];
 261
 262 /* A hash table of die offsets for following references.  */
 263 #ifndef REF_HASH_SIZE
 264 #define REF_HASH_SIZE 1021
 265 #endif
 266
 267 static struct die_info *die_ref_table[REF_HASH_SIZE];
 268
 269 /* Obstack for allocating temporary storage used during symbol reading.  */
 270 static struct obstack dwarf2_tmp_obstack;
 271
 272 /* Offset to the first byte of the current compilation unit header,
 273    for resolving relative reference dies. */
 274 static unsigned int cu_header_offset;
 275
 276 /* Allocate fields for structs, unions and enums in this size.  */
 277 #ifndef DW_FIELD_ALLOC_CHUNK
 278 #define DW_FIELD_ALLOC_CHUNK 4
 279 #endif
 280
 281 /* The language we are debugging.  */
 282 static enum language cu_language;
 283 static const struct language_defn *cu_language_defn;
 284
 285 /* Actually data from the sections.  */
 286 static char *dwarf_info_buffer;
 287 static char *dwarf_abbrev_buffer;
 288 static char *dwarf_line_buffer;
 289
 290 /* A zeroed version of a partial die for initialization purposes.  */
 291 static struct partial_die_info zeroed_partial_die;
 292
 293 /* The generic symbol table building routines have separate lists for
 294    file scope symbols and all all other scopes (local scopes).  So
 295    we need to select the right one to pass to add_symbol_to_list().
 296    We do it by keeping a pointer to the correct list in list_in_scope.
 297
 298    FIXME:  The original dwarf code just treated the file scope as the first
 299    local scope, and all other local scopes as nested local scopes, and worked
 300    fine.  Check to see if we really need to distinguish these
 301    in buildsym.c.  */
 302 static struct pending **list_in_scope = &file_symbols;
 303
 304 /* FIXME: The following variables pass additional information from
 305    decode_locdesc to the caller.  */
 306 static int optimized_out;       /* Kludge to identify optimized out variables */
 307 static int isreg;               /* Kludge to identify register variables */
 308 static int offreg;              /* Kludge to identify basereg references */
 309 static int basereg;             /* Which base register is it relative to?  */
 310 static int islocal;             /* Kludge to identify local variables */
 311
 312 /* DW_AT_frame_base values for the current function.
 313    frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
 314    contains the register number for the frame register.
 315    frame_base_offset is the offset from the frame register to the
 316    virtual stack frame. */
 317 static int frame_base_reg;
 318 static CORE_ADDR frame_base_offset;
 319
 320 /* This value is added to each symbol value.  FIXME:  Generalize to
 321    the section_offsets structure used by dbxread (once this is done,
 322    pass the appropriate section number to end_symtab).  */
 323 static CORE_ADDR baseaddr;      /* Add to each symbol value */
 324
 325 /* We put a pointer to this structure in the read_symtab_private field
 326    of the psymtab.
 327    The complete dwarf information for an objfile is kept in the
 328    psymbol_obstack, so that absolute die references can be handled.
 329    Most of the information in this structure is related to an entire
 330    object file and could be passed via the sym_private field of the objfile.
 331    It is however conceivable that dwarf2 might not be the only type
 332    of symbols read from an object file.  */
 333
 334 struct dwarf2_pinfo
 335 {
 336   /* Pointer to start of dwarf info buffer for the objfile.  */
 337
 338   char *dwarf_info_buffer;
 339
 340   /* Offset in dwarf_info_buffer for this compilation unit. */
 341
 342   unsigned long dwarf_info_offset;
 343
 344   /* Pointer to start of dwarf abbreviation buffer for the objfile.  */
 345
 346   char *dwarf_abbrev_buffer;
 347
 348   /* Size of dwarf abbreviation section for the objfile.  */
 349
 350   unsigned int dwarf_abbrev_size;
 351
 352   /* Pointer to start of dwarf line buffer for the objfile.  */
 353
 354   char *dwarf_line_buffer;
 355 };
 356
 357 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
 358 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
 359 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
 360 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
 361 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
 362 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
 363
 364 /* Maintain an array of referenced fundamental types for the current
 365    compilation unit being read.  For DWARF version 1, we have to construct
 366    the fundamental types on the fly, since no information about the
 367    fundamental types is supplied.  Each such fundamental type is created by
 368    calling a language dependent routine to create the type, and then a
 369    pointer to that type is then placed in the array at the index specified
 370    by it's FT_<TYPENAME> value.  The array has a fixed size set by the
 371    FT_NUM_MEMBERS compile time constant, which is the number of predefined
 372    fundamental types gdb knows how to construct.  */
 373 static struct type *ftypes[FT_NUM_MEMBERS];     /* Fundamental types */
 374
 375 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
 376    but this would require a corresponding change in unpack_field_as_long
 377    and friends.  */
 378 static int bits_per_byte = 8;
 379
 380 /* The routines that read and process dies for a C struct or C++ class
 381    pass lists of data member fields and lists of member function fields
 382    in an instance of a field_info structure, as defined below.  */
 383 struct field_info
 384 {
 385   /* List of data member and baseclasses fields. */
 386   struct nextfield
 387     {
 388       struct nextfield *next;
 389       int accessibility;
 390       int virtuality;
 391       struct field field;
 392     } *fields;
 393
 394   /* Number of fields.  */
 395   int nfields;
 396
 397   /* Number of baseclasses.  */
 398   int nbaseclasses;
 399
 400   /* Set if the accesibility of one of the fields is not public.  */
 401   int non_public_fields;
 402
 403   /* Member function fields array, entries are allocated in the order they
 404      are encountered in the object file.  */
 405   struct nextfnfield
 406     {
 407       struct nextfnfield *next;
 408       struct fn_field fnfield;
 409     } *fnfields;
 410
 411   /* Member function fieldlist array, contains name of possibly overloaded
 412      member function, number of overloaded member functions and a pointer
 413      to the head of the member function field chain.  */
 414   struct fnfieldlist
 415     {
 416       char *name;
 417       int length;
 418       struct nextfnfield *head;
 419     } *fnfieldlists;
 420
 421   /* Number of entries in the fnfieldlists array.  */
 422   int nfnfields;
 423 };
 424
 425 /* FIXME: Kludge to mark a varargs function type for C++ member function
 426    argument processing.  */
 427 #define TYPE_FLAG_VARARGS       (1 << 10)
 428
 429 /* Dwarf2 has no clean way to discern C++ static and non-static member
 430    functions. G++ helps GDB by marking the first parameter for non-static
 431    member functions (which is the this pointer) as artificial.
 432    We pass this information between dwarf2_add_member_fn and
 433    read_subroutine_type via TYPE_FIELD_ARTIFICIAL.  */
 434 #define TYPE_FIELD_ARTIFICIAL   TYPE_FIELD_BITPOS
 435
 436 /* Various complaints about symbol reading that don't abort the process */
 437
 438 static struct complaint dwarf2_const_ignored =
 439 {
 440   "type qualifier 'const' ignored", 0, 0
 441 };
 442 static struct complaint dwarf2_volatile_ignored =
 443 {
 444   "type qualifier 'volatile' ignored", 0, 0
 445 };
 446 static struct complaint dwarf2_non_const_array_bound_ignored =
 447 {
 448   "non-constant array bounds form '%s' ignored", 0, 0
 449 };
 450 static struct complaint dwarf2_missing_line_number_section =
 451 {
 452   "missing .debug_line section", 0, 0
 453 };
 454 static struct complaint dwarf2_mangled_line_number_section =
 455 {
 456   "mangled .debug_line section", 0, 0
 457 };
 458 static struct complaint dwarf2_unsupported_die_ref_attr =
 459 {
 460   "unsupported die ref attribute form: '%s'", 0, 0
 461 };
 462 static struct complaint dwarf2_unsupported_stack_op =
 463 {
 464   "unsupported stack op: '%s'", 0, 0
 465 };
 466 static struct complaint dwarf2_unsupported_tag =
 467 {
 468   "unsupported tag: '%s'", 0, 0
 469 };
 470 static struct complaint dwarf2_unsupported_at_encoding =
 471 {
 472   "unsupported DW_AT_encoding: '%s'", 0, 0
 473 };
 474 static struct complaint dwarf2_unsupported_at_frame_base =
 475 {
 476   "unsupported DW_AT_frame_base for function '%s'", 0, 0
 477 };
 478 static struct complaint dwarf2_unexpected_tag =
 479 {
 480   "unexepected tag in read_type_die: '%s'", 0, 0
 481 };
 482 static struct complaint dwarf2_missing_at_frame_base =
 483 {
 484   "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
 485 };
 486 static struct complaint dwarf2_bad_static_member_name =
 487 {
 488   "unrecognized static data member name '%s'", 0, 0
 489 };
 490 static struct complaint dwarf2_unsupported_accessibility =
 491 {
 492   "unsupported accessibility %d", 0, 0
 493 };
 494 static struct complaint dwarf2_bad_member_name_complaint =
 495 {
 496   "cannot extract member name from '%s'", 0, 0
 497 };
 498 static struct complaint dwarf2_missing_member_fn_type_complaint =
 499 {
 500   "member function type missing for '%s'", 0, 0
 501 };
 502 static struct complaint dwarf2_vtbl_not_found_complaint =
 503 {
 504   "virtual function table pointer not found when defining class '%s'", 0, 0
 505 };
 506 static struct complaint dwarf2_absolute_sibling_complaint =
 507 {
 508   "ignoring absolute DW_AT_sibling", 0, 0
 509 };
 510 static struct complaint dwarf2_const_value_length_mismatch =
 511 {
 512   "const value length mismatch for '%s', got %d, expected %d", 0, 0
 513 };
 514 static struct complaint dwarf2_unsupported_const_value_attr =
 515 {
 516   "unsupported const value attribute form: '%s'", 0, 0
 517 };
 518
 519 /* Remember the addr_size read from the dwarf.
 520    If a target expects to link compilation units with differing address
 521    sizes, gdb needs to be sure that the appropriate size is here for
 522    whatever scope is currently getting read. */
 523 static int address_size;
 524
 525 /* Externals references.  */
 526 extern int info_verbose;        /* From main.c; nonzero => verbose */
 527
 528 /* local function prototypes */
 529
 530 static void dwarf2_locate_sections PARAMS ((bfd *, asection *, PTR));
 531
 532 #if 0
 533 static void dwarf2_build_psymtabs_easy PARAMS ((struct objfile *,
 534                                                 struct section_offsets *,
 535                                                 int));
 536 #endif
 537
 538 static void dwarf2_build_psymtabs_hard PARAMS ((struct objfile *,
 539                                                 struct section_offsets *,
 540                                                 int));
 541
 542 static char *scan_partial_symbols PARAMS ((char *, struct objfile *,
 543                                            CORE_ADDR *, CORE_ADDR *));
 544
 545 static void add_partial_symbol PARAMS ((struct partial_die_info *,
 546                                         struct objfile *));
 547
 548 static void dwarf2_psymtab_to_symtab PARAMS ((struct partial_symtab *));
 549
 550 static void psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
 551
 552 static char *dwarf2_read_section PARAMS ((struct objfile *, file_ptr,
 553                                           unsigned int));
 554
 555 static void dwarf2_read_abbrevs PARAMS ((bfd *, unsigned int));
 556
 557 static void dwarf2_empty_abbrev_table PARAMS ((PTR));
 558
 559 static struct abbrev_info *dwarf2_lookup_abbrev PARAMS ((unsigned int));
 560
 561 static char *read_partial_die PARAMS ((struct partial_die_info *,
 562                                        bfd *, char *, int *));
 563
 564 static char *read_full_die PARAMS ((struct die_info **, bfd *, char *));
 565
 566 static char *read_attribute PARAMS ((struct attribute *, struct attr_abbrev *,
 567                                      bfd *, char *));
 568
 569 static unsigned int read_1_byte PARAMS ((bfd *, char *));
 570
 571 static int read_1_signed_byte PARAMS ((bfd *, char *));
 572
 573 static unsigned int read_2_bytes PARAMS ((bfd *, char *));
 574
 575 static unsigned int read_4_bytes PARAMS ((bfd *, char *));
 576
 577 static unsigned int read_8_bytes PARAMS ((bfd *, char *));
 578
 579 static CORE_ADDR read_address PARAMS ((bfd *, char *));
 580
 581 static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
 582
 583 static char *read_string PARAMS ((bfd *, char *, unsigned int *));
 584
 585 static unsigned int read_unsigned_leb128 PARAMS ((bfd *, char *,
 586                                                   unsigned int *));
 587
 588 static int read_signed_leb128 PARAMS ((bfd *, char *, unsigned int *));
 589
 590 static void set_cu_language PARAMS ((unsigned int));
 591
 592 static struct attribute *dwarf_attr PARAMS ((struct die_info *,
 593                                              unsigned int));
 594
 595 static void dwarf_decode_lines PARAMS ((unsigned int, char *, bfd *));
 596
 597 static void dwarf2_start_subfile PARAMS ((char *, char *));
 598
 599 static struct symbol *new_symbol PARAMS ((struct die_info *, struct type *,
 600                                           struct objfile *));
 601
 602 static void dwarf2_const_value PARAMS ((struct attribute *, struct symbol *,
 603                                         struct objfile *));
 604
 605 static struct type *die_type PARAMS ((struct die_info *, struct objfile *));
 606
 607 static struct type *die_containing_type PARAMS ((struct die_info *,
 608                                                  struct objfile *));
 609
 610 #if 0
 611 static struct type *type_at_offset PARAMS ((unsigned int, struct objfile *));
 612 #endif
 613
 614 static struct type *tag_type_to_type PARAMS ((struct die_info *,
 615                                               struct objfile *));
 616
 617 static void read_type_die PARAMS ((struct die_info *, struct objfile *));
 618
 619 static void read_typedef PARAMS ((struct die_info *, struct objfile *));
 620
 621 static void read_base_type PARAMS ((struct die_info *, struct objfile *));
 622
 623 static void read_file_scope PARAMS ((struct die_info *, struct objfile *));
 624
 625 static void read_func_scope PARAMS ((struct die_info *, struct objfile *));
 626
 627 static void read_lexical_block_scope PARAMS ((struct die_info *,
 628                                               struct objfile *));
 629
 630 static int dwarf2_get_pc_bounds PARAMS ((struct die_info *,
 631                                          CORE_ADDR *, CORE_ADDR *,
 632                                          struct objfile *));
 633
 634 static void dwarf2_add_field PARAMS ((struct field_info *, struct die_info *,
 635                                       struct objfile *));
 636
 637 static void dwarf2_attach_fields_to_type PARAMS ((struct field_info *,
 638                                                   struct type *,
 639                                                   struct objfile *));
 640
 641 static char *skip_member_fn_name PARAMS ((char *));
 642
 643 static void dwarf2_add_member_fn PARAMS ((struct field_info *,
 644                                           struct die_info *, struct type *,
 645                                           struct objfile *objfile));
 646
 647 static void dwarf2_attach_fn_fields_to_type PARAMS ((struct field_info *,
 648                                                      struct type *,
 649                                                      struct objfile *));
 650
 651 static void read_structure_scope PARAMS ((struct die_info *, struct objfile *));
 652
 653 static void read_common_block PARAMS ((struct die_info *, struct objfile *));
 654
 655 static void read_enumeration PARAMS ((struct die_info *, struct objfile *));
 656
 657 static struct type *dwarf_base_type PARAMS ((int, int, struct objfile *));
 658
 659 static CORE_ADDR decode_locdesc PARAMS ((struct dwarf_block *,
 660                                          struct objfile *));
 661
 662 static void read_array_type PARAMS ((struct die_info *, struct objfile *));
 663
 664 static void read_tag_pointer_type PARAMS ((struct die_info *,
 665                                            struct objfile *));
 666
 667 static void read_tag_ptr_to_member_type PARAMS ((struct die_info *,
 668                                                  struct objfile *));
 669
 670 static void read_tag_reference_type PARAMS ((struct die_info *,
 671                                              struct objfile *));
 672
 673 static void read_tag_const_type PARAMS ((struct die_info *, struct objfile *));
 674
 675 static void read_tag_volatile_type PARAMS ((struct die_info *,
 676                                             struct objfile *));
 677
 678 static void read_tag_string_type PARAMS ((struct die_info *,
 679                                           struct objfile *));
 680
 681 static void read_subroutine_type PARAMS ((struct die_info *,
 682                                           struct objfile *));
 683
 684 struct die_info *read_comp_unit PARAMS ((char *, bfd *));
 685
 686 static void free_die_list PARAMS ((struct die_info *));
 687
 688 static void process_die PARAMS ((struct die_info *, struct objfile *));
 689
 690 static char *dwarf2_linkage_name PARAMS ((struct die_info *));
 691
 692 static char *dwarf_tag_name PARAMS ((unsigned int));
 693
 694 static char *dwarf_attr_name PARAMS ((unsigned int));
 695
 696 static char *dwarf_form_name PARAMS ((unsigned int));
 697
 698 static char *dwarf_stack_op_name PARAMS ((unsigned int));
 699
 700 static char *dwarf_bool_name PARAMS ((unsigned int));
 701
 702 static char *dwarf_type_encoding_name PARAMS ((unsigned int));
 703
 704 #if 0
 705 static char *dwarf_cfi_name PARAMS ((unsigned int));
 706
 707 struct die_info *copy_die PARAMS ((struct die_info *));
 708 #endif
 709
 710 struct die_info *sibling_die PARAMS ((struct die_info *));
 711
 712 void dump_die PARAMS ((struct die_info *));
 713
 714 void dump_die_list PARAMS ((struct die_info *));
 715
 716 void store_in_ref_table PARAMS ((unsigned int, struct die_info *));
 717
 718 static void dwarf2_empty_die_ref_table PARAMS ((void));
 719
 720 static unsigned int dwarf2_get_ref_die_offset PARAMS ((struct attribute *));
 721
 722 struct die_info *follow_die_ref PARAMS ((unsigned int));
 723
 724 static struct type *dwarf2_fundamental_type PARAMS ((struct objfile *, int));
 725
 726 /* memory allocation interface */
 727
 728 static void dwarf2_free_tmp_obstack PARAMS ((PTR));
 729
 730 static struct dwarf_block *dwarf_alloc_block PARAMS ((void));
 731
 732 static struct abbrev_info *dwarf_alloc_abbrev PARAMS ((void));
 733
 734 static struct die_info *dwarf_alloc_die PARAMS ((void));
 735
 736 /* Try to locate the sections we need for DWARF 2 debugging
 737    information and return true if we have enough to do something.  */
 738
 739 int
 740 dwarf2_has_info (abfd)
 741      bfd *abfd;
 742 {
 743   dwarf_info_offset = dwarf_abbrev_offset = dwarf_line_offset = 0;
 744   bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL);
 745   if (dwarf_info_offset && dwarf_abbrev_offset)
 746     {
 747       return 1;
 748     }
 749   else
 750     {
 751       return 0;
 752     }
 753 }
 754
 755 /* This function is mapped across the sections and remembers the
 756    offset and size of each of the debugging sections we are interested
 757    in.  */
 758
 759 static void
 760 dwarf2_locate_sections (ignore_abfd, sectp, ignore_ptr)
 761      bfd *ignore_abfd;
 762      asection *sectp;
 763      PTR ignore_ptr;
 764 {
 765   if (STREQ (sectp->name, INFO_SECTION))
 766     {
 767       dwarf_info_offset = sectp->filepos;
 768       dwarf_info_size = bfd_get_section_size_before_reloc (sectp);
 769     }
 770   else if (STREQ (sectp->name, ABBREV_SECTION))
 771     {
 772       dwarf_abbrev_offset = sectp->filepos;
 773       dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp);
 774     }
 775   else if (STREQ (sectp->name, LINE_SECTION))
 776     {
 777       dwarf_line_offset = sectp->filepos;
 778       dwarf_line_size = bfd_get_section_size_before_reloc (sectp);
 779     }
 780   else if (STREQ (sectp->name, PUBNAMES_SECTION))
 781     {
 782       dwarf_pubnames_offset = sectp->filepos;
 783       dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp);
 784     }
 785   else if (STREQ (sectp->name, ARANGES_SECTION))
 786     {
 787       dwarf_aranges_offset = sectp->filepos;
 788       dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp);
 789     }
 790   else if (STREQ (sectp->name, LOC_SECTION))
 791     {
 792       dwarf_loc_offset = sectp->filepos;
 793       dwarf_loc_size = bfd_get_section_size_before_reloc (sectp);
 794     }
 795   else if (STREQ (sectp->name, MACINFO_SECTION))
 796     {
 797       dwarf_macinfo_offset = sectp->filepos;
 798       dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp);
 799     }
 800   else if (STREQ (sectp->name, STR_SECTION))
 801     {
 802       dwarf_str_offset = sectp->filepos;
 803       dwarf_str_size = bfd_get_section_size_before_reloc (sectp);
 804     }
 805 }
 806
 807 /* Build a partial symbol table.  */
 808
 809 void
 810 dwarf2_build_psymtabs (objfile, section_offsets, mainline)
 811     struct objfile *objfile;
 812     struct section_offsets *section_offsets;
 813     int mainline;
 814 {
 815
 816   /* We definitely need the .debug_info and .debug_abbrev sections */
 817
 818   dwarf_info_buffer = dwarf2_read_section (objfile,
 819                                            dwarf_info_offset,
 820                                            dwarf_info_size);
 821   dwarf_abbrev_buffer = dwarf2_read_section (objfile,
 822                                              dwarf_abbrev_offset,
 823                                              dwarf_abbrev_size);
 824   dwarf_line_buffer = dwarf2_read_section (objfile,
 825                                            dwarf_line_offset,
 826                                            dwarf_line_size);
 827
 828   if (mainline || objfile->global_psymbols.size == 0 ||
 829       objfile->static_psymbols.size == 0)
 830     {
 831       init_psymbol_list (objfile, 1024);
 832     }
 833
 834 #if 0
 835   if (dwarf_aranges_offset && dwarf_pubnames_offset)
 836     {
 837       /* Things are significanlty easier if we have .debug_aranges and
 838          .debug_pubnames sections */
 839
 840       dwarf2_build_psymtabs_easy (objfile, section_offsets, mainline);
 841     }
 842   else
 843 #endif
 844     /* only test this case for now */
 845     {
 846       /* In this case we have to work a bit harder */
 847       dwarf2_build_psymtabs_hard (objfile, section_offsets, mainline);
 848     }
 849 }
 850
 851 #if 0
 852 /* Build the partial symbol table from the information in the
 853    .debug_pubnames and .debug_aranges sections.  */
 854
 855 static void
 856 dwarf2_build_psymtabs_easy (objfile, section_offsets, mainline)
 857      struct objfile *objfile;
 858      struct section_offsets *section_offsets;
 859      int mainline;
 860 {
 861   bfd *abfd = objfile->obfd;
 862   char *aranges_buffer, *pubnames_buffer;
 863   char *aranges_ptr, *pubnames_ptr;
 864   unsigned int entry_length, version, info_offset, info_size;
 865
 866   pubnames_buffer = dwarf2_read_section (objfile,
 867                                          dwarf_pubnames_offset,
 868                                          dwarf_pubnames_size);
 869   pubnames_ptr = pubnames_buffer;
 870   while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size)
 871     {
 872       entry_length = read_4_bytes (abfd, pubnames_ptr);
 873       pubnames_ptr += 4;
 874       version = read_1_byte (abfd, pubnames_ptr);
 875       pubnames_ptr += 1;
 876       info_offset = read_4_bytes (abfd, pubnames_ptr);
 877       pubnames_ptr += 4;
 878       info_size = read_4_bytes (abfd, pubnames_ptr);
 879       pubnames_ptr += 4;
 880     }
 881
 882   aranges_buffer = dwarf2_read_section (objfile,
 883                                         dwarf_aranges_offset,
 884                                         dwarf_aranges_size);
 885
 886 }
 887 #endif
 888
 889 /* Build the partial symbol table by doing a quick pass through the
 890    .debug_info and .debug_abbrev sections.  */
 891
 892 static void
 893 dwarf2_build_psymtabs_hard (objfile, section_offsets, mainline)
 894      struct objfile *objfile;
 895      struct section_offsets *section_offsets;
 896      int mainline;
 897 {
 898   /* Instead of reading this into a big buffer, we should probably use
 899      mmap()  on architectures that support it. (FIXME) */
 900   bfd *abfd = objfile->obfd;
 901   char *info_ptr, *abbrev_ptr;
 902   char *beg_of_comp_unit;
 903   struct comp_unit_head cu_header;
 904   struct partial_die_info comp_unit_die;
 905   struct partial_symtab *pst;
 906   struct cleanup *back_to;
 907   int comp_unit_has_pc_info;
 908   CORE_ADDR lowpc, highpc;
 909
 910   info_ptr = dwarf_info_buffer;
 911   abbrev_ptr = dwarf_abbrev_buffer;
 912
 913   obstack_init (&dwarf2_tmp_obstack);
 914   back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
 915
 916   while ((unsigned int) (info_ptr - dwarf_info_buffer)
 917           + ((info_ptr - dwarf_info_buffer) % 4) < dwarf_info_size)
 918     {
 919       beg_of_comp_unit = info_ptr;
 920       cu_header.length = read_4_bytes (abfd, info_ptr);
 921       info_ptr += 4;
 922       cu_header.version = read_2_bytes (abfd, info_ptr);
 923       info_ptr += 2;
 924       cu_header.abbrev_offset = read_4_bytes (abfd, info_ptr);
 925       info_ptr += 4;
 926       cu_header.addr_size = read_1_byte (abfd, info_ptr);
 927       info_ptr += 1;
 928       address_size = cu_header.addr_size;
 929
 930       if (cu_header.version != 2)
 931         {
 932           error ("Dwarf Error: wrong version in compilation unit header.");
 933           return;
 934         }
 935
 936       /* Read the abbrevs for this compilation unit into a table */
 937       dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset);
 938       make_cleanup (dwarf2_empty_abbrev_table, NULL);
 939
 940       /* Read the compilation unit die */
 941       info_ptr = read_partial_die (&comp_unit_die, abfd,
 942                                    info_ptr, &comp_unit_has_pc_info);
 943
 944       /* Set the language we're debugging */
 945       set_cu_language (comp_unit_die.language);
 946
 947       /* Allocate a new partial symbol table structure */
 948       pst = start_psymtab_common (objfile, section_offsets,
 949                                   comp_unit_die.name ? comp_unit_die.name : "",
 950                                   comp_unit_die.lowpc,
 951                                   objfile->global_psymbols.next,
 952                                   objfile->static_psymbols.next);
 953
 954       pst->read_symtab_private = (char *)
 955         obstack_alloc (&objfile->psymbol_obstack, sizeof (struct dwarf2_pinfo));
 956       cu_header_offset = beg_of_comp_unit - dwarf_info_buffer;
 957       DWARF_INFO_BUFFER(pst) = dwarf_info_buffer;
 958       DWARF_INFO_OFFSET(pst) = beg_of_comp_unit - dwarf_info_buffer;
 959       DWARF_ABBREV_BUFFER(pst) = dwarf_abbrev_buffer;
 960       DWARF_ABBREV_SIZE(pst) = dwarf_abbrev_size;
 961       DWARF_LINE_BUFFER(pst) = dwarf_line_buffer;
 962       baseaddr = ANOFFSET (section_offsets, 0);
 963
 964       /* Store the function that reads in the rest of the symbol table */
 965       pst->read_symtab = dwarf2_psymtab_to_symtab;
 966
 967       /* Read the rest of the partial symbols from this comp unit */
 968       info_ptr = scan_partial_symbols (info_ptr, objfile, &lowpc, &highpc);
 969
 970       /* If the compilation unit didn't have an explicit address range,
 971          then use the information extracted from its child dies.  */
 972       if (!comp_unit_has_pc_info)
 973         {
 974           comp_unit_die.lowpc  = lowpc;
 975           comp_unit_die.highpc = highpc;
 976         }
 977       pst->textlow  = comp_unit_die.lowpc + baseaddr;
 978       pst->texthigh = comp_unit_die.highpc + baseaddr;
 979
 980       pst->n_global_syms = objfile->global_psymbols.next -
 981         (objfile->global_psymbols.list + pst->globals_offset);
 982       pst->n_static_syms = objfile->static_psymbols.next -
 983         (objfile->static_psymbols.list + pst->statics_offset);
 984       sort_pst_symbols (pst);
 985
 986       /* If there is already a psymtab or symtab for a file of this
 987          name, remove it. (If there is a symtab, more drastic things
 988          also happen.) This happens in VxWorks.  */
 989       free_named_symtabs (pst->filename);
 990
 991       info_ptr = beg_of_comp_unit + cu_header.length + 4;
 992     }
 993   do_cleanups (back_to);
 994 }
 995
 996 /* Read in all interesting dies to the end of the compilation unit.  */
 997
 998 static char *
 999 scan_partial_symbols (info_ptr, objfile, lowpc, highpc)
1000      char *info_ptr;
1001      struct objfile *objfile;
1002      CORE_ADDR *lowpc;
1003      CORE_ADDR *highpc;
1004 {
1005   bfd *abfd = objfile->obfd;
1006   struct partial_die_info pdi;
1007   int nesting_level = 1;        /* we've already read in comp_unit_die */
1008   int has_pc_info;
1009
1010   *lowpc  = ((CORE_ADDR) -1);
1011   *highpc = ((CORE_ADDR) 0);
1012
1013   while (nesting_level)
1014     {
1015       info_ptr = read_partial_die (&pdi, abfd, info_ptr, &has_pc_info);
1016
1017       if (pdi.name)
1018         {
1019           switch (pdi.tag)
1020             {
1021             case DW_TAG_subprogram:
1022               if (has_pc_info)
1023                 {
1024                   if (pdi.lowpc < *lowpc)
1025                     {
1026                       *lowpc = pdi.lowpc;
1027                     }
1028                   if (pdi.highpc > *highpc)
1029                     {
1030                       *highpc = pdi.highpc;
1031                     }
1032                   if ((pdi.is_external || nesting_level == 1)
1033                       && !pdi.is_declaration)
1034                     {
1035                       add_partial_symbol (&pdi, objfile);
1036                     }
1037                 }
1038               break;
1039             case DW_TAG_variable:
1040             case DW_TAG_typedef:
1041             case DW_TAG_class_type:
1042             case DW_TAG_structure_type:
1043             case DW_TAG_union_type:
1044             case DW_TAG_enumeration_type:
1045               if ((pdi.is_external || nesting_level == 1)
1046                   && !pdi.is_declaration)
1047                 {
1048                   add_partial_symbol (&pdi, objfile);
1049                 }
1050               break;
1051             case DW_TAG_enumerator:
1052               /* File scope enumerators are added to the partial symbol
1053                  table.  */
1054               if (nesting_level == 2)
1055                 add_partial_symbol (&pdi, objfile);
1056               break;
1057             case DW_TAG_base_type:
1058               /* File scope base type definitions are added to the partial
1059                  symbol table.  */
1060               if (nesting_level == 1)
1061                 add_partial_symbol (&pdi, objfile);
1062               break;
1063             default:
1064               break;
1065             }
1066         }
1067
1068       /* If the die has a sibling, skip to the sibling.
1069          Do not skip enumeration types, we want to record their
1070          enumerators.  */
1071       if (pdi.sibling && pdi.tag != DW_TAG_enumeration_type)
1072         {
1073           info_ptr = pdi.sibling;
1074         }
1075       else if (pdi.has_children)
1076         {
1077           /* Die has children, but the optional DW_AT_sibling attribute
1078              is missing.  */
1079           nesting_level++;
1080         }
1081
1082       if (pdi.tag == 0)
1083         {
1084           nesting_level--;
1085         }
1086     }
1087
1088   /* If we didn't find a lowpc, set it to highpc to avoid complaints
1089      from `maint check'.  */
1090   if (*lowpc == ((CORE_ADDR) -1))
1091     *lowpc = *highpc;
1092   return info_ptr;
1093 }
1094
1095 static void
1096 add_partial_symbol (pdi, objfile)
1097      struct partial_die_info *pdi;
1098      struct objfile *objfile;
1099 {
1100   CORE_ADDR addr = 0;
1101
1102   switch (pdi->tag)
1103     {
1104     case DW_TAG_subprogram:
1105       if (pdi->is_external)
1106         {
1107           prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1108                                       mst_text, objfile);
1109           add_psymbol_to_list (pdi->name, strlen (pdi->name),
1110                                VAR_NAMESPACE, LOC_BLOCK,
1111                                &objfile->global_psymbols,
1112                                0, pdi->lowpc + baseaddr, cu_language, objfile);
1113         }
1114       else
1115         {
1116           prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1117                                       mst_file_text, objfile);
1118           add_psymbol_to_list (pdi->name, strlen (pdi->name),
1119                                VAR_NAMESPACE, LOC_BLOCK,
1120                                &objfile->static_psymbols,
1121                                0, pdi->lowpc + baseaddr, cu_language, objfile);
1122         }
1123       break;
1124     case DW_TAG_variable:
1125       if (pdi->is_external)
1126         {
1127           /* Global Variable.
1128              Don't enter into the minimal symbol tables as there is
1129              a minimal symbol table entry from the ELF symbols already.
1130              Enter into partial symbol table if it has a location
1131              descriptor or a type.
1132              If the location descriptor is missing, new_symbol will create
1133              a LOC_UNRESOLVED symbol, the address of the variable will then
1134              be determined from the minimal symbol table whenever the variable
1135              is referenced.
1136              The address for the partial symbol table entry is not
1137              used by GDB, but it comes in handy for debugging partial symbol
1138              table building.  */
1139
1140           if (pdi->locdesc)
1141             addr = decode_locdesc (pdi->locdesc, objfile);
1142           if (pdi->locdesc || pdi->has_type)
1143             add_psymbol_to_list (pdi->name, strlen (pdi->name),
1144                                  VAR_NAMESPACE, LOC_STATIC,
1145                                  &objfile->global_psymbols,
1146                                  0, addr + baseaddr, cu_language, objfile);
1147         }
1148       else
1149         {
1150           /* Static Variable. Skip symbols without location descriptors.  */
1151           if (pdi->locdesc == NULL)
1152             return;
1153           addr = decode_locdesc (pdi->locdesc, objfile);
1154           prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1155                                       mst_file_data, objfile);
1156           add_psymbol_to_list (pdi->name, strlen (pdi->name),
1157                                VAR_NAMESPACE, LOC_STATIC,
1158                                &objfile->static_psymbols,
1159                                0, addr + baseaddr, cu_language, objfile);
1160         }
1161       break;
1162     case DW_TAG_typedef:
1163     case DW_TAG_base_type:
1164       add_psymbol_to_list (pdi->name, strlen (pdi->name),
1165                            VAR_NAMESPACE, LOC_TYPEDEF,
1166                            &objfile->static_psymbols,
1167                            0, (CORE_ADDR) 0, cu_language, objfile);
1168       break;
1169     case DW_TAG_class_type:
1170     case DW_TAG_structure_type:
1171     case DW_TAG_union_type:
1172     case DW_TAG_enumeration_type:
1173       /* Skip aggregate types without children, these are external
1174          references.  */
1175       if (pdi->has_children == 0)
1176         return;
1177       add_psymbol_to_list (pdi->name, strlen (pdi->name),
1178                            STRUCT_NAMESPACE, LOC_TYPEDEF,
1179                            &objfile->static_psymbols,
1180                            0, (CORE_ADDR) 0, cu_language, objfile);
1181
1182       if (cu_language == language_cplus)
1183         {
1184           /* For C++, these implicitly act as typedefs as well. */
1185           add_psymbol_to_list (pdi->name, strlen (pdi->name),
1186                                VAR_NAMESPACE, LOC_TYPEDEF,
1187                                &objfile->static_psymbols,
1188                                0, (CORE_ADDR) 0, cu_language, objfile);
1189         }
1190       break;
1191     case DW_TAG_enumerator:
1192       add_psymbol_to_list (pdi->name, strlen (pdi->name),
1193                            VAR_NAMESPACE, LOC_CONST,
1194                            &objfile->static_psymbols,
1195                            0, (CORE_ADDR) 0, cu_language, objfile);
1196       break;
1197     default:
1198       break;
1199     }
1200 }
1201
1202 /* Expand this partial symbol table into a full symbol table.  */
1203
1204 static void
1205 dwarf2_psymtab_to_symtab (pst)
1206      struct partial_symtab *pst;
1207 {
1208   /* FIXME: This is barely more than a stub.  */
1209   if (pst != NULL)
1210     {
1211       if (pst->readin)
1212         {
1213           warning ("bug: psymtab for %s is already read in.", pst->filename);
1214         }
1215       else
1216         {
1217           if (info_verbose)
1218             {
1219               printf_filtered ("Reading in symbols for %s...", pst->filename);
1220               gdb_flush (gdb_stdout);
1221             }
1222
1223           psymtab_to_symtab_1 (pst);
1224
1225           /* Finish up the debug error message.  */
1226           if (info_verbose)
1227             printf_filtered ("done.\n");
1228         }
1229     }
1230 }
1231
1232 static void
1233 psymtab_to_symtab_1 (pst)
1234      struct partial_symtab *pst;
1235 {
1236   struct objfile *objfile = pst->objfile;
1237   bfd *abfd = objfile->obfd;
1238   struct comp_unit_head cu_header;
1239   struct die_info *dies;
1240   unsigned long offset;
1241   CORE_ADDR lowpc, highpc;
1242   struct die_info *child_die;
1243   char *info_ptr;
1244   struct symtab *symtab;
1245   struct cleanup *back_to;
1246
1247   /* Set local variables from the partial symbol table info.  */
1248   offset = DWARF_INFO_OFFSET(pst);
1249   dwarf_info_buffer = DWARF_INFO_BUFFER(pst);
1250   dwarf_abbrev_buffer = DWARF_ABBREV_BUFFER(pst);
1251   dwarf_abbrev_size = DWARF_ABBREV_SIZE(pst);
1252   dwarf_line_buffer = DWARF_LINE_BUFFER(pst);
1253   baseaddr = ANOFFSET (pst->section_offsets, 0);
1254   cu_header_offset = offset;
1255   info_ptr = dwarf_info_buffer + offset;
1256
1257   obstack_init (&dwarf2_tmp_obstack);
1258   back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
1259
1260   buildsym_init ();
1261   make_cleanup (really_free_pendings, NULL);
1262
1263   /* read in the comp_unit header  */
1264   cu_header.length = read_4_bytes (abfd, info_ptr);
1265   info_ptr += 4;
1266   cu_header.version = read_2_bytes (abfd, info_ptr);
1267   info_ptr += 2;
1268   cu_header.abbrev_offset = read_4_bytes (abfd, info_ptr);
1269   info_ptr += 4;
1270   cu_header.addr_size = read_1_byte (abfd, info_ptr);
1271   info_ptr += 1;
1272
1273   /* Read the abbrevs for this compilation unit  */
1274   dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset);
1275   make_cleanup (dwarf2_empty_abbrev_table, NULL);
1276
1277   dies = read_comp_unit (info_ptr, abfd);
1278
1279   make_cleanup (free_die_list, dies);
1280
1281   /* Do line number decoding in read_file_scope () */
1282   process_die (dies, objfile);
1283
1284   if (!dwarf2_get_pc_bounds (dies, &lowpc, &highpc, objfile))
1285     {
1286       /* Some compilers don't define a DW_AT_high_pc attribute for
1287          the compilation unit.   If the DW_AT_high_pc is missing,
1288          synthesize it, by scanning the DIE's below the compilation unit.  */
1289       highpc = 0;
1290       if (dies->has_children)
1291         {
1292           child_die = dies->next;
1293           while (child_die && child_die->tag)
1294             {
1295               if (child_die->tag == DW_TAG_subprogram)
1296                 {
1297                   CORE_ADDR low, high;
1298
1299                   if (dwarf2_get_pc_bounds (child_die, &low, &high, objfile))
1300                     {
1301                       highpc = max (highpc, high);
1302                     }
1303                 }
1304               child_die = sibling_die (child_die);
1305             }
1306         }
1307     }
1308   symtab = end_symtab (highpc + baseaddr, objfile, 0);
1309
1310   /* Set symtab language to language from DW_AT_language.
1311      If the compilation is from a C file generated by language preprocessors,
1312      do not set the language if it was already deduced by start_subfile.  */
1313   if (symtab != NULL
1314       && !(cu_language == language_c && symtab->language != language_c))
1315     {
1316       symtab->language = cu_language;
1317     }
1318   pst->symtab = symtab;
1319   pst->readin = 1;
1320   sort_symtab_syms (pst->symtab);
1321
1322   do_cleanups (back_to);
1323 }
1324
1325 /* Process a die and its children.  */
1326
1327 static void
1328 process_die (die, objfile)
1329      struct die_info *die;
1330      struct objfile *objfile;
1331 {
1332   switch (die->tag)
1333     {
1334     case DW_TAG_padding:
1335       break;
1336     case DW_TAG_compile_unit:
1337       read_file_scope (die, objfile);
1338       break;
1339     case DW_TAG_subprogram:
1340       read_subroutine_type (die, objfile);
1341       read_func_scope (die, objfile);
1342       break;
1343     case DW_TAG_inlined_subroutine:
1344       /* FIXME:  These are ignored for now.
1345          They could be used to set breakpoints on all inlined instances
1346          of a function and make GDB `next' properly over inlined functions.  */
1347       break;
1348     case DW_TAG_lexical_block:
1349       read_lexical_block_scope (die, objfile);
1350       break;
1351     case DW_TAG_class_type:
1352     case DW_TAG_structure_type:
1353     case DW_TAG_union_type:
1354       read_structure_scope (die, objfile);
1355       break;
1356     case DW_TAG_enumeration_type:
1357       read_enumeration (die, objfile);
1358       break;
1359     case DW_TAG_subroutine_type:
1360       read_subroutine_type (die, objfile);
1361       break;
1362     case DW_TAG_array_type:
1363       read_array_type (die, objfile);
1364       break;
1365     case DW_TAG_pointer_type:
1366       read_tag_pointer_type (die, objfile);
1367       break;
1368     case DW_TAG_ptr_to_member_type:
1369       read_tag_ptr_to_member_type (die, objfile);
1370       break;
1371     case DW_TAG_reference_type:
1372       read_tag_reference_type (die, objfile);
1373       break;
1374     case DW_TAG_string_type:
1375       read_tag_string_type (die, objfile);
1376       break;
1377     case DW_TAG_base_type:
1378       read_base_type (die, objfile);
1379       if (dwarf_attr (die, DW_AT_name))
1380         {
1381           /* Add a typedef symbol for the base type definition.  */
1382           new_symbol (die, die->type, objfile);
1383         }
1384       break;
1385     case DW_TAG_common_block:
1386       read_common_block (die, objfile);
1387       break;
1388     case DW_TAG_common_inclusion:
1389       break;
1390     default:
1391       new_symbol (die, NULL, objfile);
1392       break;
1393     }
1394 }
1395
1396 static void
1397 read_file_scope (die, objfile)
1398      struct die_info *die;
1399      struct objfile *objfile;
1400 {
1401   unsigned int line_offset = 0;
1402   CORE_ADDR lowpc  = ((CORE_ADDR) -1);
1403   CORE_ADDR highpc = ((CORE_ADDR) 0);
1404   struct attribute *attr;
1405   char *name = "<unknown>";
1406   char *comp_dir = NULL;
1407   struct die_info *child_die;
1408   bfd *abfd = objfile->obfd;
1409
1410   if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile))
1411     {
1412       if (die->has_children)
1413         {
1414           child_die = die->next;
1415           while (child_die && child_die->tag)
1416             {
1417               if (child_die->tag == DW_TAG_subprogram)
1418                 {
1419                   CORE_ADDR low, high;
1420
1421                   if (dwarf2_get_pc_bounds (child_die, &low, &high, objfile))
1422                     {
1423                       lowpc = min (lowpc, low);
1424                       highpc = max (highpc, high);
1425                     }
1426                 }
1427               child_die = sibling_die (child_die);
1428             }
1429         }
1430     }
1431
1432   /* If we didn't find a lowpc, set it to highpc to avoid complaints
1433      from finish_block.  */
1434   if (lowpc == ((CORE_ADDR) -1))
1435     lowpc = highpc;
1436   lowpc += baseaddr;
1437   highpc += baseaddr;
1438
1439   attr = dwarf_attr (die, DW_AT_name);
1440   if (attr)
1441     {
1442       name = DW_STRING (attr);
1443     }
1444   attr = dwarf_attr (die, DW_AT_comp_dir);
1445   if (attr)
1446     {
1447       comp_dir = DW_STRING (attr);
1448       if (comp_dir)
1449         {
1450           /* Irix 6.2 native cc prepends <machine>.: to the compilation
1451              directory, get rid of it.  */
1452           char *cp = strchr (comp_dir, ':');
1453
1454           if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1455             comp_dir = cp + 1;
1456         }
1457     }
1458
1459   if (objfile->ei.entry_point >= lowpc &&
1460       objfile->ei.entry_point < highpc)
1461     {
1462       objfile->ei.entry_file_lowpc = lowpc;
1463       objfile->ei.entry_file_highpc = highpc;
1464     }
1465
1466   attr = dwarf_attr (die, DW_AT_language);
1467   if (attr)
1468     {
1469       set_cu_language (DW_UNSND (attr));
1470     }
1471
1472 #if 0
1473     /* FIXME:Do something here.  */
1474     if (dip->at_producer != NULL)
1475     {
1476       handle_producer (dip->at_producer);
1477     }
1478 #endif
1479
1480   /* The compilation unit may be in a different language or objfile,
1481      zero out all remembered fundamental types.  */
1482   memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
1483
1484   start_symtab (name, comp_dir, lowpc);
1485   record_debugformat ("DWARF 2");
1486
1487   /* Decode line number information if present.  */
1488   attr = dwarf_attr (die, DW_AT_stmt_list);
1489   if (attr)
1490     {
1491       line_offset = DW_UNSND (attr);
1492       dwarf_decode_lines (line_offset, comp_dir, abfd);
1493     }
1494
1495   /* Process all dies in compilation unit.  */
1496   if (die->has_children)
1497     {
1498       child_die = die->next;
1499       while (child_die && child_die->tag)
1500         {
1501           process_die (child_die, objfile);
1502           child_die = sibling_die (child_die);
1503         }
1504     }
1505 }
1506
1507 static void
1508 read_func_scope (die, objfile)
1509      struct die_info *die;
1510      struct objfile *objfile;
1511 {
1512   register struct context_stack *new;
1513   CORE_ADDR lowpc;
1514   CORE_ADDR highpc;
1515   struct die_info *child_die;
1516   struct attribute *attr;
1517   char *name;
1518
1519   name = dwarf2_linkage_name (die);
1520
1521   /* Ignore functions with missing or empty names and functions with
1522      missing or invalid low and high pc attributes.  */
1523   if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile))
1524     return;
1525
1526   lowpc += baseaddr;
1527   highpc += baseaddr;
1528
1529   if (objfile->ei.entry_point >= lowpc &&
1530       objfile->ei.entry_point < highpc)
1531     {
1532       objfile->ei.entry_func_lowpc = lowpc;
1533       objfile->ei.entry_func_highpc = highpc;
1534     }
1535
1536   if (STREQ (name, "main"))     /* FIXME: hardwired name */
1537     {
1538       objfile->ei.main_func_lowpc = lowpc;
1539       objfile->ei.main_func_highpc = highpc;
1540     }
1541
1542   /* Decode DW_AT_frame_base location descriptor if present, keep result
1543      for DW_OP_fbreg operands in decode_locdesc.  */
1544   frame_base_reg = -1;
1545   frame_base_offset = 0;
1546   attr = dwarf_attr (die, DW_AT_frame_base);
1547   if (attr)
1548     {
1549       CORE_ADDR addr = decode_locdesc (DW_BLOCK (attr), objfile);
1550       if (isreg)
1551         frame_base_reg = addr;
1552       else if (offreg)
1553         {
1554           frame_base_reg = basereg;
1555           frame_base_offset = addr;
1556         }
1557       else
1558         complain (&dwarf2_unsupported_at_frame_base, name);
1559     }
1560
1561   new = push_context (0, lowpc);
1562   new->name = new_symbol (die, die->type, objfile);
1563   list_in_scope = &local_symbols;
1564
1565   if (die->has_children)
1566     {
1567       child_die = die->next;
1568       while (child_die && child_die->tag)
1569         {
1570           process_die (child_die, objfile);
1571           child_die = sibling_die (child_die);
1572         }
1573     }
1574
1575   new = pop_context ();
1576   /* Make a block for the local symbols within.  */
1577   finish_block (new->name, &local_symbols, new->old_blocks,
1578                 lowpc, highpc, objfile);
1579   list_in_scope = &file_symbols;
1580 }
1581
1582 /* Process all the DIES contained within a lexical block scope.  Start
1583    a new scope, process the dies, and then close the scope.  */
1584
1585 static void
1586 read_lexical_block_scope (die, objfile)
1587      struct die_info *die;
1588      struct objfile *objfile;
1589 {
1590   register struct context_stack *new;
1591   CORE_ADDR lowpc, highpc;
1592   struct die_info *child_die;
1593
1594   /* Ignore blocks with missing or invalid low and high pc attributes.  */
1595   if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile))
1596     return;
1597   lowpc += baseaddr;
1598   highpc += baseaddr;
1599
1600   push_context (0, lowpc);
1601   if (die->has_children)
1602     {
1603       child_die = die->next;
1604       while (child_die && child_die->tag)
1605         {
1606           process_die (child_die, objfile);
1607           child_die = sibling_die (child_die);
1608         }
1609     }
1610   new = pop_context ();
1611
1612   if (local_symbols != NULL)
1613     {
1614       finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
1615                     highpc, objfile);
1616     }
1617   local_symbols = new->locals;
1618 }
1619
1620 /* Get low and high pc attributes from a die.
1621    Return 1 if the attributes are present and valid, otherwise, return 0.  */
1622
1623 static int
1624 dwarf2_get_pc_bounds (die, lowpc, highpc, objfile)
1625      struct die_info *die;
1626      CORE_ADDR *lowpc;
1627      CORE_ADDR *highpc;
1628      struct objfile *objfile;
1629 {
1630   struct attribute *attr;
1631   CORE_ADDR low;
1632   CORE_ADDR high;
1633
1634   attr = dwarf_attr (die, DW_AT_low_pc);
1635   if (attr)
1636     low = DW_ADDR (attr);
1637   else
1638     return 0;
1639   attr = dwarf_attr (die, DW_AT_high_pc);
1640   if (attr)
1641     high = DW_ADDR (attr);
1642   else
1643     return 0;
1644
1645   if (high < low)
1646     return 0;
1647
1648   /* When using the GNU linker, .gnu.linkonce. sections are used to
1649      eliminate duplicate copies of functions and vtables and such.
1650      The linker will arbitrarily choose one and discard the others.
1651      The AT_*_pc values for such functions refer to local labels in
1652      these sections.  If the section from that file was discarded, the
1653      labels are not in the output, so the relocs get a value of 0.
1654      If this is a discarded function, mark the pc bounds as invalid,
1655      so that GDB will ignore it.  */
1656   if (low == 0 && (bfd_get_file_flags (objfile->obfd) & HAS_RELOC) == 0)
1657     return 0;
1658
1659   *lowpc = low;
1660   *highpc = high;
1661   return 1;
1662 }
1663
1664 /* Add an aggregate field to the field list.  */
1665
1666 static void
1667 dwarf2_add_field (fip, die, objfile)
1668      struct field_info *fip;
1669      struct die_info *die;
1670      struct objfile *objfile;
1671 {
1672   struct nextfield *new_field;
1673   struct attribute *attr;
1674   struct field *fp;
1675   char *fieldname = "";
1676
1677   /* Allocate a new field list entry and link it in.  */
1678   new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
1679   make_cleanup (free, new_field);
1680   memset (new_field, 0, sizeof (struct nextfield));
1681   new_field->next = fip->fields;
1682   fip->fields = new_field;
1683   fip->nfields++;
1684
1685   /* Handle accessibility and virtuality of field.
1686      The default accessibility for members is public, the default
1687      accessibility for inheritance is private.  */
1688   if (die->tag != DW_TAG_inheritance)
1689     new_field->accessibility = DW_ACCESS_public;
1690   else
1691     new_field->accessibility = DW_ACCESS_private;
1692   new_field->virtuality = DW_VIRTUALITY_none;
1693
1694   attr = dwarf_attr (die, DW_AT_accessibility);
1695   if (attr)
1696     new_field->accessibility = DW_UNSND (attr);
1697   if (new_field->accessibility != DW_ACCESS_public)
1698     fip->non_public_fields = 1;
1699   attr = dwarf_attr (die, DW_AT_virtuality);
1700   if (attr)
1701     new_field->virtuality = DW_UNSND (attr);
1702
1703   fp = &new_field->field;
1704   if (die->tag == DW_TAG_member)
1705     {
1706       /* Get type of field.  */
1707       fp->type = die_type (die, objfile);
1708
1709       /* Get bit size of field (zero if none).  */
1710       attr = dwarf_attr (die, DW_AT_bit_size);
1711       if (attr)
1712         {
1713           fp->bitsize = DW_UNSND (attr);
1714         }
1715       else
1716         {
1717           fp->bitsize = 0;
1718         }
1719
1720       /* Get bit offset of field.  */
1721       attr = dwarf_attr (die, DW_AT_data_member_location);
1722       if (attr)
1723         {
1724           fp->bitpos =
1725             decode_locdesc (DW_BLOCK (attr), objfile) * bits_per_byte;
1726         }
1727       else
1728         fp->bitpos = 0;
1729       attr = dwarf_attr (die, DW_AT_bit_offset);
1730       if (attr)
1731         {
1732           if (BITS_BIG_ENDIAN)
1733             {
1734               /* For big endian bits, the DW_AT_bit_offset gives the
1735                  additional bit offset from the MSB of the containing
1736                  anonymous object to the MSB of the field.  We don't
1737                  have to do anything special since we don't need to
1738                  know the size of the anonymous object.  */
1739               fp->bitpos += DW_UNSND (attr);
1740             }
1741           else
1742             {
1743               /* For little endian bits, compute the bit offset to the
1744                  MSB of the anonymous object, subtract off the number of
1745                  bits from the MSB of the field to the MSB of the
1746                  object, and then subtract off the number of bits of
1747                  the field itself.  The result is the bit offset of
1748                  the LSB of the field.  */
1749               int anonymous_size;
1750               int bit_offset = DW_UNSND (attr);
1751
1752               attr = dwarf_attr (die, DW_AT_byte_size);
1753               if (attr)
1754                 {
1755                   /* The size of the anonymous object containing
1756                      the bit field is explicit, so use the
1757                      indicated size (in bytes).  */
1758                   anonymous_size = DW_UNSND (attr);
1759                 }
1760               else
1761                 {
1762                   /* The size of the anonymous object containing
1763                      the bit field must be inferred from the type
1764                      attribute of the data member containing the
1765                      bit field.  */
1766                   anonymous_size = TYPE_LENGTH (fp->type);
1767                 }
1768               fp->bitpos +=
1769                 anonymous_size * bits_per_byte - bit_offset - fp->bitsize;
1770             }
1771         }
1772
1773       /* Get name of field.  */
1774       attr = dwarf_attr (die, DW_AT_name);
1775       if (attr && DW_STRING (attr))
1776         fieldname = DW_STRING (attr);
1777       fp->name = obsavestring (fieldname, strlen (fieldname),
1778                                &objfile->type_obstack);
1779
1780       /* Change accessibility for artificial fields (e.g. virtual table
1781          pointer or virtual base class pointer) to private.  */
1782       if (dwarf_attr (die, DW_AT_artificial))
1783         {
1784           new_field->accessibility = DW_ACCESS_private;
1785           fip->non_public_fields = 1;
1786         }
1787     }
1788   else if (die->tag == DW_TAG_variable)
1789     {
1790       char *physname;
1791       char *cp;
1792
1793       /* C++ static member.
1794          Get physical name, extract field name from physical name.  */
1795       physname = dwarf2_linkage_name (die);
1796       if (physname == NULL)
1797         return;
1798
1799       cp = physname;
1800       while (*cp && !is_cplus_marker (*cp))
1801         cp++;
1802       if (*cp)
1803         fieldname = cp + 1;
1804       if (*fieldname == '\0')
1805         {
1806           complain (&dwarf2_bad_static_member_name, physname);
1807         }
1808
1809       fp->bitpos = -1;
1810       fp->bitsize = (long) obsavestring (physname, strlen (physname),
1811                                          &objfile->type_obstack);
1812       fp->type = die_type (die, objfile);
1813       fp->name = obsavestring (fieldname, strlen (fieldname),
1814                                &objfile->type_obstack);
1815     }
1816   else if (die->tag == DW_TAG_inheritance)
1817     {
1818       /* C++ base class field.  */
1819       attr = dwarf_attr (die, DW_AT_data_member_location);
1820       if (attr)
1821         fp->bitpos = decode_locdesc (DW_BLOCK (attr), objfile) * bits_per_byte;
1822       fp->bitsize = 0;
1823       fp->type = die_type (die, objfile);
1824       fp->name = type_name_no_tag (fp->type);
1825       fip->nbaseclasses++;
1826     }
1827 }
1828
1829 /* Create the vector of fields, and attach it to the type.  */
1830
1831 static void
1832 dwarf2_attach_fields_to_type (fip, type, objfile)
1833      struct field_info *fip;
1834      struct type *type;
1835      struct objfile *objfile;
1836 {
1837   int nfields = fip->nfields;
1838
1839   /* Record the field count, allocate space for the array of fields,
1840      and create blank accessibility bitfields if necessary.  */
1841   TYPE_NFIELDS (type) = nfields;
1842   TYPE_FIELDS (type) = (struct field *)
1843     TYPE_ALLOC (type, sizeof (struct field) * nfields);
1844   memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
1845
1846   if (fip->non_public_fields)
1847     {
1848       ALLOCATE_CPLUS_STRUCT_TYPE (type);
1849
1850       TYPE_FIELD_PRIVATE_BITS (type) =
1851         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
1852       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
1853
1854       TYPE_FIELD_PROTECTED_BITS (type) =
1855         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
1856       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
1857
1858       TYPE_FIELD_IGNORE_BITS (type) =
1859         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
1860       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
1861     }
1862
1863   /* If the type has baseclasses, allocate and clear a bit vector for
1864      TYPE_FIELD_VIRTUAL_BITS.  */
1865   if (fip->nbaseclasses)
1866     {
1867       int num_bytes = B_BYTES (fip->nbaseclasses);
1868       char *pointer;
1869
1870       ALLOCATE_CPLUS_STRUCT_TYPE (type);
1871       pointer = (char *) TYPE_ALLOC (type, num_bytes);
1872       TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
1873       B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
1874       TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
1875     }
1876
1877   /* Copy the saved-up fields into the field vector.  Start from the head
1878      of the list, adding to the tail of the field array, so that they end
1879      up in the same order in the array in which they were added to the list.  */
1880   while (nfields-- > 0)
1881     {
1882       TYPE_FIELD (type, nfields) = fip->fields->field;
1883       switch (fip->fields->accessibility)
1884         {
1885           case DW_ACCESS_private:
1886             SET_TYPE_FIELD_PRIVATE (type, nfields);
1887             break;
1888
1889           case DW_ACCESS_protected:
1890             SET_TYPE_FIELD_PROTECTED (type, nfields);
1891             break;
1892
1893           case DW_ACCESS_public:
1894             break;
1895
1896           default:
1897             /* Unknown accessibility.  Complain and treat it as public.  */
1898             {
1899               complain (&dwarf2_unsupported_accessibility,
1900                         fip->fields->accessibility);
1901             }
1902             break;
1903         }
1904       if (nfields < fip->nbaseclasses)
1905         {
1906           switch (fip->fields->virtuality)
1907             {
1908               case DW_VIRTUALITY_virtual:
1909               case DW_VIRTUALITY_pure_virtual:
1910                 SET_TYPE_FIELD_VIRTUAL (type, nfields);
1911                 break;
1912             }
1913         }
1914       fip->fields = fip->fields->next;
1915     }
1916 }
1917
1918 /* Skip to the end of a member function name in a mangled name.  */
1919
1920 static char *
1921 skip_member_fn_name (physname)
1922      char *physname;
1923 {
1924   char *endname = physname;
1925
1926   /* Skip over leading underscores.  */
1927   while (*endname == '_')
1928     endname++;
1929
1930   /* Find two succesive underscores.  */
1931   do
1932     endname = strchr (endname, '_');
1933   while (endname != NULL && *++endname != '_');
1934
1935   if (endname == NULL)
1936     {
1937       complain (&dwarf2_bad_member_name_complaint, physname);
1938       endname = physname;
1939     }
1940   else
1941     {
1942       /* Take care of trailing underscores.  */
1943       if (endname[1] != '_')
1944         endname--;
1945     }
1946   return endname;
1947 }
1948
1949 /* Add a member function to the proper fieldlist.  */
1950
1951 static void
1952 dwarf2_add_member_fn (fip, die, type, objfile)
1953      struct field_info *fip;
1954      struct die_info *die;
1955      struct type *type;
1956      struct objfile *objfile;
1957 {
1958   struct attribute *attr;
1959   struct fnfieldlist *flp;
1960   int i;
1961   struct fn_field *fnp;
1962   char *fieldname;
1963   char *physname;
1964   struct nextfnfield *new_fnfield;
1965
1966   /* Extract member function name from mangled name.  */
1967   physname = dwarf2_linkage_name (die);
1968   if (physname == NULL)
1969     return;
1970   if ((physname[0] == '_' && physname[1] == '_'
1971         && strchr ("0123456789Qt", physname[2]))
1972       || DESTRUCTOR_PREFIX_P (physname))
1973     {
1974       /* Constructor and destructor field names are set to the name
1975          of the class, but without template parameter lists.
1976          The name might be missing for anonymous aggregates.  */
1977       if (TYPE_TAG_NAME (type))
1978         {
1979           char *p = strchr (TYPE_TAG_NAME (type), '<');
1980
1981           if (p == NULL)
1982             fieldname = TYPE_TAG_NAME (type);
1983           else
1984             fieldname = obsavestring (TYPE_TAG_NAME (type),
1985                                       p - TYPE_TAG_NAME (type),
1986                                       &objfile->type_obstack);
1987         }
1988       else
1989         {
1990           char *anon_name = "";
1991           fieldname = obsavestring (anon_name, strlen (anon_name),
1992                                     &objfile->type_obstack);
1993         }
1994     }
1995   else
1996     {
1997       char *endname = skip_member_fn_name (physname);
1998
1999       /* Ignore member function if we were unable not extract the member
2000          function name.  */
2001       if (endname == physname)
2002         return;
2003       fieldname = obsavestring (physname, endname - physname,
2004                                 &objfile->type_obstack);
2005     }
2006
2007   /* Look up member function name in fieldlist.  */
2008   for (i = 0; i < fip->nfnfields; i++)
2009     {
2010       if (STREQ (fip->fnfieldlists[i].name, fieldname))
2011         break;
2012     }
2013
2014   /* Create new list element if necessary.  */
2015   if (i < fip->nfnfields)
2016     flp = &fip->fnfieldlists[i];
2017   else
2018     {
2019       if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
2020         {
2021           fip->fnfieldlists = (struct fnfieldlist *)
2022             xrealloc (fip->fnfieldlists,
2023                       (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
2024                         * sizeof (struct fnfieldlist));
2025           if (fip->nfnfields == 0)
2026             make_cleanup (free_current_contents, &fip->fnfieldlists);
2027         }
2028       flp = &fip->fnfieldlists[fip->nfnfields];
2029       flp->name = fieldname;
2030       flp->length = 0;
2031       flp->head = NULL;
2032       fip->nfnfields++;
2033     }
2034
2035   /* Create a new member function field and chain it to the field list
2036      entry. */
2037   new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
2038   make_cleanup (free, new_fnfield);
2039   memset (new_fnfield, 0, sizeof (struct nextfnfield));
2040   new_fnfield->next = flp->head;
2041   flp->head = new_fnfield;
2042   flp->length++;
2043
2044   /* Fill in the member function field info.  */
2045   fnp = &new_fnfield->fnfield;
2046   fnp->physname = obsavestring (physname, strlen (physname),
2047                                 &objfile->type_obstack);
2048   fnp->type = alloc_type (objfile);
2049   if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
2050     {
2051       struct type *return_type = TYPE_TARGET_TYPE (die->type);
2052       struct type **arg_types;
2053       int nparams = TYPE_NFIELDS (die->type);
2054       int iparams;
2055
2056       /* Copy argument types from the subroutine type.  */
2057       arg_types = (struct type **)
2058         TYPE_ALLOC (fnp->type, (nparams + 1) * sizeof (struct type *));
2059       for (iparams = 0; iparams < nparams; iparams++)
2060         arg_types[iparams] = TYPE_FIELD_TYPE (die->type, iparams);
2061
2062       /* Set last entry in argument type vector.  */
2063       if (TYPE_FLAGS (die->type) & TYPE_FLAG_VARARGS)
2064         arg_types[nparams] = NULL;
2065       else
2066         arg_types[nparams] = dwarf2_fundamental_type (objfile, FT_VOID);
2067
2068       smash_to_method_type (fnp->type, type, return_type, arg_types);
2069
2070       /* Handle static member functions.
2071          Dwarf2 has no clean way to discern C++ static and non-static
2072          member functions. G++ helps GDB by marking the first
2073          parameter for non-static member functions (which is the
2074          this pointer) as artificial. We obtain this information
2075          from read_subroutine_type via TYPE_FIELD_ARTIFICIAL.  */
2076       if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
2077         fnp->voffset = VOFFSET_STATIC;
2078     }
2079   else
2080     complain (&dwarf2_missing_member_fn_type_complaint, physname);
2081
2082   /* Get fcontext from DW_AT_containing_type if present.  */
2083   if (dwarf_attr (die, DW_AT_containing_type) != NULL)
2084     fnp->fcontext = die_containing_type (die, objfile);
2085
2086   /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2087      and is_volatile is irrelevant, as it is needed by gdb_mangle_name only.  */
2088
2089   /* Get accessibility.  */
2090   attr = dwarf_attr (die, DW_AT_accessibility);
2091   if (attr)
2092     {
2093       switch (DW_UNSND (attr))
2094         {
2095           case DW_ACCESS_private:
2096             fnp->is_private = 1;
2097             break;
2098           case DW_ACCESS_protected:
2099             fnp->is_protected = 1;
2100             break;
2101         }
2102     }
2103
2104   /* Get index in virtual function table if it is a virtual member function.  */
2105   attr = dwarf_attr (die, DW_AT_vtable_elem_location);
2106   if (attr)
2107     fnp->voffset = decode_locdesc (DW_BLOCK (attr), objfile) + 2;
2108 }
2109
2110 /* Create the vector of member function fields, and attach it to the type.  */
2111
2112 static void
2113 dwarf2_attach_fn_fields_to_type (fip, type, objfile)
2114      struct field_info *fip;
2115      struct type *type;
2116      struct objfile *objfile;
2117 {
2118   struct fnfieldlist *flp;
2119   int total_length = 0;
2120   int i;
2121
2122   ALLOCATE_CPLUS_STRUCT_TYPE (type);
2123   TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2124     TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
2125
2126   for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
2127     {
2128       struct nextfnfield *nfp = flp->head;
2129       struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
2130       int k;
2131
2132       TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
2133       TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
2134       fn_flp->fn_fields = (struct fn_field *)
2135         TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
2136       for (k = flp->length; (k--, nfp); nfp = nfp->next)
2137         fn_flp->fn_fields[k] = nfp->fnfield;
2138
2139       total_length += flp->length;
2140     }
2141
2142   TYPE_NFN_FIELDS (type) = fip->nfnfields;
2143   TYPE_NFN_FIELDS_TOTAL (type) = total_length;
2144 }
2145
2146 /* Called when we find the DIE that starts a structure or union scope
2147    (definition) to process all dies that define the members of the
2148    structure or union.
2149
2150    NOTE: we need to call struct_type regardless of whether or not the
2151    DIE has an at_name attribute, since it might be an anonymous
2152    structure or union.  This gets the type entered into our set of
2153    user defined types.
2154
2155    However, if the structure is incomplete (an opaque struct/union)
2156    then suppress creating a symbol table entry for it since gdb only
2157    wants to find the one with the complete definition.  Note that if
2158    it is complete, we just call new_symbol, which does it's own
2159    checking about whether the struct/union is anonymous or not (and
2160    suppresses creating a symbol table entry itself).  */
2161
2162 static void
2163 read_structure_scope (die, objfile)
2164      struct die_info *die;
2165      struct objfile *objfile;
2166 {
2167   struct type *type;
2168   struct attribute *attr;
2169
2170   type = alloc_type (objfile);
2171
2172   INIT_CPLUS_SPECIFIC (type);
2173   attr = dwarf_attr (die, DW_AT_name);
2174   if (attr && DW_STRING (attr))
2175     {
2176       TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr),
2177                                            strlen (DW_STRING (attr)),
2178                                            &objfile->type_obstack);
2179     }
2180
2181   if (die->tag == DW_TAG_structure_type)
2182     {
2183       TYPE_CODE (type) = TYPE_CODE_STRUCT;
2184     }
2185   else if (die->tag == DW_TAG_union_type)
2186     {
2187       TYPE_CODE (type) = TYPE_CODE_UNION;
2188     }
2189   else
2190     {
2191       /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2192          in gdbtypes.h.  */
2193       TYPE_CODE (type) = TYPE_CODE_CLASS;
2194     }
2195
2196   attr = dwarf_attr (die, DW_AT_byte_size);
2197   if (attr)
2198     {
2199       TYPE_LENGTH (type) = DW_UNSND (attr);
2200     }
2201   else
2202     {
2203       TYPE_LENGTH (type) = 0;
2204     }
2205
2206   /* We need to add the type field to the die immediately so we don't
2207      infinitely recurse when dealing with pointers to the structure
2208      type within the structure itself. */
2209   die->type = type;
2210
2211   if (die->has_children)
2212     {
2213       struct field_info fi;
2214       struct die_info *child_die;
2215       struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
2216
2217       memset (&fi, 0, sizeof (struct field_info));
2218
2219       child_die = die->next;
2220
2221       while (child_die && child_die->tag)
2222         {
2223           if (child_die->tag == DW_TAG_member)
2224             {
2225               dwarf2_add_field (&fi, child_die, objfile);
2226             }
2227           else if (child_die->tag == DW_TAG_variable)
2228             {
2229               /* C++ static member.  */
2230               dwarf2_add_field (&fi, child_die, objfile);
2231             }
2232           else if (child_die->tag == DW_TAG_subprogram)
2233             {
2234               /* C++ member function. */
2235               process_die (child_die, objfile);
2236               dwarf2_add_member_fn (&fi, child_die, type, objfile);
2237             }
2238           else if (child_die->tag == DW_TAG_inheritance)
2239             {
2240               /* C++ base class field.  */
2241               dwarf2_add_field (&fi, child_die, objfile);
2242             }
2243           else
2244             {
2245               process_die (child_die, objfile);
2246             }
2247           child_die = sibling_die (child_die);
2248         }
2249
2250       /* Attach fields and member functions to the type.  */
2251       if (fi.nfields)
2252         dwarf2_attach_fields_to_type (&fi, type, objfile);
2253       if (fi.nfnfields)
2254         {
2255           dwarf2_attach_fn_fields_to_type (&fi, type, objfile);
2256
2257           /* Get the type which refers to the base class (possibly this
2258              class itself) which contains the vtable pointer for the current
2259              class from the DW_AT_containing_type attribute.  */
2260
2261           if (dwarf_attr (die, DW_AT_containing_type) != NULL)
2262             {
2263               struct type *t = die_containing_type (die, objfile);
2264
2265               TYPE_VPTR_BASETYPE (type) = t;
2266               if (type == t)
2267                 {
2268                   static const char vptr_name[] = { '_','v','p','t','r','\0' };
2269                   int i;
2270
2271                   /* Our own class provides vtbl ptr.  */
2272                   for (i = TYPE_NFIELDS (t) - 1;
2273                        i >= TYPE_N_BASECLASSES (t);
2274                        --i)
2275                     {
2276                       char *fieldname = TYPE_FIELD_NAME (t, i);
2277
2278                       if (STREQN (fieldname, vptr_name, strlen (vptr_name) - 1)
2279                           && is_cplus_marker (fieldname[strlen (vptr_name)]))
2280                         {
2281                           TYPE_VPTR_FIELDNO (type) = i;
2282                           break;
2283                         }
2284                     }
2285
2286                   /* Complain if virtual function table field not found.  */
2287                   if (i < TYPE_N_BASECLASSES (t))
2288                     complain (&dwarf2_vtbl_not_found_complaint,
2289                               TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "");
2290                 }
2291               else
2292                 {
2293                   TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
2294                 }
2295             }
2296         }
2297
2298       new_symbol (die, type, objfile);
2299
2300       do_cleanups (back_to);
2301     }
2302   else
2303     {
2304       /* No children, must be stub. */
2305       TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
2306     }
2307
2308   die->type = type;
2309 }
2310
2311 /* Given a pointer to a die which begins an enumeration, process all
2312    the dies that define the members of the enumeration.
2313
2314    This will be much nicer in draft 6 of the DWARF spec when our
2315    members will be dies instead squished into the DW_AT_element_list
2316    attribute.
2317
2318    NOTE: We reverse the order of the element list.  */
2319
2320 static void
2321 read_enumeration (die, objfile)
2322      struct die_info *die;
2323      struct objfile *objfile;
2324 {
2325   struct die_info *child_die;
2326   struct type *type;
2327   struct field *fields;
2328   struct attribute *attr;
2329   struct symbol *sym;
2330   int num_fields;
2331   int unsigned_enum = 1;
2332
2333   type = alloc_type (objfile);
2334
2335   TYPE_CODE (type) = TYPE_CODE_ENUM;
2336   attr = dwarf_attr (die, DW_AT_name);
2337   if (attr && DW_STRING (attr))
2338     {
2339       TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr),
2340                                            strlen (DW_STRING (attr)),
2341                                            &objfile->type_obstack);
2342     }
2343
2344   attr = dwarf_attr (die, DW_AT_byte_size);
2345   if (attr)
2346     {
2347       TYPE_LENGTH (type) = DW_UNSND (attr);
2348     }
2349   else
2350     {
2351       TYPE_LENGTH (type) = 0;
2352     }
2353
2354   num_fields = 0;
2355   fields = NULL;
2356   if (die->has_children)
2357     {
2358       child_die = die->next;
2359       while (child_die && child_die->tag)
2360         {
2361           if (child_die->tag != DW_TAG_enumerator)
2362             {
2363               process_die (child_die, objfile);
2364             }
2365           else
2366             {
2367               attr = dwarf_attr (child_die, DW_AT_name);
2368               if (attr)
2369                 {
2370                   sym = new_symbol (child_die, type, objfile);
2371                   if (SYMBOL_VALUE (sym) < 0)
2372                     unsigned_enum = 0;
2373
2374                   if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
2375                     {
2376                       fields = (struct field *)
2377                         xrealloc (fields,
2378                                   (num_fields + DW_FIELD_ALLOC_CHUNK)
2379                                     * sizeof (struct field));
2380                     }
2381
2382                   fields[num_fields].name = SYMBOL_NAME (sym);
2383                   fields[num_fields].type = NULL;
2384                   fields[num_fields].bitpos = SYMBOL_VALUE (sym);
2385                   fields[num_fields].bitsize = 0;
2386
2387                   num_fields++;
2388                 }
2389             }
2390
2391           child_die = sibling_die (child_die);
2392         }
2393
2394       if (num_fields)
2395         {
2396           TYPE_NFIELDS (type) = num_fields;
2397           TYPE_FIELDS (type) = (struct field *)
2398             TYPE_ALLOC (type, sizeof (struct field) * num_fields);
2399           memcpy (TYPE_FIELDS (type), fields,
2400                   sizeof (struct field) * num_fields);
2401           free (fields);
2402         }
2403       if (unsigned_enum)
2404         TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
2405     }
2406   die->type = type;
2407   new_symbol (die, type, objfile);
2408 }
2409
2410 /* Extract all information from a DW_TAG_array_type DIE and put it in
2411    the DIE's type field.  For now, this only handles one dimensional
2412    arrays.  */
2413
2414 static void
2415 read_array_type (die, objfile)
2416      struct die_info *die;
2417      struct objfile *objfile;
2418 {
2419   struct die_info *child_die;
2420   struct type *type = NULL;
2421   struct type *element_type, *range_type, *index_type;
2422   struct type **range_types = NULL;
2423   struct attribute *attr;
2424   int ndim = 0;
2425   struct cleanup *back_to;
2426
2427   /* Return if we've already decoded this type. */
2428   if (die->type)
2429     {
2430       return;
2431     }
2432
2433   element_type = die_type (die, objfile);
2434
2435   /* Irix 6.2 native cc creates array types without children for
2436      arrays with unspecified length.  */
2437   if (die->has_children == 0)
2438     {
2439       index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
2440       range_type = create_range_type (NULL, index_type, 0, -1);
2441       die->type = create_array_type (NULL, element_type, range_type);
2442       return;
2443     }
2444
2445   back_to = make_cleanup (null_cleanup, NULL);
2446   child_die = die->next;
2447   while (child_die && child_die->tag)
2448     {
2449       if (child_die->tag == DW_TAG_subrange_type)
2450         {
2451           unsigned int low, high;
2452
2453           /* Default bounds to an array with unspecified length.  */
2454           low = 0;
2455           high = -1;
2456           if (cu_language == DW_LANG_Fortran77
2457               || cu_language == DW_LANG_Fortran90)
2458             {
2459               /* FORTRAN implies a lower bound of 1, if not given.  */
2460               low = 1;
2461             }
2462
2463           index_type = die_type (child_die, objfile);
2464           attr = dwarf_attr (child_die, DW_AT_lower_bound);
2465           if (attr)
2466             {
2467               if (attr->form == DW_FORM_sdata)
2468                 {
2469                   low = DW_SND (attr);
2470                 }
2471               else if (attr->form == DW_FORM_udata
2472                        || attr->form == DW_FORM_data1
2473                        || attr->form == DW_FORM_data2
2474                        || attr->form == DW_FORM_data4)
2475                 {
2476                   low = DW_UNSND (attr);
2477                 }
2478               else
2479                 {
2480                   complain (&dwarf2_non_const_array_bound_ignored,
2481                             dwarf_form_name (attr->form));
2482 #ifdef FORTRAN_HACK
2483                   die->type = lookup_pointer_type (element_type);
2484                   return;
2485 #else
2486                   low = 0;
2487 #endif
2488                 }
2489             }
2490           attr = dwarf_attr (child_die, DW_AT_upper_bound);
2491           if (attr)
2492             {
2493               if (attr->form == DW_FORM_sdata)
2494                 {
2495                   high = DW_SND (attr);
2496                 }
2497               else if (attr->form == DW_FORM_udata
2498                        || attr->form == DW_FORM_data1
2499                        || attr->form == DW_FORM_data2
2500                        || attr->form == DW_FORM_data4)
2501                 {
2502                   high = DW_UNSND (attr);
2503                 }
2504               else if (attr->form == DW_FORM_block1)
2505                 {
2506                   /* GCC encodes arrays with unspecified or dynamic length
2507                      with a DW_FORM_block1 attribute.
2508                      FIXME: GDB does not yet know how to handle dynamic
2509                      arrays properly, treat them as arrays with unspecified
2510                      length for now.  */
2511                   high = -1;
2512                 }
2513               else
2514                 {
2515                   complain (&dwarf2_non_const_array_bound_ignored,
2516                             dwarf_form_name (attr->form));
2517 #ifdef FORTRAN_HACK
2518                   die->type = lookup_pointer_type (element_type);
2519                   return;
2520 #else
2521                   high = 1;
2522 #endif
2523                 }
2524             }
2525
2526           /* Create a range type and save it for array type creation.  */
2527           if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
2528             {
2529               range_types = (struct type **)
2530                 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
2531                                          * sizeof (struct type *));
2532               if (ndim == 0)
2533                 make_cleanup (free_current_contents, &range_types);
2534             }
2535           range_types[ndim++] = create_range_type (NULL, index_type, low, high);
2536         }
2537       child_die = sibling_die (child_die);
2538     }
2539
2540   /* Dwarf2 dimensions are output from left to right, create the
2541      necessary array types in backwards order.  */
2542   type = element_type;
2543   while (ndim-- > 0)
2544     type = create_array_type (NULL, type, range_types[ndim]);
2545
2546   do_cleanups (back_to);
2547
2548   /* Install the type in the die. */
2549   die->type = type;
2550 }
2551
2552 /* First cut: install each common block member as a global variable.  */
2553
2554 static void
2555 read_common_block (die, objfile)
2556      struct die_info *die;
2557      struct objfile *objfile;
2558 {
2559   struct die_info *child_die;
2560   struct attribute *attr;
2561   struct symbol *sym;
2562   CORE_ADDR base = (CORE_ADDR) 0;
2563
2564   attr = dwarf_attr (die, DW_AT_location);
2565   if (attr)
2566     {
2567       base = decode_locdesc (DW_BLOCK (attr), objfile);
2568     }
2569   if (die->has_children)
2570     {
2571       child_die = die->next;
2572       while (child_die && child_die->tag)
2573         {
2574           sym = new_symbol (child_die, NULL, objfile);
2575           attr = dwarf_attr (child_die, DW_AT_data_member_location);
2576           if (attr)
2577             {
2578               SYMBOL_VALUE_ADDRESS (sym) =
2579                 base + decode_locdesc (DW_BLOCK (attr), objfile);
2580               add_symbol_to_list (sym, &global_symbols);
2581             }
2582           child_die = sibling_die (child_die);
2583         }
2584     }
2585 }
2586
2587 /* Extract all information from a DW_TAG_pointer_type DIE and add to
2588    the user defined type vector.  */
2589
2590 static void
2591 read_tag_pointer_type (die, objfile)
2592      struct die_info *die;
2593      struct objfile *objfile;
2594 {
2595   struct type *type;
2596   struct attribute *attr;
2597
2598   if (die->type)
2599     {
2600       return;
2601     }
2602
2603   type = lookup_pointer_type (die_type (die, objfile));
2604   attr = dwarf_attr (die, DW_AT_byte_size);
2605   if (attr)
2606     {
2607       TYPE_LENGTH (type) = DW_UNSND (attr);
2608     }
2609   else
2610     {
2611       TYPE_LENGTH (type) = address_size;
2612     }
2613   die->type = type;
2614 }
2615
2616 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
2617    the user defined type vector.  */
2618
2619 static void
2620 read_tag_ptr_to_member_type (die, objfile)
2621      struct die_info *die;
2622      struct objfile *objfile;
2623 {
2624   struct type *type;
2625   struct type *to_type;
2626   struct type *domain;
2627
2628   if (die->type)
2629     {
2630       return;
2631     }
2632
2633   type = alloc_type (objfile);
2634   to_type = die_type (die, objfile);
2635   domain = die_containing_type (die, objfile);
2636   smash_to_member_type (type, domain, to_type);
2637
2638   die->type = type;
2639 }
2640
2641 /* Extract all information from a DW_TAG_reference_type DIE and add to
2642    the user defined type vector.  */
2643
2644 static void
2645 read_tag_reference_type (die, objfile)
2646      struct die_info *die;
2647      struct objfile *objfile;
2648 {
2649   struct type *type;
2650   struct attribute *attr;
2651
2652   if (die->type)
2653     {
2654       return;
2655     }
2656
2657   type = lookup_reference_type (die_type (die, objfile));
2658   attr = dwarf_attr (die, DW_AT_byte_size);
2659   if (attr)
2660     {
2661       TYPE_LENGTH (type) = DW_UNSND (attr);
2662     }
2663   else
2664     {
2665       TYPE_LENGTH (type) = address_size;
2666     }
2667   die->type = type;
2668 }
2669
2670 static void
2671 read_tag_const_type (die, objfile)
2672      struct die_info *die;
2673      struct objfile *objfile;
2674 {
2675   if (die->type)
2676     {
2677       return;
2678     }
2679
2680   complain (&dwarf2_const_ignored);
2681   die->type = die_type (die, objfile);
2682 }
2683
2684 static void
2685 read_tag_volatile_type (die, objfile)
2686      struct die_info *die;
2687      struct objfile *objfile;
2688 {
2689   if (die->type)
2690     {
2691       return;
2692     }
2693
2694   complain (&dwarf2_volatile_ignored);
2695   die->type = die_type (die, objfile);
2696 }
2697
2698 /* Extract all information from a DW_TAG_string_type DIE and add to
2699    the user defined type vector.  It isn't really a user defined type,
2700    but it behaves like one, with other DIE's using an AT_user_def_type
2701    attribute to reference it.  */
2702
2703 static void
2704 read_tag_string_type (die, objfile)
2705      struct die_info *die;
2706      struct objfile *objfile;
2707 {
2708   struct type *type, *range_type, *index_type, *char_type;
2709   struct attribute *attr;
2710   unsigned int length;
2711
2712   if (die->type)
2713     {
2714       return;
2715     }
2716
2717   attr = dwarf_attr (die, DW_AT_string_length);
2718   if (attr)
2719     {
2720       length = DW_UNSND (attr);
2721     }
2722   else
2723     {
2724       length = 1;
2725     }
2726   index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
2727   range_type = create_range_type (NULL, index_type, 1, length);
2728   char_type = dwarf2_fundamental_type (objfile, FT_CHAR);
2729   type = create_string_type (char_type, range_type);
2730   die->type = type;
2731 }
2732
2733 /* Handle DIES due to C code like:
2734
2735    struct foo
2736      {
2737        int (*funcp)(int a, long l);
2738        int b;
2739      };
2740
2741    ('funcp' generates a DW_TAG_subroutine_type DIE)
2742 */
2743
2744 static void
2745 read_subroutine_type (die, objfile)
2746      struct die_info *die;
2747      struct objfile *objfile;
2748 {
2749   struct type *type;            /* Type that this function returns */
2750   struct type *ftype;           /* Function that returns above type */
2751   struct attribute *attr;
2752
2753   /* Decode the type that this subroutine returns */
2754   if (die->type)
2755     {
2756       return;
2757     }
2758   type = die_type (die, objfile);
2759   ftype = lookup_function_type (type);
2760   attr = dwarf_attr (die, DW_AT_prototyped);
2761   if (attr && (DW_UNSND (attr) != 0))
2762     TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
2763
2764   if (die->has_children)
2765     {
2766       struct die_info *child_die;
2767       int nparams = 0;
2768       int iparams = 0;
2769
2770       /* Count the number of parameters.
2771          FIXME: GDB currently ignores vararg functions, but knows about
2772          vararg member functions.  */
2773       child_die = die->next;
2774       while (child_die && child_die->tag)
2775         {
2776           if (child_die->tag == DW_TAG_formal_parameter)
2777             nparams++;
2778           else if (child_die->tag == DW_TAG_unspecified_parameters)
2779             TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
2780           child_die = sibling_die (child_die);
2781         }
2782
2783       /* Allocate storage for parameters and fill them in.  */
2784       TYPE_NFIELDS (ftype) = nparams;
2785       TYPE_FIELDS (ftype) = (struct field *)
2786         TYPE_ALLOC (ftype, nparams * sizeof (struct field));
2787
2788       child_die = die->next;
2789       while (child_die && child_die->tag)
2790         {
2791           if (child_die->tag == DW_TAG_formal_parameter)
2792             {
2793               /* Dwarf2 has no clean way to discern C++ static and non-static
2794                  member functions. G++ helps GDB by marking the first
2795                  parameter for non-static member functions (which is the
2796                  this pointer) as artificial. We pass this information
2797                  to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.  */
2798               attr = dwarf_attr (child_die, DW_AT_artificial);
2799               if (attr)
2800                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
2801               else
2802                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
2803               TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, objfile);
2804               iparams++;
2805             }
2806           child_die = sibling_die (child_die);
2807         }
2808     }
2809
2810   die->type = ftype;
2811 }
2812
2813 static void
2814 read_typedef (die, objfile)
2815      struct die_info *die;
2816      struct objfile *objfile;
2817 {
2818   struct type *type;
2819
2820   if (!die->type)
2821     {
2822       struct attribute *attr;
2823       struct type *xtype;
2824
2825       xtype = die_type (die, objfile);
2826
2827       type = alloc_type (objfile);
2828       TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
2829       TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB;
2830       TYPE_TARGET_TYPE (type) = xtype;
2831       attr = dwarf_attr (die, DW_AT_name);
2832       if (attr && DW_STRING (attr))
2833         TYPE_NAME (type) = obsavestring (DW_STRING (attr),
2834                                          strlen (DW_STRING (attr)),
2835                                          &objfile->type_obstack);
2836
2837       die->type = type;
2838     }
2839 }
2840
2841 /* Find a representation of a given base type and install
2842    it in the TYPE field of the die.  */
2843
2844 static void
2845 read_base_type (die, objfile)
2846      struct die_info *die;
2847      struct objfile *objfile;
2848 {
2849   struct type *type;
2850   struct attribute *attr;
2851   int encoding = 0, size = 0;
2852
2853   /* If we've already decoded this die, this is a no-op. */
2854   if (die->type)
2855     {
2856       return;
2857     }
2858
2859   attr = dwarf_attr (die, DW_AT_encoding);
2860   if (attr)
2861     {
2862       encoding = DW_UNSND (attr);
2863     }
2864   attr = dwarf_attr (die, DW_AT_byte_size);
2865   if (attr)
2866     {
2867       size = DW_UNSND (attr);
2868     }
2869   attr = dwarf_attr (die, DW_AT_name);
2870   if (attr && DW_STRING (attr))
2871     {
2872       enum type_code code = TYPE_CODE_INT;
2873       int is_unsigned = 0;
2874
2875       switch (encoding)
2876         {
2877         case DW_ATE_address:
2878           /* Turn DW_ATE_address into a void * pointer.  */
2879           code = TYPE_CODE_PTR;
2880           is_unsigned = 1;
2881           break;
2882         case DW_ATE_boolean:
2883           code = TYPE_CODE_BOOL;
2884           is_unsigned = 1;
2885           break;
2886         case DW_ATE_complex_float:
2887           code = TYPE_CODE_COMPLEX;
2888           break;
2889         case DW_ATE_float:
2890           code = TYPE_CODE_FLT;
2891           break;
2892         case DW_ATE_signed:
2893         case DW_ATE_signed_char:
2894           break;
2895         case DW_ATE_unsigned:
2896         case DW_ATE_unsigned_char:
2897           is_unsigned = 1;
2898           break;
2899         default:
2900           complain (&dwarf2_unsupported_at_encoding,
2901                     dwarf_type_encoding_name (encoding));
2902           break;
2903         }
2904       type = init_type (code, size, is_unsigned, DW_STRING (attr), objfile);
2905       if (encoding == DW_ATE_address)
2906         TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID);
2907     }
2908   else
2909     {
2910       type = dwarf_base_type (encoding, size, objfile);
2911     }
2912   die->type = type;
2913 }
2914
2915 /* Read a whole compilation unit into a linked list of dies.  */
2916
2917 struct die_info *
2918 read_comp_unit (info_ptr, abfd)
2919     char *info_ptr;
2920     bfd *abfd;
2921 {
2922   struct die_info *first_die, *last_die, *die;
2923   char *cur_ptr;
2924   int nesting_level;
2925
2926   /* Reset die reference table, we are building a new one now. */
2927   dwarf2_empty_die_ref_table ();
2928
2929   cur_ptr = info_ptr;
2930   nesting_level = 0;
2931   first_die = last_die = NULL;
2932   do
2933     {
2934       cur_ptr = read_full_die (&die, abfd, cur_ptr);
2935       if (die->has_children)
2936         {
2937           nesting_level++;
2938         }
2939       if (die->tag == 0)
2940         {
2941           nesting_level--;
2942         }
2943
2944       die->next = NULL;
2945
2946       /* Enter die in reference hash table */
2947       store_in_ref_table (die->offset, die);
2948
2949       if (!first_die)
2950         {
2951           first_die = last_die = die;
2952         }
2953       else
2954         {
2955           last_die->next = die;
2956           last_die = die;
2957         }
2958     }
2959   while (nesting_level > 0);
2960   return first_die;
2961 }
2962
2963 /* Free a linked list of dies.  */
2964
2965 static void
2966 free_die_list (dies)
2967      struct die_info *dies;
2968 {
2969   struct die_info *die, *next;
2970
2971   die = dies;
2972   while (die)
2973     {
2974       next = die->next;
2975       free (die->attrs);
2976       free (die);
2977       die = next;
2978     }
2979 }
2980
2981 /* Read the contents of the section at OFFSET and of size SIZE from the
2982    object file specified by OBJFILE into the psymbol_obstack and return it.  */
2983
2984 static char *
2985 dwarf2_read_section (objfile, offset, size)
2986      struct objfile *objfile;
2987      file_ptr offset;
2988      unsigned int size;
2989 {
2990   bfd *abfd = objfile->obfd;
2991   char *buf;
2992
2993   if (size == 0)
2994     return NULL;
2995
2996   buf = (char *) obstack_alloc (&objfile->psymbol_obstack, size);
2997   if ((bfd_seek (abfd, offset, SEEK_SET) != 0) ||
2998       (bfd_read (buf, size, 1, abfd) != size))
2999     {
3000       buf = NULL;
3001       error ("Dwarf Error: Can't read DWARF data from '%s'",
3002         bfd_get_filename (abfd));
3003     }
3004   return buf;
3005 }
3006
3007 /* In DWARF version 2, the description of the debugging information is
3008    stored in a separate .debug_abbrev section.  Before we read any
3009    dies from a section we read in all abbreviations and install them
3010    in a hash table.  */
3011
3012 static void
3013 dwarf2_read_abbrevs (abfd, offset)
3014      bfd * abfd;
3015      unsigned int offset;
3016 {
3017   char *abbrev_ptr;
3018   struct abbrev_info *cur_abbrev;
3019   unsigned int abbrev_number, bytes_read, abbrev_name;
3020   unsigned int abbrev_form, hash_number;
3021
3022   /* empty the table */
3023   dwarf2_empty_abbrev_table (NULL);
3024
3025   abbrev_ptr = dwarf_abbrev_buffer + offset;
3026   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3027   abbrev_ptr += bytes_read;
3028
3029   /* loop until we reach an abbrev number of 0 */
3030   while (abbrev_number)
3031     {
3032       cur_abbrev = dwarf_alloc_abbrev ();
3033
3034       /* read in abbrev header */
3035       cur_abbrev->number = abbrev_number;
3036       cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3037       abbrev_ptr += bytes_read;
3038       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
3039       abbrev_ptr += 1;
3040
3041       /* now read in declarations */
3042       abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3043       abbrev_ptr += bytes_read;
3044       abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3045       abbrev_ptr += bytes_read;
3046       while (abbrev_name)
3047         {
3048           if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
3049             {
3050               cur_abbrev->attrs = (struct attr_abbrev *)
3051                 xrealloc (cur_abbrev->attrs,
3052                           (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
3053                             * sizeof (struct attr_abbrev));
3054             }
3055           cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
3056           cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
3057           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3058           abbrev_ptr += bytes_read;
3059           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3060           abbrev_ptr += bytes_read;
3061         }
3062
3063       hash_number = abbrev_number % ABBREV_HASH_SIZE;
3064       cur_abbrev->next = dwarf2_abbrevs[hash_number];
3065       dwarf2_abbrevs[hash_number] = cur_abbrev;
3066
3067       /* Get next abbreviation.
3068          Under Irix6 the abbreviations for a compilation unit are not
3069          always properly terminated with an abbrev number of 0.
3070          Exit loop if we encounter an abbreviation which we have
3071          already read (which means we are about to read the abbreviations
3072          for the next compile unit) or if the end of the abbreviation
3073          table is reached.  */
3074       if ((unsigned int) (abbrev_ptr - dwarf_abbrev_buffer)
3075             >= dwarf_abbrev_size)
3076         break;
3077       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3078       abbrev_ptr += bytes_read;
3079       if (dwarf2_lookup_abbrev (abbrev_number) != NULL)
3080         break;
3081     }
3082 }
3083
3084 /* Empty the abbrev table for a new compilation unit.  */
3085
3086 /* ARGSUSED */
3087 static void
3088 dwarf2_empty_abbrev_table (ignore)
3089      PTR ignore;
3090 {
3091   int i;
3092   struct abbrev_info *abbrev, *next;
3093
3094   for (i = 0; i < ABBREV_HASH_SIZE; ++i)
3095     {
3096       next = NULL;
3097       abbrev = dwarf2_abbrevs[i];
3098       while (abbrev)
3099         {
3100           next = abbrev->next;
3101           free (abbrev->attrs);
3102           free (abbrev);
3103           abbrev = next;
3104         }
3105       dwarf2_abbrevs[i] = NULL;
3106     }
3107 }
3108
3109 /* Lookup an abbrev_info structure in the abbrev hash table.  */
3110
3111 static struct abbrev_info *
3112 dwarf2_lookup_abbrev (number)
3113      unsigned int number;
3114 {
3115   unsigned int hash_number;
3116   struct abbrev_info *abbrev;
3117
3118   hash_number = number % ABBREV_HASH_SIZE;
3119   abbrev = dwarf2_abbrevs[hash_number];
3120
3121   while (abbrev)
3122     {
3123       if (abbrev->number == number)
3124         return abbrev;
3125       else
3126         abbrev = abbrev->next;
3127     }
3128   return NULL;
3129 }
3130
3131 /* Read a minimal amount of information into the minimal die structure.  */
3132
3133 static char *
3134 read_partial_die (part_die, abfd, info_ptr, has_pc_info)
3135      struct partial_die_info *part_die;
3136      bfd * abfd;
3137      char *info_ptr;
3138      int *has_pc_info;
3139 {
3140   unsigned int abbrev_number, bytes_read, i;
3141   struct abbrev_info *abbrev;
3142   struct attribute attr;
3143   struct attribute spec_attr;
3144   int found_spec_attr = 0;
3145   int has_low_pc_attr  = 0;
3146   int has_high_pc_attr = 0;
3147
3148   *part_die = zeroed_partial_die;
3149   *has_pc_info = 0;
3150   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
3151   info_ptr += bytes_read;
3152   if (!abbrev_number)
3153     return info_ptr;
3154
3155   abbrev = dwarf2_lookup_abbrev (abbrev_number);
3156   if (!abbrev)
3157     {
3158       error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number);
3159     }
3160   part_die->offset = info_ptr - dwarf_info_buffer;
3161   part_die->tag = abbrev->tag;
3162   part_die->has_children = abbrev->has_children;
3163   part_die->abbrev = abbrev_number;
3164
3165   for (i = 0; i < abbrev->num_attrs; ++i)
3166     {
3167       info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr);
3168
3169       /* Store the data if it is of an attribute we want to keep in a
3170          partial symbol table.  */
3171       switch (attr.name)
3172         {
3173         case DW_AT_name:
3174
3175           /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
3176           if (part_die->name == NULL)
3177             part_die->name = DW_STRING (&attr);
3178           break;
3179         case DW_AT_MIPS_linkage_name:
3180           part_die->name = DW_STRING (&attr);
3181           break;
3182         case DW_AT_low_pc:
3183           has_low_pc_attr = 1;
3184           part_die->lowpc = DW_ADDR (&attr);
3185           break;
3186         case DW_AT_high_pc:
3187           has_high_pc_attr = 1;
3188           part_die->highpc = DW_ADDR (&attr);
3189           break;
3190         case DW_AT_location:
3191           part_die->locdesc = DW_BLOCK (&attr);
3192           break;
3193         case DW_AT_language:
3194           part_die->language = DW_UNSND (&attr);
3195           break;
3196         case DW_AT_external:
3197           part_die->is_external = DW_UNSND (&attr);
3198           break;
3199         case DW_AT_declaration:
3200           part_die->is_declaration = DW_UNSND (&attr);
3201           break;
3202         case DW_AT_type:
3203           part_die->has_type = 1;
3204           break;
3205         case DW_AT_abstract_origin:
3206         case DW_AT_specification:
3207           found_spec_attr = 1;
3208           spec_attr = attr;
3209           break;
3210         case DW_AT_sibling:
3211           /* Ignore absolute siblings, they might point outside of
3212              the current compile unit.  */
3213           if (attr.form == DW_FORM_ref_addr)
3214             complain(&dwarf2_absolute_sibling_complaint);
3215           else
3216             part_die->sibling =
3217               dwarf_info_buffer + dwarf2_get_ref_die_offset (&attr);
3218           break;
3219         default:
3220           break;
3221         }
3222     }
3223
3224   /* If we found a reference attribute and the die has no name, try
3225      to find a name in the referred to die.  */
3226
3227   if (found_spec_attr && part_die->name == NULL)
3228     {
3229       struct partial_die_info spec_die;
3230       char *spec_ptr;
3231       int dummy;
3232
3233       spec_ptr = dwarf_info_buffer + dwarf2_get_ref_die_offset (&spec_attr);
3234       read_partial_die (&spec_die, abfd, spec_ptr, &dummy);
3235       if (spec_die.name)
3236         {
3237           part_die->name = spec_die.name;
3238
3239           /* Copy DW_AT_external attribute if it is set.  */
3240           if (spec_die.is_external)
3241             part_die->is_external = spec_die.is_external;
3242         }
3243     }
3244
3245   /* When using the GNU linker, .gnu.linkonce. sections are used to
3246      eliminate duplicate copies of functions and vtables and such.
3247      The linker will arbitrarily choose one and discard the others.
3248      The AT_*_pc values for such functions refer to local labels in
3249      these sections.  If the section from that file was discarded, the
3250      labels are not in the output, so the relocs get a value of 0.
3251      If this is a discarded function, mark the pc bounds as invalid,
3252      so that GDB will ignore it.  */
3253   if (has_low_pc_attr && has_high_pc_attr
3254       && part_die->lowpc < part_die->highpc
3255       && (part_die->lowpc != 0
3256           || (bfd_get_file_flags (abfd) & HAS_RELOC)))
3257     *has_pc_info = 1;
3258   return info_ptr;
3259 }
3260
3261 /* Read the die from the .debug_info section buffer.  And set diep to
3262    point to a newly allocated die with its information.  */
3263
3264 static char *
3265 read_full_die (diep, abfd, info_ptr)
3266      struct die_info **diep;
3267      bfd *abfd;
3268      char *info_ptr;
3269 {
3270   unsigned int abbrev_number, bytes_read, i, offset;
3271   struct abbrev_info *abbrev;
3272   struct die_info *die;
3273
3274   offset = info_ptr - dwarf_info_buffer;
3275   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
3276   info_ptr += bytes_read;
3277   if (!abbrev_number)
3278     {
3279       die = dwarf_alloc_die ();
3280       die->tag = 0;
3281       die->abbrev = abbrev_number;
3282       die->type = NULL;
3283       *diep = die;
3284       return info_ptr;
3285     }
3286
3287   abbrev = dwarf2_lookup_abbrev (abbrev_number);
3288   if (!abbrev)
3289     {
3290       error ("Dwarf Error: could not find abbrev number %d.", abbrev_number);
3291     }
3292   die = dwarf_alloc_die ();
3293   die->offset = offset;
3294   die->tag = abbrev->tag;
3295   die->has_children = abbrev->has_children;
3296   die->abbrev = abbrev_number;
3297   die->type = NULL;
3298
3299   die->num_attrs = abbrev->num_attrs;
3300   die->attrs = (struct attribute *)
3301     xmalloc (die->num_attrs * sizeof (struct attribute));
3302
3303   for (i = 0; i < abbrev->num_attrs; ++i)
3304     {
3305       info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
3306                                  abfd, info_ptr);
3307     }
3308
3309   *diep = die;
3310   return info_ptr;
3311 }
3312
3313 /* Read an attribute described by an abbreviated attribute.  */
3314
3315 static char *
3316 read_attribute (attr, abbrev, abfd, info_ptr)
3317      struct attribute *attr;
3318      struct attr_abbrev *abbrev;
3319      bfd *abfd;
3320      char *info_ptr;
3321 {
3322   unsigned int bytes_read;
3323   struct dwarf_block *blk;
3324
3325   attr->name = abbrev->name;
3326   attr->form = abbrev->form;
3327   switch (abbrev->form)
3328     {
3329     case DW_FORM_addr:
3330     case DW_FORM_ref_addr:
3331       DW_ADDR (attr) = read_address (abfd, info_ptr);
3332       info_ptr += address_size;
3333       break;
3334     case DW_FORM_block2:
3335       blk = dwarf_alloc_block ();
3336       blk->size = read_2_bytes (abfd, info_ptr);
3337       info_ptr += 2;
3338       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
3339       info_ptr += blk->size;
3340       DW_BLOCK (attr) = blk;
3341       break;
3342     case DW_FORM_block4:
3343       blk = dwarf_alloc_block ();
3344       blk->size = read_4_bytes (abfd, info_ptr);
3345       info_ptr += 4;
3346       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
3347       info_ptr += blk->size;
3348       DW_BLOCK (attr) = blk;
3349       break;
3350     case DW_FORM_data2:
3351       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
3352       info_ptr += 2;
3353       break;
3354     case DW_FORM_data4:
3355       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
3356       info_ptr += 4;
3357       break;
3358     case DW_FORM_data8:
3359       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
3360       info_ptr += 8;
3361       break;
3362     case DW_FORM_string:
3363       DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
3364       info_ptr += bytes_read;
3365       break;
3366     case DW_FORM_block:
3367       blk = dwarf_alloc_block ();
3368       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
3369       info_ptr += bytes_read;
3370       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
3371       info_ptr += blk->size;
3372       DW_BLOCK (attr) = blk;
3373       break;
3374     case DW_FORM_block1:
3375       blk = dwarf_alloc_block ();
3376       blk->size = read_1_byte (abfd, info_ptr);
3377       info_ptr += 1;
3378       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
3379       info_ptr += blk->size;
3380       DW_BLOCK (attr) = blk;
3381       break;
3382     case DW_FORM_data1:
3383       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
3384       info_ptr += 1;
3385       break;
3386     case DW_FORM_flag:
3387       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
3388       info_ptr += 1;
3389       break;
3390     case DW_FORM_sdata:
3391       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
3392       info_ptr += bytes_read;
3393       break;
3394     case DW_FORM_udata:
3395       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
3396       info_ptr += bytes_read;
3397       break;
3398     case DW_FORM_ref1:
3399       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
3400       info_ptr += 1;
3401       break;
3402     case DW_FORM_ref2:
3403       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
3404       info_ptr += 2;
3405       break;
3406     case DW_FORM_ref4:
3407       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
3408       info_ptr += 4;
3409       break;
3410     case DW_FORM_ref_udata:
3411       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
3412       info_ptr += bytes_read;
3413       break;
3414     case DW_FORM_strp:
3415     case DW_FORM_indirect:
3416     default:
3417       error ("Dwarf Error: Cannot handle %s in DWARF reader.",
3418              dwarf_form_name (abbrev->form));
3419     }
3420   return info_ptr;
3421 }
3422
3423 /* read dwarf information from a buffer */
3424
3425 static unsigned int
3426 read_1_byte (abfd, buf)
3427      bfd *abfd;
3428      char *buf;
3429 {
3430   return bfd_get_8 (abfd, (bfd_byte *) buf);
3431 }
3432
3433 static int
3434 read_1_signed_byte (abfd, buf)
3435      bfd *abfd;
3436      char *buf;
3437 {
3438   return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
3439 }
3440
3441 static unsigned int
3442 read_2_bytes (abfd, buf)
3443      bfd *abfd;
3444      char *buf;
3445 {
3446   return bfd_get_16 (abfd, (bfd_byte *) buf);
3447 }
3448
3449 static int
3450 read_2_signed_bytes (abfd, buf)
3451      bfd *abfd;
3452      char *buf;
3453 {
3454   return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
3455 }
3456
3457 static unsigned int
3458 read_4_bytes (abfd, buf)
3459      bfd *abfd;
3460      char *buf;
3461 {
3462   return bfd_get_32 (abfd, (bfd_byte *) buf);
3463 }
3464
3465 static int
3466 read_4_signed_bytes (abfd, buf)
3467      bfd *abfd;
3468      char *buf;
3469 {
3470   return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
3471 }
3472
3473 static unsigned int
3474 read_8_bytes (abfd, buf)
3475      bfd *abfd;
3476      char *buf;
3477 {
3478   return bfd_get_64 (abfd, (bfd_byte *) buf);
3479 }
3480
3481 static CORE_ADDR
3482 read_address (abfd, buf)
3483      bfd *abfd;
3484      char *buf;
3485 {
3486   CORE_ADDR retval = 0;
3487
3488   if (address_size == 4)
3489     {
3490       retval = bfd_get_32 (abfd, (bfd_byte *) buf);
3491     } else {                    /* *THE* alternative is 8, right? */
3492       retval = bfd_get_64 (abfd, (bfd_byte *) buf);
3493     }
3494   return retval;
3495 }
3496
3497 static char *
3498 read_n_bytes (abfd, buf, size)
3499      bfd * abfd;
3500      char *buf;
3501      unsigned int size;
3502 {
3503   /* If the size of a host char is 8 bits, we can return a pointer
3504      to the buffer, otherwise we have to copy the data to a buffer
3505      allocated on the temporary obstack.  */
3506 #if HOST_CHAR_BIT == 8
3507   return buf;
3508 #else
3509   char *ret;
3510   unsigned int i;
3511
3512   ret = obstack_alloc (&dwarf2_tmp_obstack, size);
3513   for (i = 0; i < size; ++i)
3514     {
3515       ret[i] = bfd_get_8 (abfd, (bfd_byte *) buf);
3516       buf++;
3517     }
3518   return ret;
3519 #endif
3520 }
3521
3522 static char *
3523 read_string (abfd, buf, bytes_read_ptr)
3524      bfd *abfd;
3525      char *buf;
3526      unsigned int *bytes_read_ptr;
3527 {
3528   /* If the size of a host char is 8 bits, we can return a pointer
3529      to the string, otherwise we have to copy the string to a buffer
3530      allocated on the temporary obstack.  */
3531 #if HOST_CHAR_BIT == 8
3532   if (*buf == '\0')
3533     {
3534       *bytes_read_ptr = 1;
3535       return NULL;
3536     }
3537   *bytes_read_ptr = strlen (buf) + 1;
3538   return buf;
3539 #else
3540   int byte;
3541   unsigned int i = 0;
3542
3543   while ((byte = bfd_get_8 (abfd, (bfd_byte *) buf)) != 0)
3544     {
3545       obstack_1grow (&dwarf2_tmp_obstack, byte);
3546       i++;
3547       buf++;
3548     }
3549   if (i == 0)
3550     {
3551       *bytes_read_ptr = 1;
3552       return NULL;
3553     }
3554   obstack_1grow (&dwarf2_tmp_obstack, '\0');
3555   *bytes_read_ptr = i + 1;
3556   return obstack_finish (&dwarf2_tmp_obstack);
3557 #endif
3558 }
3559
3560 static unsigned int
3561 read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
3562      bfd *abfd;
3563      char *buf;
3564      unsigned int *bytes_read_ptr;
3565 {
3566   unsigned int result, num_read;
3567   int i, shift;
3568   unsigned char byte;
3569
3570   result = 0;
3571   shift = 0;
3572   num_read = 0;
3573   i = 0;
3574   while (1)
3575     {
3576       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
3577       buf++;
3578       num_read++;
3579       result |= ((byte & 127) << shift);
3580       if ((byte & 128) == 0)
3581         {
3582           break;
3583         }
3584       shift += 7;
3585     }
3586   *bytes_read_ptr = num_read;
3587   return result;
3588 }
3589
3590 static int
3591 read_signed_leb128 (abfd, buf, bytes_read_ptr)
3592      bfd *abfd;
3593      char *buf;
3594      unsigned int *bytes_read_ptr;
3595 {
3596   int result;
3597   int i, shift, size, num_read;
3598   unsigned char byte;
3599
3600   result = 0;
3601   shift = 0;
3602   size = 32;
3603   num_read = 0;
3604   i = 0;
3605   while (1)
3606     {
3607       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
3608       buf++;
3609       num_read++;
3610       result |= ((byte & 127) << shift);
3611       shift += 7;
3612       if ((byte & 128) == 0)
3613         {
3614           break;
3615         }
3616     }
3617   if ((shift < size) && (byte & 0x40))
3618     {
3619       result |= -(1 << shift);
3620     }
3621   *bytes_read_ptr = num_read;
3622   return result;
3623 }
3624
3625 static void
3626 set_cu_language (lang)
3627      unsigned int lang;
3628 {
3629   switch (lang)
3630     {
3631     case DW_LANG_C89:
3632     case DW_LANG_C:
3633     case DW_LANG_Fortran77:
3634       cu_language = language_c;
3635       break;
3636     case DW_LANG_C_plus_plus:
3637       cu_language = language_cplus;
3638       break;
3639     case DW_LANG_Mips_Assembler:
3640       cu_language = language_asm;
3641       break;
3642     case DW_LANG_Ada83:
3643     case DW_LANG_Cobol74:
3644     case DW_LANG_Cobol85:
3645 #if 0
3646     case DW_LANG_Fortran77:     /* moved up top for now */
3647 #endif
3648     case DW_LANG_Fortran90:
3649     case DW_LANG_Pascal83:
3650     case DW_LANG_Modula2:
3651     default:
3652       cu_language = language_unknown;
3653       break;
3654     }
3655   cu_language_defn = language_def (cu_language);
3656 }
3657
3658 /* Return the named attribute or NULL if not there.  */
3659
3660 static struct attribute *
3661 dwarf_attr (die, name)
3662      struct die_info *die;
3663      unsigned int name;
3664 {
3665   unsigned int i;
3666   struct attribute *spec = NULL;
3667
3668   for (i = 0; i < die->num_attrs; ++i)
3669     {
3670       if (die->attrs[i].name == name)
3671         {
3672           return &die->attrs[i];
3673         }
3674       if (die->attrs[i].name == DW_AT_specification
3675           || die->attrs[i].name == DW_AT_abstract_origin)
3676         spec = &die->attrs[i];
3677     }
3678   if (spec)
3679     {
3680       struct die_info *ref_die =
3681         follow_die_ref (dwarf2_get_ref_die_offset (spec));
3682
3683       if (ref_die)
3684         return dwarf_attr (ref_die, name);
3685     }
3686
3687   return NULL;
3688 }
3689
3690 /* Decode the line number information for the compilation unit whose
3691    line number info is at OFFSET in the .debug_line section.
3692    The compilation directory of the file is passed in COMP_DIR.  */
3693
3694 struct filenames
3695 {
3696   unsigned int num_files;
3697   struct fileinfo
3698   {
3699     char *name;
3700     unsigned int dir;
3701     unsigned int time;
3702     unsigned int size;
3703   }
3704   *files;
3705 };
3706
3707 struct directories
3708 {
3709   unsigned int num_dirs;
3710   char **dirs;
3711 };
3712
3713 static void
3714 dwarf_decode_lines (offset, comp_dir, abfd)
3715      unsigned int offset;
3716      char *comp_dir;
3717      bfd *abfd;
3718 {
3719   char *line_ptr;
3720   char *line_end;
3721   struct line_head lh;
3722   struct cleanup *back_to;
3723   unsigned int i, bytes_read;
3724   char *cur_file, *cur_dir;
3725   unsigned char op_code, extended_op, adj_opcode;
3726
3727 #define FILE_ALLOC_CHUNK 5
3728 #define DIR_ALLOC_CHUNK 5
3729
3730   struct filenames files;
3731   struct directories dirs;
3732
3733   if (dwarf_line_buffer == NULL)
3734     {
3735       complain (&dwarf2_missing_line_number_section);
3736       return;
3737     }
3738
3739   files.num_files = 0;
3740   files.files = NULL;
3741
3742   dirs.num_dirs = 0;
3743   dirs.dirs = NULL;
3744
3745   line_ptr = dwarf_line_buffer + offset;
3746
3747   /* read in the prologue */
3748   lh.total_length = read_4_bytes (abfd, line_ptr);
3749   line_ptr += 4;
3750   line_end = line_ptr + lh.total_length;
3751   lh.version = read_2_bytes (abfd, line_ptr);
3752   line_ptr += 2;
3753   lh.prologue_length = read_4_bytes (abfd, line_ptr);
3754   line_ptr += 4;
3755   lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
3756   line_ptr += 1;
3757   lh.default_is_stmt = read_1_byte (abfd, line_ptr);
3758   line_ptr += 1;
3759   lh.line_base = read_1_signed_byte (abfd, line_ptr);
3760   line_ptr += 1;
3761   lh.line_range = read_1_byte (abfd, line_ptr);
3762   line_ptr += 1;
3763   lh.opcode_base = read_1_byte (abfd, line_ptr);
3764   line_ptr += 1;
3765   lh.standard_opcode_lengths = (unsigned char *)
3766     xmalloc (lh.opcode_base * sizeof (unsigned char));
3767   back_to = make_cleanup (free_current_contents, &lh.standard_opcode_lengths);
3768
3769   lh.standard_opcode_lengths[0] = 1;
3770   for (i = 1; i < lh.opcode_base; ++i)
3771     {
3772       lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
3773       line_ptr += 1;
3774     }
3775
3776   /* Read directory table  */
3777   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
3778     {
3779       line_ptr += bytes_read;
3780       if ((dirs.num_dirs % DIR_ALLOC_CHUNK) == 0)
3781         {
3782           dirs.dirs = (char **)
3783             xrealloc (dirs.dirs,
3784                       (dirs.num_dirs + DIR_ALLOC_CHUNK) * sizeof (char *));
3785           if (dirs.num_dirs == 0)
3786             make_cleanup (free_current_contents, &dirs.dirs);
3787         }
3788       dirs.dirs[dirs.num_dirs++] = cur_dir;
3789     }
3790   line_ptr += bytes_read;
3791
3792   /* Read file name table */
3793   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
3794     {
3795       line_ptr += bytes_read;
3796       if ((files.num_files % FILE_ALLOC_CHUNK) == 0)
3797         {
3798           files.files = (struct fileinfo *)
3799             xrealloc (files.files,
3800                       (files.num_files + FILE_ALLOC_CHUNK)
3801                         * sizeof (struct fileinfo));
3802           if (files.num_files == 0)
3803             make_cleanup (free_current_contents, &files.files);
3804         }
3805       files.files[files.num_files].name = cur_file;
3806       files.files[files.num_files].dir =
3807         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3808       line_ptr += bytes_read;
3809       files.files[files.num_files].time =
3810         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3811       line_ptr += bytes_read;
3812       files.files[files.num_files].size =
3813         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3814       line_ptr += bytes_read;
3815       files.num_files++;
3816     }
3817   line_ptr += bytes_read;
3818
3819   /* Read the statement sequences until there's nothing left.  */
3820   while (line_ptr < line_end)
3821     {
3822       /* state machine registers  */
3823       unsigned int address = 0;
3824       unsigned int file = 1;
3825       unsigned int line = 1;
3826       unsigned int column = 0;
3827       int is_stmt = lh.default_is_stmt;
3828       int basic_block = 0;
3829       int end_sequence = 0;
3830
3831       /* Start a subfile for the current file of the state machine.  */
3832       if (files.num_files >= file)
3833         {
3834           /* The file and directory tables are 0 based, the references
3835              are 1 based.  */
3836           dwarf2_start_subfile (files.files[file - 1].name,
3837                                 (files.files[file - 1].dir
3838                                  ? dirs.dirs[files.files[file - 1].dir - 1]
3839                                  : comp_dir));
3840         }
3841
3842       /* Decode the table. */
3843       while (! end_sequence)
3844         {
3845           op_code = read_1_byte (abfd, line_ptr);
3846           line_ptr += 1;
3847           switch (op_code)
3848             {
3849             case DW_LNS_extended_op:
3850               line_ptr += 1;    /* ignore length */
3851               extended_op = read_1_byte (abfd, line_ptr);
3852               line_ptr += 1;
3853               switch (extended_op)
3854                 {
3855                 case DW_LNE_end_sequence:
3856                   end_sequence = 1;
3857                   record_line (current_subfile, line, address);
3858                   break;
3859                 case DW_LNE_set_address:
3860                   address = read_address (abfd, line_ptr) + baseaddr;
3861                   line_ptr += address_size;
3862                   break;
3863                 case DW_LNE_define_file:
3864                   cur_file = read_string (abfd, line_ptr, &bytes_read);
3865                   line_ptr += bytes_read;
3866                   if ((files.num_files % FILE_ALLOC_CHUNK) == 0)
3867                     {
3868                       files.files = (struct fileinfo *)
3869                         xrealloc (files.files,
3870                                   (files.num_files + FILE_ALLOC_CHUNK)
3871                                     * sizeof (struct fileinfo));
3872                       if (files.num_files == 0)
3873                         make_cleanup (free_current_contents, &files.files);
3874                     }
3875                   files.files[files.num_files].name = cur_file;
3876                   files.files[files.num_files].dir =
3877                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3878                   line_ptr += bytes_read;
3879                   files.files[files.num_files].time =
3880                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3881                   line_ptr += bytes_read;
3882                   files.files[files.num_files].size =
3883                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3884                   line_ptr += bytes_read;
3885                   files.num_files++;
3886                   break;
3887                 default:
3888                   complain (&dwarf2_mangled_line_number_section);
3889                   goto done;
3890                 }
3891               break;
3892             case DW_LNS_copy:
3893               record_line (current_subfile, line, address);
3894               basic_block = 0;
3895               break;
3896             case DW_LNS_advance_pc:
3897               address += lh.minimum_instruction_length
3898                 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3899               line_ptr += bytes_read;
3900               break;
3901             case DW_LNS_advance_line:
3902               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
3903               line_ptr += bytes_read;
3904               break;
3905             case DW_LNS_set_file:
3906               /* The file and directory tables are 0 based, the references
3907                  are 1 based.  */
3908               file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3909               line_ptr += bytes_read;
3910               dwarf2_start_subfile
3911                 (files.files[file - 1].name,
3912                  (files.files[file - 1].dir
3913                   ? dirs.dirs[files.files[file - 1].dir - 1]
3914                   : comp_dir));
3915               break;
3916             case DW_LNS_set_column:
3917               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
3918               line_ptr += bytes_read;
3919               break;
3920             case DW_LNS_negate_stmt:
3921               is_stmt = (!is_stmt);
3922               break;
3923             case DW_LNS_set_basic_block:
3924               basic_block = 1;
3925               break;
3926             case DW_LNS_const_add_pc:
3927               address += (255 - lh.opcode_base) / lh.line_range;
3928               break;
3929             case DW_LNS_fixed_advance_pc:
3930               address += read_2_bytes (abfd, line_ptr);
3931               line_ptr += 2;
3932               break;
3933             default:            /* special operand */
3934               adj_opcode = op_code - lh.opcode_base;
3935               address += (adj_opcode / lh.line_range)
3936                 * lh.minimum_instruction_length;
3937               line += lh.line_base + (adj_opcode % lh.line_range);
3938               /* append row to matrix using current values */
3939               record_line (current_subfile, line, address);
3940               basic_block = 1;
3941             }
3942         }
3943     }
3944 done:
3945   do_cleanups (back_to);
3946 }
3947
3948 /* Start a subfile for DWARF.  FILENAME is the name of the file and
3949    DIRNAME the name of the source directory which contains FILENAME
3950    or NULL if not known.
3951    This routine tries to keep line numbers from identical absolute and
3952    relative file names in a common subfile.
3953
3954    Using the `list' example from the GDB testsuite, which resides in
3955    /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
3956    of /srcdir/list0.c yields the following debugging information for list0.c:
3957
3958         DW_AT_name:             /srcdir/list0.c
3959         DW_AT_comp_dir:         /compdir
3960         files.files[0].name:    list0.h
3961         files.files[0].dir:     /srcdir
3962         files.files[1].name:    list0.c
3963         files.files[1].dir:     /srcdir
3964
3965    The line number information for list0.c has to end up in a single
3966    subfile, so that `break /srcdir/list0.c:1' works as expected.  */
3967
3968 static void
3969 dwarf2_start_subfile (filename, dirname)
3970      char *filename;
3971      char *dirname;
3972 {
3973   /* If the filename isn't absolute, try to match an existing subfile
3974      with the full pathname.  */
3975
3976   if (*filename != '/' && dirname != NULL)
3977     {
3978       struct subfile *subfile;
3979       char *fullname = concat (dirname, "/", filename, NULL);
3980
3981       for (subfile = subfiles; subfile; subfile = subfile->next)
3982         {
3983           if (STREQ (subfile->name, fullname))
3984             {
3985               current_subfile = subfile;
3986               free (fullname);
3987               return;
3988             }
3989         }
3990       free (fullname);
3991     }
3992   start_subfile (filename, dirname);
3993 }
3994
3995 /* Given a pointer to a DWARF information entry, figure out if we need
3996    to make a symbol table entry for it, and if so, create a new entry
3997    and return a pointer to it.
3998    If TYPE is NULL, determine symbol type from the die, otherwise
3999    used the passed type.
4000   */
4001
4002 static struct symbol *
4003 new_symbol (die, type, objfile)
4004      struct die_info *die;
4005      struct type *type;
4006      struct objfile *objfile;
4007 {
4008   struct symbol *sym = NULL;
4009   char *name;
4010   struct attribute *attr = NULL;
4011   struct attribute *attr2 = NULL;
4012   CORE_ADDR addr;
4013
4014   name = dwarf2_linkage_name (die);
4015   if (name)
4016     {
4017       sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
4018                                              sizeof (struct symbol));
4019       OBJSTAT (objfile, n_syms++);
4020       memset (sym, 0, sizeof (struct symbol));
4021       SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
4022                                         &objfile->symbol_obstack);
4023
4024       /* Default assumptions.
4025          Use the passed type or decode it from the die.  */
4026       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
4027       SYMBOL_CLASS (sym) = LOC_STATIC;
4028       if (type != NULL)
4029         SYMBOL_TYPE (sym) = type;
4030       else
4031         SYMBOL_TYPE (sym) = die_type (die, objfile);
4032       attr = dwarf_attr (die, DW_AT_decl_line);
4033       if (attr)
4034         {
4035           SYMBOL_LINE (sym) = DW_UNSND (attr);
4036         }
4037
4038       /* If this symbol is from a C++ compilation, then attempt to
4039          cache the demangled form for future reference.  This is a
4040          typical time versus space tradeoff, that was decided in favor
4041          of time because it sped up C++ symbol lookups by a factor of
4042          about 20. */
4043
4044       SYMBOL_LANGUAGE (sym) = cu_language;
4045       SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
4046       switch (die->tag)
4047         {
4048         case DW_TAG_label:
4049           attr = dwarf_attr (die, DW_AT_low_pc);
4050           if (attr)
4051             {
4052               SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
4053             }
4054           SYMBOL_CLASS (sym) = LOC_LABEL;
4055           break;
4056         case DW_TAG_subprogram:
4057           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
4058              finish_block.  */
4059           SYMBOL_CLASS (sym) = LOC_BLOCK;
4060           attr2 = dwarf_attr (die, DW_AT_external);
4061           if (attr2 && (DW_UNSND (attr2) != 0))
4062             {
4063               add_symbol_to_list (sym, &global_symbols);
4064             }
4065           else
4066             {
4067               add_symbol_to_list (sym, list_in_scope);
4068             }
4069           break;
4070         case DW_TAG_variable:
4071           /* Compilation with minimal debug info may result in variables
4072              with missing type entries. Change the misleading `void' type
4073              to something sensible.  */
4074           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
4075             SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
4076                                            TARGET_INT_BIT / HOST_CHAR_BIT, 0,
4077                                            "<variable, no debug info>",
4078                                            objfile);
4079           attr = dwarf_attr (die, DW_AT_const_value);
4080           if (attr)
4081             {
4082               dwarf2_const_value (attr, sym, objfile);
4083               attr2 = dwarf_attr (die, DW_AT_external);
4084               if (attr2 && (DW_UNSND (attr2) != 0))
4085                 add_symbol_to_list (sym, &global_symbols);
4086               else
4087                 add_symbol_to_list (sym, list_in_scope);
4088               break;
4089             }
4090           attr = dwarf_attr (die, DW_AT_location);
4091           if (attr)
4092             {
4093               attr2 = dwarf_attr (die, DW_AT_external);
4094               if (attr2 && (DW_UNSND (attr2) != 0))
4095                 {
4096                   SYMBOL_VALUE_ADDRESS (sym) =
4097                     decode_locdesc (DW_BLOCK (attr), objfile);
4098                   add_symbol_to_list (sym, &global_symbols);
4099
4100                   /* In shared libraries the address of the variable
4101                      in the location descriptor might still be relocatable,
4102                      so its value could be zero.
4103                      Enter the symbol as a LOC_UNRESOLVED symbol, if its
4104                      value is zero, the address of the variable will then
4105                      be determined from the minimal symbol table whenever
4106                      the variable is referenced.  */
4107                   if (SYMBOL_VALUE_ADDRESS (sym))
4108                     {
4109                       SYMBOL_VALUE_ADDRESS (sym) += baseaddr;
4110                       SYMBOL_CLASS (sym) = LOC_STATIC;
4111                     }
4112                   else
4113                     SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
4114                 }
4115               else
4116                 {
4117                   SYMBOL_VALUE (sym) = addr =
4118                     decode_locdesc (DW_BLOCK (attr), objfile);
4119                   add_symbol_to_list (sym, list_in_scope);
4120                   if (optimized_out)
4121                     {
4122                       SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
4123                     }
4124                   else if (isreg)
4125                     {
4126                       SYMBOL_CLASS (sym) = LOC_REGISTER;
4127                     }
4128                   else if (offreg)
4129                     {
4130                       SYMBOL_CLASS (sym) = LOC_BASEREG;
4131                       SYMBOL_BASEREG (sym) = basereg;
4132                     }
4133                   else if (islocal)
4134                     {
4135                       SYMBOL_CLASS (sym) = LOC_LOCAL;
4136                     }
4137                   else
4138                     {
4139                       SYMBOL_CLASS (sym) = LOC_STATIC;
4140                       SYMBOL_VALUE_ADDRESS (sym) = addr + baseaddr;
4141                     }
4142                 }
4143             }
4144           else
4145             {
4146               /* We do not know the address of this symbol.
4147                  If it is an external symbol and we have type information
4148                  for it, enter the symbol as a LOC_UNRESOLVED symbol.
4149                  The address of the variable will then be determined from
4150                  the minimal symbol table whenever the variable is
4151                  referenced.  */
4152               attr2 = dwarf_attr (die, DW_AT_external);
4153               if (attr2 && (DW_UNSND (attr2) != 0)
4154                   && dwarf_attr (die, DW_AT_type) != NULL)
4155                 {
4156                   SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
4157                   add_symbol_to_list (sym, &global_symbols);
4158                 }
4159             }
4160           break;
4161         case DW_TAG_formal_parameter:
4162           attr = dwarf_attr (die, DW_AT_location);
4163           if (attr)
4164             {
4165               SYMBOL_VALUE (sym) = decode_locdesc (DW_BLOCK (attr), objfile);
4166               if (isreg)
4167                 {
4168                   SYMBOL_CLASS (sym) = LOC_REGPARM;
4169                 }
4170               else if (offreg)
4171                 {
4172                   SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
4173                   SYMBOL_BASEREG (sym) = basereg;
4174                 }
4175               else
4176                 {
4177                   SYMBOL_CLASS (sym) = LOC_ARG;
4178                 }
4179             }
4180           attr = dwarf_attr (die, DW_AT_const_value);
4181           if (attr)
4182             {
4183               dwarf2_const_value (attr, sym, objfile);
4184             }
4185           add_symbol_to_list (sym, list_in_scope);
4186           break;
4187         case DW_TAG_unspecified_parameters:
4188           /* From varargs functions; gdb doesn't seem to have any
4189              interest in this information, so just ignore it for now.
4190              (FIXME?) */
4191           break;
4192         case DW_TAG_class_type:
4193         case DW_TAG_structure_type:
4194         case DW_TAG_union_type:
4195         case DW_TAG_enumeration_type:
4196           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
4197           SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
4198           add_symbol_to_list (sym, list_in_scope);
4199
4200           /* The semantics of C++ state that "struct foo { ... }" also
4201              defines a typedef for "foo". Synthesize a typedef symbol so
4202              that "ptype foo" works as expected.  */
4203           if (cu_language == language_cplus)
4204             {
4205               struct symbol *typedef_sym = (struct symbol *)
4206                 obstack_alloc (&objfile->symbol_obstack,
4207                                sizeof (struct symbol));
4208               *typedef_sym = *sym;
4209               SYMBOL_NAMESPACE (typedef_sym) = VAR_NAMESPACE;
4210               if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
4211                 TYPE_NAME (SYMBOL_TYPE (sym)) =
4212                   obsavestring (SYMBOL_NAME (sym),
4213                                 strlen (SYMBOL_NAME (sym)),
4214                                 &objfile->type_obstack);
4215               add_symbol_to_list (typedef_sym, list_in_scope);
4216             }
4217           break;
4218         case DW_TAG_typedef:
4219         case DW_TAG_base_type:
4220           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
4221           SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
4222           add_symbol_to_list (sym, list_in_scope);
4223           break;
4224         case DW_TAG_enumerator:
4225           attr = dwarf_attr (die, DW_AT_const_value);
4226           if (attr)
4227             {
4228               dwarf2_const_value (attr, sym, objfile);
4229             }
4230           add_symbol_to_list (sym, list_in_scope);
4231           break;
4232         default:
4233           /* Not a tag we recognize.  Hopefully we aren't processing
4234              trash data, but since we must specifically ignore things
4235              we don't recognize, there is nothing else we should do at
4236              this point. */
4237           complain (&dwarf2_unsupported_tag, dwarf_tag_name (die->tag));
4238           break;
4239         }
4240     }
4241   return (sym);
4242 }
4243
4244 /* Copy constant value from an attribute to a symbol.  */
4245
4246 static void
4247 dwarf2_const_value (attr, sym, objfile)
4248      struct attribute *attr;
4249      struct symbol *sym;
4250      struct objfile *objfile;
4251 {
4252   struct dwarf_block *blk;
4253
4254   switch (attr->form)
4255     {
4256     case DW_FORM_addr:
4257       if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != (unsigned int) address_size)
4258         complain (&dwarf2_const_value_length_mismatch, SYMBOL_NAME (sym),
4259                   address_size, TYPE_LENGTH (SYMBOL_TYPE (sym)));
4260       SYMBOL_VALUE_BYTES (sym) = (char *)
4261         obstack_alloc (&objfile->symbol_obstack, address_size);
4262       store_address (SYMBOL_VALUE_BYTES (sym), address_size, DW_ADDR (attr));
4263       SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
4264       break;
4265     case DW_FORM_block1:
4266     case DW_FORM_block2:
4267     case DW_FORM_block4:
4268     case DW_FORM_block:
4269       blk = DW_BLOCK (attr);
4270       if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
4271         complain (&dwarf2_const_value_length_mismatch, SYMBOL_NAME (sym),
4272                   blk->size, TYPE_LENGTH (SYMBOL_TYPE (sym)));
4273       SYMBOL_VALUE_BYTES (sym) = (char *)
4274         obstack_alloc (&objfile->symbol_obstack, blk->size);
4275       memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
4276       SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
4277       break;
4278     case DW_FORM_data2:
4279     case DW_FORM_data4:
4280     case DW_FORM_data8:
4281     case DW_FORM_data1:
4282     case DW_FORM_sdata:
4283     case DW_FORM_udata:
4284       SYMBOL_VALUE (sym) = DW_UNSND (attr);
4285       SYMBOL_CLASS (sym) = LOC_CONST;
4286       break;
4287     default:
4288       complain (&dwarf2_unsupported_const_value_attr,
4289                 dwarf_form_name (attr->form));
4290       SYMBOL_VALUE (sym) = 0;
4291       SYMBOL_CLASS (sym) = LOC_CONST;
4292       break;
4293     }
4294 }
4295
4296 /* Return the type of the die in question using its DW_AT_type attribute.  */
4297
4298 static struct type *
4299 die_type (die, objfile)
4300      struct die_info *die;
4301      struct objfile *objfile;
4302 {
4303   struct type *type;
4304   struct attribute *type_attr;
4305   struct die_info *type_die;
4306   unsigned int ref;
4307
4308   type_attr = dwarf_attr (die, DW_AT_type);
4309   if (!type_attr)
4310     {
4311       /* A missing DW_AT_type represents a void type.  */
4312       return dwarf2_fundamental_type (objfile, FT_VOID);
4313     }
4314   else
4315     {
4316       ref = dwarf2_get_ref_die_offset (type_attr);
4317       type_die = follow_die_ref (ref);
4318       if (!type_die)
4319         {
4320           error ("Dwarf Error: Cannot find referent at offset %d.", ref);
4321           return NULL;
4322         }
4323     }
4324   type = tag_type_to_type (type_die, objfile);
4325   if (!type)
4326     {
4327       dump_die (type_die);
4328       error ("Dwarf Error: Problem turning type die at offset into gdb type.");
4329     }
4330   return type;
4331 }
4332
4333 /* Return the containing type of the die in question using its
4334    DW_AT_containing_type attribute.  */
4335
4336 static struct type *
4337 die_containing_type (die, objfile)
4338      struct die_info *die;
4339      struct objfile *objfile;
4340 {
4341   struct type *type = NULL;
4342   struct attribute *type_attr;
4343   struct die_info *type_die = NULL;
4344   unsigned int ref;
4345
4346   type_attr = dwarf_attr (die, DW_AT_containing_type);
4347   if (type_attr)
4348     {
4349       ref = dwarf2_get_ref_die_offset (type_attr);
4350       type_die = follow_die_ref (ref);
4351       if (!type_die)
4352         {
4353           error ("Dwarf Error: Cannot find referent at offset %d.", ref);
4354           return NULL;
4355         }
4356       type = tag_type_to_type (type_die, objfile);
4357     }
4358   if (!type)
4359     {
4360       if (type_die)
4361         dump_die (type_die);
4362       error ("Dwarf Error: Problem turning containing type into gdb type.");
4363     }
4364   return type;
4365 }
4366
4367 #if 0
4368 static struct type *
4369 type_at_offset (offset, objfile)
4370      unsigned int offset;
4371      struct objfile *objfile;
4372 {
4373   struct die_info *die;
4374   struct type *type;
4375
4376   die = follow_die_ref (offset);
4377   if (!die)
4378     {
4379       error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
4380       return NULL;
4381     }
4382   type = tag_type_to_type (die, objfile);
4383   return type;
4384 }
4385 #endif
4386
4387 static struct type *
4388 tag_type_to_type (die, objfile)
4389      struct die_info *die;
4390      struct objfile *objfile;
4391 {
4392   if (die->type)
4393     {
4394       return die->type;
4395     }
4396   else
4397     {
4398       read_type_die (die, objfile);
4399       if (!die->type)
4400         {
4401           dump_die (die);
4402           error ("Dwarf Error: Cannot find type of die.");
4403         }
4404       return die->type;
4405     }
4406 }
4407
4408 static void
4409 read_type_die (die, objfile)
4410      struct die_info *die;
4411      struct objfile *objfile;
4412 {
4413   switch (die->tag)
4414     {
4415     case DW_TAG_class_type:
4416     case DW_TAG_structure_type:
4417     case DW_TAG_union_type:
4418       read_structure_scope (die, objfile);
4419       break;
4420     case DW_TAG_enumeration_type:
4421       read_enumeration (die, objfile);
4422       break;
4423     case DW_TAG_subprogram:
4424     case DW_TAG_subroutine_type:
4425       read_subroutine_type (die, objfile);
4426       break;
4427     case DW_TAG_array_type:
4428       read_array_type (die, objfile);
4429       break;
4430     case DW_TAG_pointer_type:
4431       read_tag_pointer_type (die, objfile);
4432       break;
4433     case DW_TAG_ptr_to_member_type:
4434       read_tag_ptr_to_member_type (die, objfile);
4435       break;
4436     case DW_TAG_reference_type:
4437       read_tag_reference_type (die, objfile);
4438       break;
4439     case DW_TAG_const_type:
4440       read_tag_const_type (die, objfile);
4441       break;
4442     case DW_TAG_volatile_type:
4443       read_tag_volatile_type (die, objfile);
4444       break;
4445     case DW_TAG_string_type:
4446       read_tag_string_type (die, objfile);
4447       break;
4448     case DW_TAG_typedef:
4449       read_typedef (die, objfile);
4450       break;
4451     case DW_TAG_base_type:
4452       read_base_type (die, objfile);
4453       break;
4454     default:
4455       complain (&dwarf2_unexpected_tag, dwarf_tag_name (die->tag));
4456       break;
4457     }
4458 }
4459
4460 static struct type *
4461 dwarf_base_type (encoding, size, objfile)
4462      int encoding;
4463      int size;
4464      struct objfile *objfile;
4465 {
4466   /* FIXME - this should not produce a new (struct type *)
4467      every time.  It should cache base types.  */
4468   struct type *type;
4469   switch (encoding)
4470     {
4471     case DW_ATE_address:
4472       type = dwarf2_fundamental_type (objfile, FT_VOID);
4473       return type;
4474     case DW_ATE_boolean:
4475       type = dwarf2_fundamental_type (objfile, FT_BOOLEAN);
4476       return type;
4477     case DW_ATE_complex_float:
4478       if (size == 16)
4479         {
4480           type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX);
4481         }
4482       else
4483         {
4484           type = dwarf2_fundamental_type (objfile, FT_COMPLEX);
4485         }
4486       return type;
4487     case DW_ATE_float:
4488       if (size == 8)
4489         {
4490           type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT);
4491         }
4492       else
4493         {
4494           type = dwarf2_fundamental_type (objfile, FT_FLOAT);
4495         }
4496       return type;
4497     case DW_ATE_signed:
4498       switch (size)
4499         {
4500         case 1:
4501           type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR);
4502           break;
4503         case 2:
4504           type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT);
4505           break;
4506         default:
4507         case 4:
4508           type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER);
4509           break;
4510         }
4511       return type;
4512     case DW_ATE_signed_char:
4513       type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR);
4514       return type;
4515     case DW_ATE_unsigned:
4516       switch (size)
4517         {
4518         case 1:
4519           type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR);
4520           break;
4521         case 2:
4522           type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT);
4523           break;
4524         default:
4525         case 4:
4526           type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER);
4527           break;
4528         }
4529       return type;
4530     case DW_ATE_unsigned_char:
4531       type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR);
4532       return type;
4533     default:
4534       type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER);
4535       return type;
4536     }
4537 }
4538
4539 #if 0
4540 struct die_info *
4541 copy_die (old_die)
4542      struct die_info *old_die;
4543 {
4544   struct die_info *new_die;
4545   int i, num_attrs;
4546
4547   new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
4548   memset (new_die, 0, sizeof (struct die_info));
4549
4550   new_die->tag = old_die->tag;
4551   new_die->has_children = old_die->has_children;
4552   new_die->abbrev = old_die->abbrev;
4553   new_die->offset = old_die->offset;
4554   new_die->type = NULL;
4555
4556   num_attrs = old_die->num_attrs;
4557   new_die->num_attrs = num_attrs;
4558   new_die->attrs = (struct attribute *)
4559     xmalloc (num_attrs * sizeof (struct attribute));
4560
4561   for (i = 0; i < old_die->num_attrs; ++i)
4562     {
4563       new_die->attrs[i].name = old_die->attrs[i].name;
4564       new_die->attrs[i].form = old_die->attrs[i].form;
4565       new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
4566     }
4567
4568   new_die->next = NULL;
4569   return new_die;
4570 }
4571 #endif
4572
4573 /* Return sibling of die, NULL if no sibling.  */
4574
4575 struct die_info *
4576 sibling_die (die)
4577      struct die_info *die;
4578 {
4579   int nesting_level = 0;
4580
4581   if (!die->has_children)
4582     {
4583       if (die->next && (die->next->tag == 0))
4584         {
4585           return NULL;
4586         }
4587       else
4588         {
4589           return die->next;
4590         }
4591     }
4592   else
4593     {
4594       do
4595         {
4596           if (die->has_children)
4597             {
4598               nesting_level++;
4599             }
4600           if (die->tag == 0)
4601             {
4602               nesting_level--;
4603             }
4604           die = die->next;
4605         }
4606       while (nesting_level);
4607       if (die && (die->tag == 0))
4608         {
4609           return NULL;
4610         }
4611       else
4612         {
4613           return die;
4614         }
4615     }
4616 }
4617
4618 /* Get linkage name of a die, return NULL if not found.  */
4619
4620 static char *
4621 dwarf2_linkage_name (die)
4622      struct die_info *die;
4623 {
4624   struct attribute *attr;
4625
4626   attr = dwarf_attr (die, DW_AT_MIPS_linkage_name);
4627   if (attr && DW_STRING (attr))
4628     return DW_STRING (attr);
4629   attr = dwarf_attr (die, DW_AT_name);
4630   if (attr && DW_STRING (attr))
4631     return DW_STRING (attr);
4632   return NULL;
4633 }
4634
4635 /* Convert a DIE tag into its string name.  */
4636
4637 static char *
4638 dwarf_tag_name (tag)
4639      register unsigned tag;
4640 {
4641   switch (tag)
4642     {
4643     case DW_TAG_padding:
4644       return "DW_TAG_padding";
4645     case DW_TAG_array_type:
4646       return "DW_TAG_array_type";
4647     case DW_TAG_class_type:
4648       return "DW_TAG_class_type";
4649     case DW_TAG_entry_point:
4650       return "DW_TAG_entry_point";
4651     case DW_TAG_enumeration_type:
4652       return "DW_TAG_enumeration_type";
4653     case DW_TAG_formal_parameter:
4654       return "DW_TAG_formal_parameter";
4655     case DW_TAG_imported_declaration:
4656       return "DW_TAG_imported_declaration";
4657     case DW_TAG_label:
4658       return "DW_TAG_label";
4659     case DW_TAG_lexical_block:
4660       return "DW_TAG_lexical_block";
4661     case DW_TAG_member:
4662       return "DW_TAG_member";
4663     case DW_TAG_pointer_type:
4664       return "DW_TAG_pointer_type";
4665     case DW_TAG_reference_type:
4666       return "DW_TAG_reference_type";
4667     case DW_TAG_compile_unit:
4668       return "DW_TAG_compile_unit";
4669     case DW_TAG_string_type:
4670       return "DW_TAG_string_type";
4671     case DW_TAG_structure_type:
4672       return "DW_TAG_structure_type";
4673     case DW_TAG_subroutine_type:
4674       return "DW_TAG_subroutine_type";
4675     case DW_TAG_typedef:
4676       return "DW_TAG_typedef";
4677     case DW_TAG_union_type:
4678       return "DW_TAG_union_type";
4679     case DW_TAG_unspecified_parameters:
4680       return "DW_TAG_unspecified_parameters";
4681     case DW_TAG_variant:
4682       return "DW_TAG_variant";
4683     case DW_TAG_common_block:
4684       return "DW_TAG_common_block";
4685     case DW_TAG_common_inclusion:
4686       return "DW_TAG_common_inclusion";
4687     case DW_TAG_inheritance:
4688       return "DW_TAG_inheritance";
4689     case DW_TAG_inlined_subroutine:
4690       return "DW_TAG_inlined_subroutine";
4691     case DW_TAG_module:
4692       return "DW_TAG_module";
4693     case DW_TAG_ptr_to_member_type:
4694       return "DW_TAG_ptr_to_member_type";
4695     case DW_TAG_set_type:
4696       return "DW_TAG_set_type";
4697     case DW_TAG_subrange_type:
4698       return "DW_TAG_subrange_type";
4699     case DW_TAG_with_stmt:
4700       return "DW_TAG_with_stmt";
4701     case DW_TAG_access_declaration:
4702       return "DW_TAG_access_declaration";
4703     case DW_TAG_base_type:
4704       return "DW_TAG_base_type";
4705     case DW_TAG_catch_block:
4706       return "DW_TAG_catch_block";
4707     case DW_TAG_const_type:
4708       return "DW_TAG_const_type";
4709     case DW_TAG_constant:
4710       return "DW_TAG_constant";
4711     case DW_TAG_enumerator:
4712       return "DW_TAG_enumerator";
4713     case DW_TAG_file_type:
4714       return "DW_TAG_file_type";
4715     case DW_TAG_friend:
4716       return "DW_TAG_friend";
4717     case DW_TAG_namelist:
4718       return "DW_TAG_namelist";
4719     case DW_TAG_namelist_item:
4720       return "DW_TAG_namelist_item";
4721     case DW_TAG_packed_type:
4722       return "DW_TAG_packed_type";
4723     case DW_TAG_subprogram:
4724       return "DW_TAG_subprogram";
4725     case DW_TAG_template_type_param:
4726       return "DW_TAG_template_type_param";
4727     case DW_TAG_template_value_param:
4728       return "DW_TAG_template_value_param";
4729     case DW_TAG_thrown_type:
4730       return "DW_TAG_thrown_type";
4731     case DW_TAG_try_block:
4732       return "DW_TAG_try_block";
4733     case DW_TAG_variant_part:
4734       return "DW_TAG_variant_part";
4735     case DW_TAG_variable:
4736       return "DW_TAG_variable";
4737     case DW_TAG_volatile_type:
4738       return "DW_TAG_volatile_type";
4739     case DW_TAG_MIPS_loop:
4740       return "DW_TAG_MIPS_loop";
4741     case DW_TAG_format_label:
4742       return "DW_TAG_format_label";
4743     case DW_TAG_function_template:
4744       return "DW_TAG_function_template";
4745     case DW_TAG_class_template:
4746       return "DW_TAG_class_template";
4747     default:
4748       return "DW_TAG_<unknown>";
4749     }
4750 }
4751
4752 /* Convert a DWARF attribute code into its string name.  */
4753
4754 static char *
4755 dwarf_attr_name (attr)
4756      register unsigned attr;
4757 {
4758   switch (attr)
4759     {
4760     case DW_AT_sibling:
4761       return "DW_AT_sibling";
4762     case DW_AT_location:
4763       return "DW_AT_location";
4764     case DW_AT_name:
4765       return "DW_AT_name";
4766     case DW_AT_ordering:
4767       return "DW_AT_ordering";
4768     case DW_AT_subscr_data:
4769       return "DW_AT_subscr_data";
4770     case DW_AT_byte_size:
4771       return "DW_AT_byte_size";
4772     case DW_AT_bit_offset:
4773       return "DW_AT_bit_offset";
4774     case DW_AT_bit_size:
4775       return "DW_AT_bit_size";
4776     case DW_AT_element_list:
4777       return "DW_AT_element_list";
4778     case DW_AT_stmt_list:
4779       return "DW_AT_stmt_list";
4780     case DW_AT_low_pc:
4781       return "DW_AT_low_pc";
4782     case DW_AT_high_pc:
4783       return "DW_AT_high_pc";
4784     case DW_AT_language:
4785       return "DW_AT_language";
4786     case DW_AT_member:
4787       return "DW_AT_member";
4788     case DW_AT_discr:
4789       return "DW_AT_discr";
4790     case DW_AT_discr_value:
4791       return "DW_AT_discr_value";
4792     case DW_AT_visibility:
4793       return "DW_AT_visibility";
4794     case DW_AT_import:
4795       return "DW_AT_import";
4796     case DW_AT_string_length:
4797       return "DW_AT_string_length";
4798     case DW_AT_common_reference:
4799       return "DW_AT_common_reference";
4800     case DW_AT_comp_dir:
4801       return "DW_AT_comp_dir";
4802     case DW_AT_const_value:
4803       return "DW_AT_const_value";
4804     case DW_AT_containing_type:
4805       return "DW_AT_containing_type";
4806     case DW_AT_default_value:
4807       return "DW_AT_default_value";
4808     case DW_AT_inline:
4809       return "DW_AT_inline";
4810     case DW_AT_is_optional:
4811       return "DW_AT_is_optional";
4812     case DW_AT_lower_bound:
4813       return "DW_AT_lower_bound";
4814     case DW_AT_producer:
4815       return "DW_AT_producer";
4816     case DW_AT_prototyped:
4817       return "DW_AT_prototyped";
4818     case DW_AT_return_addr:
4819       return "DW_AT_return_addr";
4820     case DW_AT_start_scope:
4821       return "DW_AT_start_scope";
4822     case DW_AT_stride_size:
4823       return "DW_AT_stride_size";
4824     case DW_AT_upper_bound:
4825       return "DW_AT_upper_bound";
4826     case DW_AT_abstract_origin:
4827       return "DW_AT_abstract_origin";
4828     case DW_AT_accessibility:
4829       return "DW_AT_accessibility";
4830     case DW_AT_address_class:
4831       return "DW_AT_address_class";
4832     case DW_AT_artificial:
4833       return "DW_AT_artificial";
4834     case DW_AT_base_types:
4835       return "DW_AT_base_types";
4836     case DW_AT_calling_convention:
4837       return "DW_AT_calling_convention";
4838     case DW_AT_count:
4839       return "DW_AT_count";
4840     case DW_AT_data_member_location:
4841       return "DW_AT_data_member_location";
4842     case DW_AT_decl_column:
4843       return "DW_AT_decl_column";
4844     case DW_AT_decl_file:
4845       return "DW_AT_decl_file";
4846     case DW_AT_decl_line:
4847       return "DW_AT_decl_line";
4848     case DW_AT_declaration:
4849       return "DW_AT_declaration";
4850     case DW_AT_discr_list:
4851       return "DW_AT_discr_list";
4852     case DW_AT_encoding:
4853       return "DW_AT_encoding";
4854     case DW_AT_external:
4855       return "DW_AT_external";
4856     case DW_AT_frame_base:
4857       return "DW_AT_frame_base";
4858     case DW_AT_friend:
4859       return "DW_AT_friend";
4860     case DW_AT_identifier_case:
4861       return "DW_AT_identifier_case";
4862     case DW_AT_macro_info:
4863       return "DW_AT_macro_info";
4864     case DW_AT_namelist_items:
4865       return "DW_AT_namelist_items";
4866     case DW_AT_priority:
4867       return "DW_AT_priority";
4868     case DW_AT_segment:
4869       return "DW_AT_segment";
4870     case DW_AT_specification:
4871       return "DW_AT_specification";
4872     case DW_AT_static_link:
4873       return "DW_AT_static_link";
4874     case DW_AT_type:
4875       return "DW_AT_type";
4876     case DW_AT_use_location:
4877       return "DW_AT_use_location";
4878     case DW_AT_variable_parameter:
4879       return "DW_AT_variable_parameter";
4880     case DW_AT_virtuality:
4881       return "DW_AT_virtuality";
4882     case DW_AT_vtable_elem_location:
4883       return "DW_AT_vtable_elem_location";
4884
4885 #ifdef MIPS
4886     case DW_AT_MIPS_fde:
4887       return "DW_AT_MIPS_fde";
4888     case DW_AT_MIPS_loop_begin:
4889       return "DW_AT_MIPS_loop_begin";
4890     case DW_AT_MIPS_tail_loop_begin:
4891       return "DW_AT_MIPS_tail_loop_begin";
4892     case DW_AT_MIPS_epilog_begin:
4893       return "DW_AT_MIPS_epilog_begin";
4894     case DW_AT_MIPS_loop_unroll_factor:
4895       return "DW_AT_MIPS_loop_unroll_factor";
4896     case DW_AT_MIPS_software_pipeline_depth:
4897       return "DW_AT_MIPS_software_pipeline_depth";
4898     case DW_AT_MIPS_linkage_name:
4899       return "DW_AT_MIPS_linkage_name";
4900 #endif
4901
4902     case DW_AT_sf_names:
4903       return "DW_AT_sf_names";
4904     case DW_AT_src_info:
4905       return "DW_AT_src_info";
4906     case DW_AT_mac_info:
4907       return "DW_AT_mac_info";
4908     case DW_AT_src_coords:
4909       return "DW_AT_src_coords";
4910     case DW_AT_body_begin:
4911       return "DW_AT_body_begin";
4912     case DW_AT_body_end:
4913       return "DW_AT_body_end";
4914     default:
4915       return "DW_AT_<unknown>";
4916     }
4917 }
4918
4919 /* Convert a DWARF value form code into its string name.  */
4920
4921 static char *
4922 dwarf_form_name (form)
4923      register unsigned form;
4924 {
4925   switch (form)
4926     {
4927     case DW_FORM_addr:
4928       return "DW_FORM_addr";
4929     case DW_FORM_block2:
4930       return "DW_FORM_block2";
4931     case DW_FORM_block4:
4932       return "DW_FORM_block4";
4933     case DW_FORM_data2:
4934       return "DW_FORM_data2";
4935     case DW_FORM_data4:
4936       return "DW_FORM_data4";
4937     case DW_FORM_data8:
4938       return "DW_FORM_data8";
4939     case DW_FORM_string:
4940       return "DW_FORM_string";
4941     case DW_FORM_block:
4942       return "DW_FORM_block";
4943     case DW_FORM_block1:
4944       return "DW_FORM_block1";
4945     case DW_FORM_data1:
4946       return "DW_FORM_data1";
4947     case DW_FORM_flag:
4948       return "DW_FORM_flag";
4949     case DW_FORM_sdata:
4950       return "DW_FORM_sdata";
4951     case DW_FORM_strp:
4952       return "DW_FORM_strp";
4953     case DW_FORM_udata:
4954       return "DW_FORM_udata";
4955     case DW_FORM_ref_addr:
4956       return "DW_FORM_ref_addr";
4957     case DW_FORM_ref1:
4958       return "DW_FORM_ref1";
4959     case DW_FORM_ref2:
4960       return "DW_FORM_ref2";
4961     case DW_FORM_ref4:
4962       return "DW_FORM_ref4";
4963     case DW_FORM_ref8:
4964       return "DW_FORM_ref8";
4965     case DW_FORM_ref_udata:
4966       return "DW_FORM_ref_udata";
4967     case DW_FORM_indirect:
4968       return "DW_FORM_indirect";
4969     default:
4970       return "DW_FORM_<unknown>";
4971     }
4972 }
4973
4974 /* Convert a DWARF stack opcode into its string name.  */
4975
4976 static char *
4977 dwarf_stack_op_name (op)
4978      register unsigned op;
4979 {
4980   switch (op)
4981     {
4982     case DW_OP_addr:
4983       return "DW_OP_addr";
4984     case DW_OP_deref:
4985       return "DW_OP_deref";
4986     case DW_OP_const1u:
4987       return "DW_OP_const1u";
4988     case DW_OP_const1s:
4989       return "DW_OP_const1s";
4990     case DW_OP_const2u:
4991       return "DW_OP_const2u";
4992     case DW_OP_const2s:
4993       return "DW_OP_const2s";
4994     case DW_OP_const4u:
4995       return "DW_OP_const4u";
4996     case DW_OP_const4s:
4997       return "DW_OP_const4s";
4998     case DW_OP_const8u:
4999       return "DW_OP_const8u";
5000     case DW_OP_const8s:
5001       return "DW_OP_const8s";
5002     case DW_OP_constu:
5003       return "DW_OP_constu";
5004     case DW_OP_consts:
5005       return "DW_OP_consts";
5006     case DW_OP_dup:
5007       return "DW_OP_dup";
5008     case DW_OP_drop:
5009       return "DW_OP_drop";
5010     case DW_OP_over:
5011       return "DW_OP_over";
5012     case DW_OP_pick:
5013       return "DW_OP_pick";
5014     case DW_OP_swap:
5015       return "DW_OP_swap";
5016     case DW_OP_rot:
5017       return "DW_OP_rot";
5018     case DW_OP_xderef:
5019       return "DW_OP_xderef";
5020     case DW_OP_abs:
5021       return "DW_OP_abs";
5022     case DW_OP_and:
5023       return "DW_OP_and";
5024     case DW_OP_div:
5025       return "DW_OP_div";
5026     case DW_OP_minus:
5027       return "DW_OP_minus";
5028     case DW_OP_mod:
5029       return "DW_OP_mod";
5030     case DW_OP_mul:
5031       return "DW_OP_mul";
5032     case DW_OP_neg:
5033       return "DW_OP_neg";
5034     case DW_OP_not:
5035       return "DW_OP_not";
5036     case DW_OP_or:
5037       return "DW_OP_or";
5038     case DW_OP_plus:
5039       return "DW_OP_plus";
5040     case DW_OP_plus_uconst:
5041       return "DW_OP_plus_uconst";
5042     case DW_OP_shl:
5043       return "DW_OP_shl";
5044     case DW_OP_shr:
5045       return "DW_OP_shr";
5046     case DW_OP_shra:
5047       return "DW_OP_shra";
5048     case DW_OP_xor:
5049       return "DW_OP_xor";
5050     case DW_OP_bra:
5051       return "DW_OP_bra";
5052     case DW_OP_eq:
5053       return "DW_OP_eq";
5054     case DW_OP_ge:
5055       return "DW_OP_ge";
5056     case DW_OP_gt:
5057       return "DW_OP_gt";
5058     case DW_OP_le:
5059       return "DW_OP_le";
5060     case DW_OP_lt:
5061       return "DW_OP_lt";
5062     case DW_OP_ne:
5063       return "DW_OP_ne";
5064     case DW_OP_skip:
5065       return "DW_OP_skip";
5066     case DW_OP_lit0:
5067       return "DW_OP_lit0";
5068     case DW_OP_lit1:
5069       return "DW_OP_lit1";
5070     case DW_OP_lit2:
5071       return "DW_OP_lit2";
5072     case DW_OP_lit3:
5073       return "DW_OP_lit3";
5074     case DW_OP_lit4:
5075       return "DW_OP_lit4";
5076     case DW_OP_lit5:
5077       return "DW_OP_lit5";
5078     case DW_OP_lit6:
5079       return "DW_OP_lit6";
5080     case DW_OP_lit7:
5081       return "DW_OP_lit7";
5082     case DW_OP_lit8:
5083       return "DW_OP_lit8";
5084     case DW_OP_lit9:
5085       return "DW_OP_lit9";
5086     case DW_OP_lit10:
5087       return "DW_OP_lit10";
5088     case DW_OP_lit11:
5089       return "DW_OP_lit11";
5090     case DW_OP_lit12:
5091       return "DW_OP_lit12";
5092     case DW_OP_lit13:
5093       return "DW_OP_lit13";
5094     case DW_OP_lit14:
5095       return "DW_OP_lit14";
5096     case DW_OP_lit15:
5097       return "DW_OP_lit15";
5098     case DW_OP_lit16:
5099       return "DW_OP_lit16";
5100     case DW_OP_lit17:
5101       return "DW_OP_lit17";
5102     case DW_OP_lit18:
5103       return "DW_OP_lit18";
5104     case DW_OP_lit19:
5105       return "DW_OP_lit19";
5106     case DW_OP_lit20:
5107       return "DW_OP_lit20";
5108     case DW_OP_lit21:
5109       return "DW_OP_lit21";
5110     case DW_OP_lit22:
5111       return "DW_OP_lit22";
5112     case DW_OP_lit23:
5113       return "DW_OP_lit23";
5114     case DW_OP_lit24:
5115       return "DW_OP_lit24";
5116     case DW_OP_lit25:
5117       return "DW_OP_lit25";
5118     case DW_OP_lit26:
5119       return "DW_OP_lit26";
5120     case DW_OP_lit27:
5121       return "DW_OP_lit27";
5122     case DW_OP_lit28:
5123       return "DW_OP_lit28";
5124     case DW_OP_lit29:
5125       return "DW_OP_lit29";
5126     case DW_OP_lit30:
5127       return "DW_OP_lit30";
5128     case DW_OP_lit31:
5129       return "DW_OP_lit31";
5130     case DW_OP_reg0:
5131       return "DW_OP_reg0";
5132     case DW_OP_reg1:
5133       return "DW_OP_reg1";
5134     case DW_OP_reg2:
5135       return "DW_OP_reg2";
5136     case DW_OP_reg3:
5137       return "DW_OP_reg3";
5138     case DW_OP_reg4:
5139       return "DW_OP_reg4";
5140     case DW_OP_reg5:
5141       return "DW_OP_reg5";
5142     case DW_OP_reg6:
5143       return "DW_OP_reg6";
5144     case DW_OP_reg7:
5145       return "DW_OP_reg7";
5146     case DW_OP_reg8:
5147       return "DW_OP_reg8";
5148     case DW_OP_reg9:
5149       return "DW_OP_reg9";
5150     case DW_OP_reg10:
5151       return "DW_OP_reg10";
5152     case DW_OP_reg11:
5153       return "DW_OP_reg11";
5154     case DW_OP_reg12:
5155       return "DW_OP_reg12";
5156     case DW_OP_reg13:
5157       return "DW_OP_reg13";
5158     case DW_OP_reg14:
5159       return "DW_OP_reg14";
5160     case DW_OP_reg15:
5161       return "DW_OP_reg15";
5162     case DW_OP_reg16:
5163       return "DW_OP_reg16";
5164     case DW_OP_reg17:
5165       return "DW_OP_reg17";
5166     case DW_OP_reg18:
5167       return "DW_OP_reg18";
5168     case DW_OP_reg19:
5169       return "DW_OP_reg19";
5170     case DW_OP_reg20:
5171       return "DW_OP_reg20";
5172     case DW_OP_reg21:
5173       return "DW_OP_reg21";
5174     case DW_OP_reg22:
5175       return "DW_OP_reg22";
5176     case DW_OP_reg23:
5177       return "DW_OP_reg23";
5178     case DW_OP_reg24:
5179       return "DW_OP_reg24";
5180     case DW_OP_reg25:
5181       return "DW_OP_reg25";
5182     case DW_OP_reg26:
5183       return "DW_OP_reg26";
5184     case DW_OP_reg27:
5185       return "DW_OP_reg27";
5186     case DW_OP_reg28:
5187       return "DW_OP_reg28";
5188     case DW_OP_reg29:
5189       return "DW_OP_reg29";
5190     case DW_OP_reg30:
5191       return "DW_OP_reg30";
5192     case DW_OP_reg31:
5193       return "DW_OP_reg31";
5194     case DW_OP_breg0:
5195       return "DW_OP_breg0";
5196     case DW_OP_breg1:
5197       return "DW_OP_breg1";
5198     case DW_OP_breg2:
5199       return "DW_OP_breg2";
5200     case DW_OP_breg3:
5201       return "DW_OP_breg3";
5202     case DW_OP_breg4:
5203       return "DW_OP_breg4";
5204     case DW_OP_breg5:
5205       return "DW_OP_breg5";
5206     case DW_OP_breg6:
5207       return "DW_OP_breg6";
5208     case DW_OP_breg7:
5209       return "DW_OP_breg7";
5210     case DW_OP_breg8:
5211       return "DW_OP_breg8";
5212     case DW_OP_breg9:
5213       return "DW_OP_breg9";
5214     case DW_OP_breg10:
5215       return "DW_OP_breg10";
5216     case DW_OP_breg11:
5217       return "DW_OP_breg11";
5218     case DW_OP_breg12:
5219       return "DW_OP_breg12";
5220     case DW_OP_breg13:
5221       return "DW_OP_breg13";
5222     case DW_OP_breg14:
5223       return "DW_OP_breg14";
5224     case DW_OP_breg15:
5225       return "DW_OP_breg15";
5226     case DW_OP_breg16:
5227       return "DW_OP_breg16";
5228     case DW_OP_breg17:
5229       return "DW_OP_breg17";
5230     case DW_OP_breg18:
5231       return "DW_OP_breg18";
5232     case DW_OP_breg19:
5233       return "DW_OP_breg19";
5234     case DW_OP_breg20:
5235       return "DW_OP_breg20";
5236     case DW_OP_breg21:
5237       return "DW_OP_breg21";
5238     case DW_OP_breg22:
5239       return "DW_OP_breg22";
5240     case DW_OP_breg23:
5241       return "DW_OP_breg23";
5242     case DW_OP_breg24:
5243       return "DW_OP_breg24";
5244     case DW_OP_breg25:
5245       return "DW_OP_breg25";
5246     case DW_OP_breg26:
5247       return "DW_OP_breg26";
5248     case DW_OP_breg27:
5249       return "DW_OP_breg27";
5250     case DW_OP_breg28:
5251       return "DW_OP_breg28";
5252     case DW_OP_breg29:
5253       return "DW_OP_breg29";
5254     case DW_OP_breg30:
5255       return "DW_OP_breg30";
5256     case DW_OP_breg31:
5257       return "DW_OP_breg31";
5258     case DW_OP_regx:
5259       return "DW_OP_regx";
5260     case DW_OP_fbreg:
5261       return "DW_OP_fbreg";
5262     case DW_OP_bregx:
5263       return "DW_OP_bregx";
5264     case DW_OP_piece:
5265       return "DW_OP_piece";
5266     case DW_OP_deref_size:
5267       return "DW_OP_deref_size";
5268     case DW_OP_xderef_size:
5269       return "DW_OP_xderef_size";
5270     case DW_OP_nop:
5271       return "DW_OP_nop";
5272     default:
5273       return "OP_<unknown>";
5274     }
5275 }
5276
5277 static char *
5278 dwarf_bool_name (bool)
5279      unsigned bool;
5280 {
5281   if (bool)
5282     return "TRUE";
5283   else
5284     return "FALSE";
5285 }
5286
5287 /* Convert a DWARF type code into its string name.  */
5288
5289 static char *
5290 dwarf_type_encoding_name (enc)
5291      register unsigned enc;
5292 {
5293   switch (enc)
5294     {
5295     case DW_ATE_address:
5296       return "DW_ATE_address";
5297     case DW_ATE_boolean:
5298       return "DW_ATE_boolean";
5299     case DW_ATE_complex_float:
5300       return "DW_ATE_complex_float";
5301     case DW_ATE_float:
5302       return "DW_ATE_float";
5303     case DW_ATE_signed:
5304       return "DW_ATE_signed";
5305     case DW_ATE_signed_char:
5306       return "DW_ATE_signed_char";
5307     case DW_ATE_unsigned:
5308       return "DW_ATE_unsigned";
5309     case DW_ATE_unsigned_char:
5310       return "DW_ATE_unsigned_char";
5311     default:
5312       return "DW_ATE_<unknown>";
5313     }
5314 }
5315
5316 /* Convert a DWARF call frame info operation to its string name. */
5317
5318 #if 0
5319 static char *
5320 dwarf_cfi_name (cfi_opc)
5321      register unsigned cfi_opc;
5322 {
5323   switch (cfi_opc)
5324     {
5325     case DW_CFA_advance_loc:
5326       return "DW_CFA_advance_loc";
5327     case DW_CFA_offset:
5328       return "DW_CFA_offset";
5329     case DW_CFA_restore:
5330       return "DW_CFA_restore";
5331     case DW_CFA_nop:
5332       return "DW_CFA_nop";
5333     case DW_CFA_set_loc:
5334       return "DW_CFA_set_loc";
5335     case DW_CFA_advance_loc1:
5336       return "DW_CFA_advance_loc1";
5337     case DW_CFA_advance_loc2:
5338       return "DW_CFA_advance_loc2";
5339     case DW_CFA_advance_loc4:
5340       return "DW_CFA_advance_loc4";
5341     case DW_CFA_offset_extended:
5342       return "DW_CFA_offset_extended";
5343     case DW_CFA_restore_extended:
5344       return "DW_CFA_restore_extended";
5345     case DW_CFA_undefined:
5346       return "DW_CFA_undefined";
5347     case DW_CFA_same_value:
5348       return "DW_CFA_same_value";
5349     case DW_CFA_register:
5350       return "DW_CFA_register";
5351     case DW_CFA_remember_state:
5352       return "DW_CFA_remember_state";
5353     case DW_CFA_restore_state:
5354       return "DW_CFA_restore_state";
5355     case DW_CFA_def_cfa:
5356       return "DW_CFA_def_cfa";
5357     case DW_CFA_def_cfa_register:
5358       return "DW_CFA_def_cfa_register";
5359     case DW_CFA_def_cfa_offset:
5360       return "DW_CFA_def_cfa_offset";
5361       /* SGI/MIPS specific */
5362     case DW_CFA_MIPS_advance_loc8:
5363       return "DW_CFA_MIPS_advance_loc8";
5364     default:
5365       return "DW_CFA_<unknown>";
5366     }
5367 }
5368 #endif
5369
5370 void
5371 dump_die (die)
5372      struct die_info *die;
5373 {
5374   unsigned int i;
5375
5376   fprintf (stderr, "Die: %s (abbrev = %d, offset = %d)\n",
5377            dwarf_tag_name (die->tag), die->abbrev, die->offset);
5378   fprintf (stderr, "\thas children: %s\n",
5379            dwarf_bool_name (die->has_children));
5380
5381   fprintf (stderr, "\tattributes:\n");
5382   for (i = 0; i < die->num_attrs; ++i)
5383     {
5384       fprintf (stderr, "\t\t%s (%s) ",
5385                dwarf_attr_name (die->attrs[i].name),
5386                dwarf_form_name (die->attrs[i].form));
5387       switch (die->attrs[i].form)
5388         {
5389         case DW_FORM_ref_addr:
5390         case DW_FORM_addr:
5391           fprintf (stderr, "address: ");
5392           print_address_numeric (DW_ADDR (&die->attrs[i]), 1, stderr);
5393           break;
5394         case DW_FORM_block2:
5395         case DW_FORM_block4:
5396         case DW_FORM_block:
5397         case DW_FORM_block1:
5398           fprintf (stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
5399           break;
5400         case DW_FORM_data1:
5401         case DW_FORM_data2:
5402         case DW_FORM_data4:
5403         case DW_FORM_ref1:
5404         case DW_FORM_ref2:
5405         case DW_FORM_ref4:
5406         case DW_FORM_udata:
5407         case DW_FORM_sdata:
5408           fprintf (stderr, "constant: %d", DW_UNSND (&die->attrs[i]));
5409           break;
5410         case DW_FORM_string:
5411           fprintf (stderr, "string: \"%s\"",
5412                    DW_STRING (&die->attrs[i])
5413                      ? DW_STRING (&die->attrs[i]) : "");
5414           break;
5415         case DW_FORM_flag:
5416           if (DW_UNSND (&die->attrs[i]))
5417             fprintf (stderr, "flag: TRUE");
5418           else
5419             fprintf (stderr, "flag: FALSE");
5420           break;
5421         case DW_FORM_strp:      /* we do not support separate string
5422                                    section yet */
5423         case DW_FORM_indirect:  /* we do not handle indirect yet */
5424         case DW_FORM_data8:     /* we do not have 64 bit quantities */
5425         default:
5426           fprintf (stderr, "unsupported attribute form: %d.",
5427                            die->attrs[i].form);
5428         }
5429       fprintf (stderr, "\n");
5430     }
5431 }
5432
5433 void
5434 dump_die_list (die)
5435      struct die_info *die;
5436 {
5437   while (die)
5438     {
5439       dump_die (die);
5440       die = die->next;
5441     }
5442 }
5443
5444 void
5445 store_in_ref_table (offset, die)
5446      unsigned int offset;
5447      struct die_info *die;
5448 {
5449   int h;
5450   struct die_info *old;
5451
5452   h = (offset % REF_HASH_SIZE);
5453   old = die_ref_table[h];
5454   die->next_ref = old;
5455   die_ref_table[h] = die;
5456 }
5457
5458
5459 static void
5460 dwarf2_empty_die_ref_table ()
5461 {
5462   memset (die_ref_table, 0, sizeof (die_ref_table));
5463 }
5464
5465 static unsigned int
5466 dwarf2_get_ref_die_offset (attr)
5467      struct attribute *attr;
5468 {
5469   unsigned int result = 0;
5470
5471   switch (attr->form)
5472     {
5473     case DW_FORM_ref_addr:
5474       result = DW_ADDR (attr);
5475       break;
5476     case DW_FORM_ref1:
5477     case DW_FORM_ref2:
5478     case DW_FORM_ref4:
5479     case DW_FORM_ref_udata:
5480       result = cu_header_offset + DW_UNSND (attr);
5481       break;
5482     default:
5483       complain (&dwarf2_unsupported_die_ref_attr, dwarf_form_name (attr->form));
5484     }
5485   return result;
5486 }
5487
5488 struct die_info *
5489 follow_die_ref (offset)
5490      unsigned int offset;
5491 {
5492   struct die_info *die;
5493   int h;
5494
5495   h = (offset % REF_HASH_SIZE);
5496   die = die_ref_table[h];
5497   while (die)
5498     {
5499       if (die->offset == offset)
5500         {
5501           return die;
5502         }
5503       die = die->next_ref;
5504     }
5505   return NULL;
5506 }
5507
5508 static struct type *
5509 dwarf2_fundamental_type (objfile, typeid)
5510      struct objfile *objfile;
5511      int typeid;
5512 {
5513   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
5514     {
5515       error ("Dwarf Error: internal error - invalid fundamental type id %d.",
5516              typeid);
5517     }
5518
5519   /* Look for this particular type in the fundamental type vector.  If
5520      one is not found, create and install one appropriate for the
5521      current language and the current target machine. */
5522
5523   if (ftypes[typeid] == NULL)
5524     {
5525       ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);
5526     }
5527
5528   return (ftypes[typeid]);
5529 }
5530
5531 /* Decode simple location descriptions.
5532    Given a pointer to a dwarf block that defines a location, compute
5533    the location and return the value.
5534
5535    FIXME: This is a kludge until we figure out a better
5536    way to handle the location descriptions.
5537    Gdb's design does not mesh well with the DWARF2 notion of a location
5538    computing interpreter, which is a shame because the flexibility goes unused.
5539    FIXME: Implement more operations as necessary.
5540
5541    A location description containing no operations indicates that the
5542    object is optimized out. The global optimized_out flag is set for
5543    those, the return value is meaningless.
5544
5545    When the result is a register number, the global isreg flag is set,
5546    otherwise it is cleared.
5547
5548    When the result is a base register offset, the global offreg flag is set
5549    and the register number is returned in basereg, otherwise it is cleared.
5550
5551    When the DW_OP_fbreg operation is encountered without a corresponding
5552    DW_AT_frame_base attribute, the global islocal flag is set.
5553    Hopefully the machine dependent code knows how to set up a virtual
5554    frame pointer for the local references.
5555
5556    Note that stack[0] is unused except as a default error return.
5557    Note that stack overflow is not yet handled.  */
5558
5559 static CORE_ADDR
5560 decode_locdesc (blk, objfile)
5561      struct dwarf_block *blk;
5562      struct objfile *objfile;
5563 {
5564   int i;
5565   int size = blk->size;
5566   char *data = blk->data;
5567   CORE_ADDR stack[64];
5568   int stacki;
5569   unsigned int bytes_read, unsnd;
5570   unsigned char op;
5571
5572   i = 0;
5573   stacki = 0;
5574   stack[stacki] = 0;
5575   isreg = 0;
5576   offreg = 0;
5577   islocal = 0;
5578   optimized_out = 1;
5579
5580   while (i < size)
5581     {
5582       optimized_out = 0;
5583       op = data[i++];
5584       switch (op)
5585         {
5586         case DW_OP_reg0:
5587         case DW_OP_reg1:
5588         case DW_OP_reg2:
5589         case DW_OP_reg3:
5590         case DW_OP_reg4:
5591         case DW_OP_reg5:
5592         case DW_OP_reg6:
5593         case DW_OP_reg7:
5594         case DW_OP_reg8:
5595         case DW_OP_reg9:
5596         case DW_OP_reg10:
5597         case DW_OP_reg11:
5598         case DW_OP_reg12:
5599         case DW_OP_reg13:
5600         case DW_OP_reg14:
5601         case DW_OP_reg15:
5602         case DW_OP_reg16:
5603         case DW_OP_reg17:
5604         case DW_OP_reg18:
5605         case DW_OP_reg19:
5606         case DW_OP_reg20:
5607         case DW_OP_reg21:
5608         case DW_OP_reg22:
5609         case DW_OP_reg23:
5610         case DW_OP_reg24:
5611         case DW_OP_reg25:
5612         case DW_OP_reg26:
5613         case DW_OP_reg27:
5614         case DW_OP_reg28:
5615         case DW_OP_reg29:
5616         case DW_OP_reg30:
5617         case DW_OP_reg31:
5618           isreg = 1;
5619           stack[++stacki] = op - DW_OP_reg0;
5620           break;
5621
5622         case DW_OP_regx:
5623           isreg = 1;
5624           unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
5625           i += bytes_read;
5626 #if defined(HARRIS_TARGET) && defined(_M88K)
5627           /* The Harris 88110 gdb ports have long kept their special reg
5628              numbers between their gp-regs and their x-regs.  This is
5629              not how our dwarf is generated.  Punt. */
5630           unsnd += 6;
5631 #endif
5632           stack[++stacki] = unsnd;
5633           break;
5634
5635         case DW_OP_breg0:
5636         case DW_OP_breg1:
5637         case DW_OP_breg2:
5638         case DW_OP_breg3:
5639         case DW_OP_breg4:
5640         case DW_OP_breg5:
5641         case DW_OP_breg6:
5642         case DW_OP_breg7:
5643         case DW_OP_breg8:
5644         case DW_OP_breg9:
5645         case DW_OP_breg10:
5646         case DW_OP_breg11:
5647         case DW_OP_breg12:
5648         case DW_OP_breg13:
5649         case DW_OP_breg14:
5650         case DW_OP_breg15:
5651         case DW_OP_breg16:
5652         case DW_OP_breg17:
5653         case DW_OP_breg18:
5654         case DW_OP_breg19:
5655         case DW_OP_breg20:
5656         case DW_OP_breg21:
5657         case DW_OP_breg22:
5658         case DW_OP_breg23:
5659         case DW_OP_breg24:
5660         case DW_OP_breg25:
5661         case DW_OP_breg26:
5662         case DW_OP_breg27:
5663         case DW_OP_breg28:
5664         case DW_OP_breg29:
5665         case DW_OP_breg30:
5666         case DW_OP_breg31:
5667           offreg = 1;
5668           basereg = op - DW_OP_breg0;
5669           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
5670           i += bytes_read;
5671           break;
5672
5673         case DW_OP_fbreg:
5674           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
5675           i += bytes_read;
5676           if (frame_base_reg >= 0)
5677             {
5678               offreg = 1;
5679               basereg = frame_base_reg;
5680               stack[stacki] += frame_base_offset;
5681             }
5682           else
5683             {
5684               complain (&dwarf2_missing_at_frame_base);
5685               islocal = 1;
5686             }
5687           break;
5688
5689         case DW_OP_addr:
5690           stack[++stacki] = read_address (objfile->obfd, &data[i]);
5691           i += address_size;
5692           break;
5693
5694         case DW_OP_const1u:
5695           stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
5696           i += 1;
5697           break;
5698
5699         case DW_OP_const1s:
5700           stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
5701           i += 1;
5702           break;
5703
5704         case DW_OP_const2u:
5705           stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
5706           i += 2;
5707           break;
5708
5709         case DW_OP_const2s:
5710           stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
5711           i += 2;
5712           break;
5713
5714         case DW_OP_const4u:
5715           stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
5716           i += 4;
5717           break;
5718
5719         case DW_OP_const4s:
5720           stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
5721           i += 4;
5722           break;
5723
5724         case DW_OP_constu:
5725           stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
5726                                                          &bytes_read);
5727           i += bytes_read;
5728           break;
5729
5730         case DW_OP_consts:
5731           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
5732           i += bytes_read;
5733           break;
5734
5735         case DW_OP_plus:
5736           stack[stacki - 1] += stack[stacki];
5737           stacki--;
5738           break;
5739
5740         case DW_OP_plus_uconst:
5741           stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
5742           i += bytes_read;
5743           break;
5744
5745         case DW_OP_minus:
5746           stack[stacki - 1] = stack[stacki] - stack[stacki - 1];
5747           stacki--;
5748           break;
5749
5750         default:
5751           complain (&dwarf2_unsupported_stack_op, dwarf_stack_op_name(op));
5752           return (stack[stacki]);
5753         }
5754     }
5755   return (stack[stacki]);
5756 }
5757
5758 /* memory allocation interface */
5759
5760 /* ARGSUSED */
5761 static void
5762 dwarf2_free_tmp_obstack (ignore)
5763      PTR ignore;
5764 {
5765   obstack_free (&dwarf2_tmp_obstack, NULL);
5766 }
5767
5768 static struct dwarf_block *
5769 dwarf_alloc_block ()
5770 {
5771   struct dwarf_block *blk;
5772
5773   blk = (struct dwarf_block *)
5774     obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct dwarf_block));
5775   return (blk);
5776 }
5777
5778 static struct abbrev_info *
5779 dwarf_alloc_abbrev ()
5780 {
5781   struct abbrev_info *abbrev;
5782
5783   abbrev = (struct abbrev_info *) xmalloc (sizeof (struct abbrev_info));
5784   memset (abbrev, 0, sizeof (struct abbrev_info));
5785   return (abbrev);
5786 }
5787
5788 static struct die_info *
5789 dwarf_alloc_die ()
5790 {
5791   struct die_info *die;
5792
5793   die = (struct die_info *) xmalloc (sizeof (struct die_info));
5794   memset (die, 0, sizeof (struct die_info));
5795   return (die);
5796 }