gdb/dwarf2read.c

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