gdb/dwarfread.c

   1 /* DWARF debugging format support for GDB.
   2
   3    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4    2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   5
   6    Written by Fred Fish at Cygnus Support.  Portions based on dbxread.c,
   7    mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  24
  25 /*
  26    If you are looking for DWARF-2 support, you are in the wrong file.
  27    Go look in dwarf2read.c.  This file is for the original DWARF.
  28
  29    DWARF (also known as DWARF-1) is headed for obsoletion.
  30
  31    In gcc 3.2.1, these targets prefer dwarf-1:
  32
  33      i[34567]86-sequent-ptx4*   # TD-R2
  34      i[34567]86-sequent-sysv4*  # TD-R2
  35      i[34567]86-dg-dgux*        # obsolete in gcc 3.2.1, to be removed in 3.3
  36      m88k-dg-dgux*              # TD-R2
  37      mips-sni-sysv4             # TD-R2
  38      sparc-hal-solaris2*        # TD-R2
  39
  40     Configurations marked with "# TD-R2" are on Zach Weinberg's list
  41     of "Target Deprecation, Round 2".  This is a candidate list of
  42     targets to be deprecated in gcc 3.3 and removed in gcc 3.4.
  43
  44       http://gcc.gnu.org/ml/gcc/2002-12/msg00702.html
  45
  46     gcc 2.95.3 had many configurations which prefer dwarf-1.
  47     We may have to support dwarf-1 as long as we support gcc 2.95.3.
  48     This could use more analysis.
  49
  50     DG/UX (Data General Unix) used dwarf-1 for its native format.
  51     DG/UX uses gcc for its system C compiler, but they have their
  52     own linker and their own debuggers.
  53
  54     Takis Psarogiannakopoulos has a complete gnu toolchain for DG/UX
  55     with gcc 2.95.3, gdb 5.1, and debug formats of dwarf-2 and stabs.
  56     For more info, see PR gdb/979 and PR gdb/1013; also:
  57
  58       http://sources.redhat.com/ml/gdb/2003-02/msg00074.html
  59
  60     There may be non-gcc compilers that still emit dwarf-1.
  61
  62     -- chastain 2003-02-04
  63 */
  64
  65 /*
  66
  67    FIXME: Do we need to generate dependencies in partial symtabs?
  68    (Perhaps we don't need to).
  69
  70    FIXME: Resolve minor differences between what information we put in the
  71    partial symbol table and what dbxread puts in.  For example, we don't yet
  72    put enum constants there.  And dbxread seems to invent a lot of typedefs
  73    we never see.  Use the new printpsym command to see the partial symbol table
  74    contents.
  75
  76    FIXME: Figure out a better way to tell gdb about the name of the function
  77    contain the user's entry point (I.E. main())
  78
  79    FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
  80    other things to work on, if you get bored. :-)
  81
  82  */
  83
  84 #include "defs.h"
  85 #include "symtab.h"
  86 #include "gdbtypes.h"
  87 #include "symfile.h"
  88 #include "objfiles.h"
  89 #include "elf/dwarf.h"
  90 #include "buildsym.h"
  91 #include "demangle.h"
  92 #include "expression.h"         /* Needed for enum exp_opcode in language.h, sigh... */
  93 #include "language.h"
  94 #include "complaints.h"
  95
  96 #include <fcntl.h>
  97 #include "gdb_string.h"
  98
  99 /* Some macros to provide DIE info for complaints. */
 100
 101 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
 102 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
 103
 104 /* Complaints that can be issued during DWARF debug info reading. */
 105
 106 static void
 107 bad_die_ref_complaint (int arg1, const char *arg2, int arg3)
 108 {
 109   complaint (&symfile_complaints,
 110              "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit",
 111              arg1, arg2, arg3);
 112 }
 113
 114 static void
 115 unknown_attribute_form_complaint (int arg1, const char *arg2, int arg3)
 116 {
 117   complaint (&symfile_complaints,
 118              "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", arg1, arg2,
 119              arg3);
 120 }
 121
 122 static void
 123 dup_user_type_definition_complaint (int arg1, const char *arg2)
 124 {
 125   complaint (&symfile_complaints,
 126              "DIE @ 0x%x \"%s\", internal error: duplicate user type definition",
 127              arg1, arg2);
 128 }
 129
 130 static void
 131 bad_array_element_type_complaint (int arg1, const char *arg2, int arg3)
 132 {
 133   complaint (&symfile_complaints,
 134              "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", arg1,
 135              arg2, arg3);
 136 }
 137
 138 typedef unsigned int DIE_REF;   /* Reference to a DIE */
 139
 140 #ifndef GCC_PRODUCER
 141 #define GCC_PRODUCER "GNU C "
 142 #endif
 143
 144 #ifndef GPLUS_PRODUCER
 145 #define GPLUS_PRODUCER "GNU C++ "
 146 #endif
 147
 148 #ifndef LCC_PRODUCER
 149 #define LCC_PRODUCER "NCR C/C++"
 150 #endif
 151
 152 /* Flags to target_to_host() that tell whether or not the data object is
 153    expected to be signed.  Used, for example, when fetching a signed
 154    integer in the target environment which is used as a signed integer
 155    in the host environment, and the two environments have different sized
 156    ints.  In this case, *somebody* has to sign extend the smaller sized
 157    int. */
 158
 159 #define GET_UNSIGNED    0       /* No sign extension required */
 160 #define GET_SIGNED      1       /* Sign extension required */
 161
 162 /* Defines for things which are specified in the document "DWARF Debugging
 163    Information Format" published by UNIX International, Programming Languages
 164    SIG.  These defines are based on revision 1.0.0, Jan 20, 1992. */
 165
 166 #define SIZEOF_DIE_LENGTH       4
 167 #define SIZEOF_DIE_TAG          2
 168 #define SIZEOF_ATTRIBUTE        2
 169 #define SIZEOF_FORMAT_SPECIFIER 1
 170 #define SIZEOF_FMT_FT           2
 171 #define SIZEOF_LINETBL_LENGTH   4
 172 #define SIZEOF_LINETBL_LINENO   4
 173 #define SIZEOF_LINETBL_STMT     2
 174 #define SIZEOF_LINETBL_DELTA    4
 175 #define SIZEOF_LOC_ATOM_CODE    1
 176
 177 #define FORM_FROM_ATTR(attr)    ((attr) & 0xF)  /* Implicitly specified */
 178
 179 /* Macros that return the sizes of various types of data in the target
 180    environment.
 181
 182    FIXME:  Currently these are just compile time constants (as they are in
 183    other parts of gdb as well).  They need to be able to get the right size
 184    either from the bfd or possibly from the DWARF info.  It would be nice if
 185    the DWARF producer inserted DIES that describe the fundamental types in
 186    the target environment into the DWARF info, similar to the way dbx stabs
 187    producers produce information about their fundamental types. */
 188
 189 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
 190 #define TARGET_FT_LONG_SIZE(objfile)    (TARGET_LONG_BIT / TARGET_CHAR_BIT)
 191
 192 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
 193    FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
 194    However, the Issue 2 DWARF specification from AT&T defines it as
 195    a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
 196    For backwards compatibility with the AT&T compiler produced executables
 197    we define AT_short_element_list for this variant. */
 198
 199 #define AT_short_element_list    (0x00f0|FORM_BLOCK2)
 200
 201 /* The DWARF debugging information consists of two major pieces,
 202    one is a block of DWARF Information Entries (DIE's) and the other
 203    is a line number table.  The "struct dieinfo" structure contains
 204    the information for a single DIE, the one currently being processed.
 205
 206    In order to make it easier to randomly access the attribute fields
 207    of the current DIE, which are specifically unordered within the DIE,
 208    each DIE is scanned and an instance of the "struct dieinfo"
 209    structure is initialized.
 210
 211    Initialization is done in two levels.  The first, done by basicdieinfo(),
 212    just initializes those fields that are vital to deciding whether or not
 213    to use this DIE, how to skip past it, etc.  The second, done by the
 214    function completedieinfo(), fills in the rest of the information.
 215
 216    Attributes which have block forms are not interpreted at the time
 217    the DIE is scanned, instead we just save pointers to the start
 218    of their value fields.
 219
 220    Some fields have a flag <name>_p that is set when the value of the
 221    field is valid (I.E. we found a matching attribute in the DIE).  Since
 222    we may want to test for the presence of some attributes in the DIE,
 223    such as AT_low_pc, without restricting the values of the field,
 224    we need someway to note that we found such an attribute.
 225
 226  */
 227
 228 typedef char BLOCK;
 229
 230 struct dieinfo
 231   {
 232     char *die;                  /* Pointer to the raw DIE data */
 233     unsigned long die_length;   /* Length of the raw DIE data */
 234     DIE_REF die_ref;            /* Offset of this DIE */
 235     unsigned short die_tag;     /* Tag for this DIE */
 236     unsigned long at_padding;
 237     unsigned long at_sibling;
 238     BLOCK *at_location;
 239     char *at_name;
 240     unsigned short at_fund_type;
 241     BLOCK *at_mod_fund_type;
 242     unsigned long at_user_def_type;
 243     BLOCK *at_mod_u_d_type;
 244     unsigned short at_ordering;
 245     BLOCK *at_subscr_data;
 246     unsigned long at_byte_size;
 247     unsigned short at_bit_offset;
 248     unsigned long at_bit_size;
 249     BLOCK *at_element_list;
 250     unsigned long at_stmt_list;
 251     CORE_ADDR at_low_pc;
 252     CORE_ADDR at_high_pc;
 253     unsigned long at_language;
 254     unsigned long at_member;
 255     unsigned long at_discr;
 256     BLOCK *at_discr_value;
 257     BLOCK *at_string_length;
 258     char *at_comp_dir;
 259     char *at_producer;
 260     unsigned long at_start_scope;
 261     unsigned long at_stride_size;
 262     unsigned long at_src_info;
 263     char *at_prototyped;
 264     unsigned int has_at_low_pc:1;
 265     unsigned int has_at_stmt_list:1;
 266     unsigned int has_at_byte_size:1;
 267     unsigned int short_element_list:1;
 268
 269     /* Kludge to identify register variables */
 270
 271     unsigned int isreg;
 272
 273     /* Kludge to identify optimized out variables */
 274
 275     unsigned int optimized_out;
 276
 277     /* Kludge to identify basereg references.
 278        Nonzero if we have an offset relative to a basereg.  */
 279
 280     unsigned int offreg;
 281
 282     /* Kludge to identify which base register is it relative to.  */
 283
 284     unsigned int basereg;
 285   };
 286
 287 static int diecount;            /* Approximate count of dies for compilation unit */
 288 static struct dieinfo *curdie;  /* For warnings and such */
 289
 290 static char *dbbase;            /* Base pointer to dwarf info */
 291 static int dbsize;              /* Size of dwarf info in bytes */
 292 static int dbroff;              /* Relative offset from start of .debug section */
 293 static char *lnbase;            /* Base pointer to line section */
 294
 295 /* This value is added to each symbol value.  FIXME:  Generalize to
 296    the section_offsets structure used by dbxread (once this is done,
 297    pass the appropriate section number to end_symtab).  */
 298 static CORE_ADDR baseaddr;      /* Add to each symbol value */
 299
 300 /* The section offsets used in the current psymtab or symtab.  FIXME,
 301    only used to pass one value (baseaddr) at the moment.  */
 302 static struct section_offsets *base_section_offsets;
 303
 304 /* We put a pointer to this structure in the read_symtab_private field
 305    of the psymtab.  */
 306
 307 struct dwfinfo
 308   {
 309     /* Always the absolute file offset to the start of the ".debug"
 310        section for the file containing the DIE's being accessed.  */
 311     file_ptr dbfoff;
 312     /* Relative offset from the start of the ".debug" section to the
 313        first DIE to be accessed.  When building the partial symbol
 314        table, this value will be zero since we are accessing the
 315        entire ".debug" section.  When expanding a partial symbol
 316        table entry, this value will be the offset to the first
 317        DIE for the compilation unit containing the symbol that
 318        triggers the expansion.  */
 319     int dbroff;
 320     /* The size of the chunk of DIE's being examined, in bytes.  */
 321     int dblength;
 322     /* The absolute file offset to the line table fragment.  Ignored
 323        when building partial symbol tables, but used when expanding
 324        them, and contains the absolute file offset to the fragment
 325        of the ".line" section containing the line numbers for the
 326        current compilation unit.  */
 327     file_ptr lnfoff;
 328   };
 329
 330 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
 331 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
 332 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
 333 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
 334
 335 /* The generic symbol table building routines have separate lists for
 336    file scope symbols and all all other scopes (local scopes).  So
 337    we need to select the right one to pass to add_symbol_to_list().
 338    We do it by keeping a pointer to the correct list in list_in_scope.
 339
 340    FIXME:  The original dwarf code just treated the file scope as the first
 341    local scope, and all other local scopes as nested local scopes, and worked
 342    fine.  Check to see if we really need to distinguish these in buildsym.c */
 343
 344 struct pending **list_in_scope = &file_symbols;
 345
 346 /* DIES which have user defined types or modified user defined types refer to
 347    other DIES for the type information.  Thus we need to associate the offset
 348    of a DIE for a user defined type with a pointer to the type information.
 349
 350    Originally this was done using a simple but expensive algorithm, with an
 351    array of unsorted structures, each containing an offset/type-pointer pair.
 352    This array was scanned linearly each time a lookup was done.  The result
 353    was that gdb was spending over half it's startup time munging through this
 354    array of pointers looking for a structure that had the right offset member.
 355
 356    The second attempt used the same array of structures, but the array was
 357    sorted using qsort each time a new offset/type was recorded, and a binary
 358    search was used to find the type pointer for a given DIE offset.  This was
 359    even slower, due to the overhead of sorting the array each time a new
 360    offset/type pair was entered.
 361
 362    The third attempt uses a fixed size array of type pointers, indexed by a
 363    value derived from the DIE offset.  Since the minimum DIE size is 4 bytes,
 364    we can divide any DIE offset by 4 to obtain a unique index into this fixed
 365    size array.  Since each element is a 4 byte pointer, it takes exactly as
 366    much memory to hold this array as to hold the DWARF info for a given
 367    compilation unit.  But it gets freed as soon as we are done with it.
 368    This has worked well in practice, as a reasonable tradeoff between memory
 369    consumption and speed, without having to resort to much more complicated
 370    algorithms. */
 371
 372 static struct type **utypes;    /* Pointer to array of user type pointers */
 373 static int numutypes;           /* Max number of user type pointers */
 374
 375 /* Maintain an array of referenced fundamental types for the current
 376    compilation unit being read.  For DWARF version 1, we have to construct
 377    the fundamental types on the fly, since no information about the
 378    fundamental types is supplied.  Each such fundamental type is created by
 379    calling a language dependent routine to create the type, and then a
 380    pointer to that type is then placed in the array at the index specified
 381    by it's FT_<TYPENAME> value.  The array has a fixed size set by the
 382    FT_NUM_MEMBERS compile time constant, which is the number of predefined
 383    fundamental types gdb knows how to construct. */
 384
 385 static struct type *ftypes[FT_NUM_MEMBERS];     /* Fundamental types */
 386
 387 /* Record the language for the compilation unit which is currently being
 388    processed.  We know it once we have seen the TAG_compile_unit DIE,
 389    and we need it while processing the DIE's for that compilation unit.
 390    It is eventually saved in the symtab structure, but we don't finalize
 391    the symtab struct until we have processed all the DIE's for the
 392    compilation unit.  We also need to get and save a pointer to the
 393    language struct for this language, so we can call the language
 394    dependent routines for doing things such as creating fundamental
 395    types. */
 396
 397 static enum language cu_language;
 398 static const struct language_defn *cu_language_defn;
 399
 400 /* Forward declarations of static functions so we don't have to worry
 401    about ordering within this file.  */
 402
 403 static void free_utypes (void *);
 404
 405 static int attribute_size (unsigned int);
 406
 407 static CORE_ADDR target_to_host (char *, int, int, struct objfile *);
 408
 409 static void add_enum_psymbol (struct dieinfo *, struct objfile *);
 410
 411 static void handle_producer (char *);
 412
 413 static void read_file_scope (struct dieinfo *, char *, char *,
 414                              struct objfile *);
 415
 416 static void read_func_scope (struct dieinfo *, char *, char *,
 417                              struct objfile *);
 418
 419 static void read_lexical_block_scope (struct dieinfo *, char *, char *,
 420                                       struct objfile *);
 421
 422 static void scan_partial_symbols (char *, char *, struct objfile *);
 423
 424 static void scan_compilation_units (char *, char *, file_ptr, file_ptr,
 425                                     struct objfile *);
 426
 427 static void add_partial_symbol (struct dieinfo *, struct objfile *);
 428
 429 static void basicdieinfo (struct dieinfo *, char *, struct objfile *);
 430
 431 static void completedieinfo (struct dieinfo *, struct objfile *);
 432
 433 static void dwarf_psymtab_to_symtab (struct partial_symtab *);
 434
 435 static void psymtab_to_symtab_1 (struct partial_symtab *);
 436
 437 static void read_ofile_symtab (struct partial_symtab *);
 438
 439 static void process_dies (char *, char *, struct objfile *);
 440
 441 static void read_structure_scope (struct dieinfo *, char *, char *,
 442                                   struct objfile *);
 443
 444 static struct type *decode_array_element_type (char *);
 445
 446 static struct type *decode_subscript_data_item (char *, char *);
 447
 448 static void dwarf_read_array_type (struct dieinfo *);
 449
 450 static void read_tag_pointer_type (struct dieinfo *dip);
 451
 452 static void read_tag_string_type (struct dieinfo *dip);
 453
 454 static void read_subroutine_type (struct dieinfo *, char *, char *);
 455
 456 static void read_enumeration (struct dieinfo *, char *, char *,
 457                               struct objfile *);
 458
 459 static struct type *struct_type (struct dieinfo *, char *, char *,
 460                                  struct objfile *);
 461
 462 static struct type *enum_type (struct dieinfo *, struct objfile *);
 463
 464 static void decode_line_numbers (char *);
 465
 466 static struct type *decode_die_type (struct dieinfo *);
 467
 468 static struct type *decode_mod_fund_type (char *);
 469
 470 static struct type *decode_mod_u_d_type (char *);
 471
 472 static struct type *decode_modified_type (char *, unsigned int, int);
 473
 474 static struct type *decode_fund_type (unsigned int);
 475
 476 static char *create_name (char *, struct obstack *);
 477
 478 static struct type *lookup_utype (DIE_REF);
 479
 480 static struct type *alloc_utype (DIE_REF, struct type *);
 481
 482 static struct symbol *new_symbol (struct dieinfo *, struct objfile *);
 483
 484 static void synthesize_typedef (struct dieinfo *, struct objfile *,
 485                                 struct type *);
 486
 487 static int locval (struct dieinfo *);
 488
 489 static void set_cu_language (struct dieinfo *);
 490
 491 static struct type *dwarf_fundamental_type (struct objfile *, int);
 492
 493
 494 /*
 495
 496    LOCAL FUNCTION
 497
 498    dwarf_fundamental_type -- lookup or create a fundamental type
 499
 500    SYNOPSIS
 501
 502    struct type *
 503    dwarf_fundamental_type (struct objfile *objfile, int typeid)
 504
 505    DESCRIPTION
 506
 507    DWARF version 1 doesn't supply any fundamental type information,
 508    so gdb has to construct such types.  It has a fixed number of
 509    fundamental types that it knows how to construct, which is the
 510    union of all types that it knows how to construct for all languages
 511    that it knows about.  These are enumerated in gdbtypes.h.
 512
 513    As an example, assume we find a DIE that references a DWARF
 514    fundamental type of FT_integer.  We first look in the ftypes
 515    array to see if we already have such a type, indexed by the
 516    gdb internal value of FT_INTEGER.  If so, we simply return a
 517    pointer to that type.  If not, then we ask an appropriate
 518    language dependent routine to create a type FT_INTEGER, using
 519    defaults reasonable for the current target machine, and install
 520    that type in ftypes for future reference.
 521
 522    RETURNS
 523
 524    Pointer to a fundamental type.
 525
 526  */
 527
 528 static struct type *
 529 dwarf_fundamental_type (struct objfile *objfile, int typeid)
 530 {
 531   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
 532     {
 533       error ("internal error - invalid fundamental type id %d", typeid);
 534     }
 535
 536   /* Look for this particular type in the fundamental type vector.  If one is
 537      not found, create and install one appropriate for the current language
 538      and the current target machine. */
 539
 540   if (ftypes[typeid] == NULL)
 541     {
 542       ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);
 543     }
 544
 545   return (ftypes[typeid]);
 546 }
 547
 548 /*
 549
 550    LOCAL FUNCTION
 551
 552    set_cu_language -- set local copy of language for compilation unit
 553
 554    SYNOPSIS
 555
 556    void
 557    set_cu_language (struct dieinfo *dip)
 558
 559    DESCRIPTION
 560
 561    Decode the language attribute for a compilation unit DIE and
 562    remember what the language was.  We use this at various times
 563    when processing DIE's for a given compilation unit.
 564
 565    RETURNS
 566
 567    No return value.
 568
 569  */
 570
 571 static void
 572 set_cu_language (struct dieinfo *dip)
 573 {
 574   switch (dip->at_language)
 575     {
 576     case LANG_C89:
 577     case LANG_C:
 578       cu_language = language_c;
 579       break;
 580     case LANG_C_PLUS_PLUS:
 581       cu_language = language_cplus;
 582       break;
 583     case LANG_MODULA2:
 584       cu_language = language_m2;
 585       break;
 586     case LANG_FORTRAN77:
 587     case LANG_FORTRAN90:
 588       cu_language = language_fortran;
 589       break;
 590     case LANG_ADA83:
 591     case LANG_COBOL74:
 592     case LANG_COBOL85:
 593     case LANG_PASCAL83:
 594       /* We don't know anything special about these yet. */
 595       cu_language = language_unknown;
 596       break;
 597     default:
 598       /* If no at_language, try to deduce one from the filename */
 599       cu_language = deduce_language_from_filename (dip->at_name);
 600       break;
 601     }
 602   cu_language_defn = language_def (cu_language);
 603 }
 604
 605 /*
 606
 607    GLOBAL FUNCTION
 608
 609    dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
 610
 611    SYNOPSIS
 612
 613    void dwarf_build_psymtabs (struct objfile *objfile,
 614    int mainline, file_ptr dbfoff, unsigned int dbfsize,
 615    file_ptr lnoffset, unsigned int lnsize)
 616
 617    DESCRIPTION
 618
 619    This function is called upon to build partial symtabs from files
 620    containing DIE's (Dwarf Information Entries) and DWARF line numbers.
 621
 622    It is passed a bfd* containing the DIES
 623    and line number information, the corresponding filename for that
 624    file, a base address for relocating the symbols, a flag indicating
 625    whether or not this debugging information is from a "main symbol
 626    table" rather than a shared library or dynamically linked file,
 627    and file offset/size pairs for the DIE information and line number
 628    information.
 629
 630    RETURNS
 631
 632    No return value.
 633
 634  */
 635
 636 void
 637 dwarf_build_psymtabs (struct objfile *objfile, int mainline, file_ptr dbfoff,
 638                       unsigned int dbfsize, file_ptr lnoffset,
 639                       unsigned int lnsize)
 640 {
 641   bfd *abfd = objfile->obfd;
 642   struct cleanup *back_to;
 643
 644   current_objfile = objfile;
 645   dbsize = dbfsize;
 646   dbbase = xmalloc (dbsize);
 647   dbroff = 0;
 648   if ((bfd_seek (abfd, dbfoff, SEEK_SET) != 0) ||
 649       (bfd_bread (dbbase, dbsize, abfd) != dbsize))
 650     {
 651       xfree (dbbase);
 652       error ("can't read DWARF data from '%s'", bfd_get_filename (abfd));
 653     }
 654   back_to = make_cleanup (xfree, dbbase);
 655
 656   /* If we are reinitializing, or if we have never loaded syms yet, init.
 657      Since we have no idea how many DIES we are looking at, we just guess
 658      some arbitrary value. */
 659
 660   if (mainline
 661       || (objfile->global_psymbols.size == 0
 662           && objfile->static_psymbols.size == 0))
 663     {
 664       init_psymbol_list (objfile, 1024);
 665     }
 666
 667   /* Save the relocation factor where everybody can see it.  */
 668
 669   base_section_offsets = objfile->section_offsets;
 670   baseaddr = ANOFFSET (objfile->section_offsets, 0);
 671
 672   /* Follow the compilation unit sibling chain, building a partial symbol
 673      table entry for each one.  Save enough information about each compilation
 674      unit to locate the full DWARF information later. */
 675
 676   scan_compilation_units (dbbase, dbbase + dbsize, dbfoff, lnoffset, objfile);
 677
 678   do_cleanups (back_to);
 679   current_objfile = NULL;
 680 }
 681
 682 /*
 683
 684    LOCAL FUNCTION
 685
 686    read_lexical_block_scope -- process all dies in a lexical block
 687
 688    SYNOPSIS
 689
 690    static void read_lexical_block_scope (struct dieinfo *dip,
 691    char *thisdie, char *enddie)
 692
 693    DESCRIPTION
 694
 695    Process all the DIES contained within a lexical block scope.
 696    Start a new scope, process the dies, and then close the scope.
 697
 698  */
 699
 700 static void
 701 read_lexical_block_scope (struct dieinfo *dip, char *thisdie, char *enddie,
 702                           struct objfile *objfile)
 703 {
 704   struct context_stack *new;
 705
 706   push_context (0, dip->at_low_pc);
 707   process_dies (thisdie + dip->die_length, enddie, objfile);
 708   new = pop_context ();
 709   if (local_symbols != NULL)
 710     {
 711       finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
 712                     dip->at_high_pc, objfile);
 713     }
 714   local_symbols = new->locals;
 715 }
 716
 717 /*
 718
 719    LOCAL FUNCTION
 720
 721    lookup_utype -- look up a user defined type from die reference
 722
 723    SYNOPSIS
 724
 725    static type *lookup_utype (DIE_REF die_ref)
 726
 727    DESCRIPTION
 728
 729    Given a DIE reference, lookup the user defined type associated with
 730    that DIE, if it has been registered already.  If not registered, then
 731    return NULL.  Alloc_utype() can be called to register an empty
 732    type for this reference, which will be filled in later when the
 733    actual referenced DIE is processed.
 734  */
 735
 736 static struct type *
 737 lookup_utype (DIE_REF die_ref)
 738 {
 739   struct type *type = NULL;
 740   int utypeidx;
 741
 742   utypeidx = (die_ref - dbroff) / 4;
 743   if ((utypeidx < 0) || (utypeidx >= numutypes))
 744     {
 745       bad_die_ref_complaint (DIE_ID, DIE_NAME, die_ref);
 746     }
 747   else
 748     {
 749       type = *(utypes + utypeidx);
 750     }
 751   return (type);
 752 }
 753
 754
 755 /*
 756
 757    LOCAL FUNCTION
 758
 759    alloc_utype  -- add a user defined type for die reference
 760
 761    SYNOPSIS
 762
 763    static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
 764
 765    DESCRIPTION
 766
 767    Given a die reference DIE_REF, and a possible pointer to a user
 768    defined type UTYPEP, register that this reference has a user
 769    defined type and either use the specified type in UTYPEP or
 770    make a new empty type that will be filled in later.
 771
 772    We should only be called after calling lookup_utype() to verify that
 773    there is not currently a type registered for DIE_REF.
 774  */
 775
 776 static struct type *
 777 alloc_utype (DIE_REF die_ref, struct type *utypep)
 778 {
 779   struct type **typep;
 780   int utypeidx;
 781
 782   utypeidx = (die_ref - dbroff) / 4;
 783   typep = utypes + utypeidx;
 784   if ((utypeidx < 0) || (utypeidx >= numutypes))
 785     {
 786       utypep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
 787       bad_die_ref_complaint (DIE_ID, DIE_NAME, die_ref);
 788     }
 789   else if (*typep != NULL)
 790     {
 791       utypep = *typep;
 792       complaint (&symfile_complaints,
 793                  "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation",
 794                  DIE_ID, DIE_NAME);
 795     }
 796   else
 797     {
 798       if (utypep == NULL)
 799         {
 800           utypep = alloc_type (current_objfile);
 801         }
 802       *typep = utypep;
 803     }
 804   return (utypep);
 805 }
 806
 807 /*
 808
 809    LOCAL FUNCTION
 810
 811    free_utypes -- free the utypes array and reset pointer & count
 812
 813    SYNOPSIS
 814
 815    static void free_utypes (void *dummy)
 816
 817    DESCRIPTION
 818
 819    Called via do_cleanups to free the utypes array, reset the pointer to NULL,
 820    and set numutypes back to zero.  This ensures that the utypes does not get
 821    referenced after being freed.
 822  */
 823
 824 static void
 825 free_utypes (void *dummy)
 826 {
 827   xfree (utypes);
 828   utypes = NULL;
 829   numutypes = 0;
 830 }
 831
 832
 833 /*
 834
 835    LOCAL FUNCTION
 836
 837    decode_die_type -- return a type for a specified die
 838
 839    SYNOPSIS
 840
 841    static struct type *decode_die_type (struct dieinfo *dip)
 842
 843    DESCRIPTION
 844
 845    Given a pointer to a die information structure DIP, decode the
 846    type of the die and return a pointer to the decoded type.  All
 847    dies without specific types default to type int.
 848  */
 849
 850 static struct type *
 851 decode_die_type (struct dieinfo *dip)
 852 {
 853   struct type *type = NULL;
 854
 855   if (dip->at_fund_type != 0)
 856     {
 857       type = decode_fund_type (dip->at_fund_type);
 858     }
 859   else if (dip->at_mod_fund_type != NULL)
 860     {
 861       type = decode_mod_fund_type (dip->at_mod_fund_type);
 862     }
 863   else if (dip->at_user_def_type)
 864     {
 865       type = lookup_utype (dip->at_user_def_type);
 866       if (type == NULL)
 867         {
 868           type = alloc_utype (dip->at_user_def_type, NULL);
 869         }
 870     }
 871   else if (dip->at_mod_u_d_type)
 872     {
 873       type = decode_mod_u_d_type (dip->at_mod_u_d_type);
 874     }
 875   else
 876     {
 877       type = dwarf_fundamental_type (current_objfile, FT_VOID);
 878     }
 879   return (type);
 880 }
 881
 882 /*
 883
 884    LOCAL FUNCTION
 885
 886    struct_type -- compute and return the type for a struct or union
 887
 888    SYNOPSIS
 889
 890    static struct type *struct_type (struct dieinfo *dip, char *thisdie,
 891    char *enddie, struct objfile *objfile)
 892
 893    DESCRIPTION
 894
 895    Given pointer to a die information structure for a die which
 896    defines a union or structure (and MUST define one or the other),
 897    and pointers to the raw die data that define the range of dies which
 898    define the members, compute and return the user defined type for the
 899    structure or union.
 900  */
 901
 902 static struct type *
 903 struct_type (struct dieinfo *dip, char *thisdie, char *enddie,
 904              struct objfile *objfile)
 905 {
 906   struct type *type;
 907   struct nextfield
 908     {
 909       struct nextfield *next;
 910       struct field field;
 911     };
 912   struct nextfield *list = NULL;
 913   struct nextfield *new;
 914   int nfields = 0;
 915   int n;
 916   struct dieinfo mbr;
 917   char *nextdie;
 918   int anonymous_size;
 919
 920   type = lookup_utype (dip->die_ref);
 921   if (type == NULL)
 922     {
 923       /* No forward references created an empty type, so install one now */
 924       type = alloc_utype (dip->die_ref, NULL);
 925     }
 926   INIT_CPLUS_SPECIFIC (type);
 927   switch (dip->die_tag)
 928     {
 929     case TAG_class_type:
 930       TYPE_CODE (type) = TYPE_CODE_CLASS;
 931       break;
 932     case TAG_structure_type:
 933       TYPE_CODE (type) = TYPE_CODE_STRUCT;
 934       break;
 935     case TAG_union_type:
 936       TYPE_CODE (type) = TYPE_CODE_UNION;
 937       break;
 938     default:
 939       /* Should never happen */
 940       TYPE_CODE (type) = TYPE_CODE_UNDEF;
 941       complaint (&symfile_complaints,
 942                  "DIE @ 0x%x \"%s\", missing class, structure, or union tag",
 943                  DIE_ID, DIE_NAME);
 944       break;
 945     }
 946   /* Some compilers try to be helpful by inventing "fake" names for
 947      anonymous enums, structures, and unions, like "~0fake" or ".0fake".
 948      Thanks, but no thanks... */
 949   if (dip->at_name != NULL
 950       && *dip->at_name != '~'
 951       && *dip->at_name != '.')
 952     {
 953       TYPE_TAG_NAME (type) = obconcat (&objfile->type_obstack,
 954                                        "", "", dip->at_name);
 955     }
 956   /* Use whatever size is known.  Zero is a valid size.  We might however
 957      wish to check has_at_byte_size to make sure that some byte size was
 958      given explicitly, but DWARF doesn't specify that explicit sizes of
 959      zero have to present, so complaining about missing sizes should
 960      probably not be the default. */
 961   TYPE_LENGTH (type) = dip->at_byte_size;
 962   thisdie += dip->die_length;
 963   while (thisdie < enddie)
 964     {
 965       basicdieinfo (&mbr, thisdie, objfile);
 966       completedieinfo (&mbr, objfile);
 967       if (mbr.die_length <= SIZEOF_DIE_LENGTH)
 968         {
 969           break;
 970         }
 971       else if (mbr.at_sibling != 0)
 972         {
 973           nextdie = dbbase + mbr.at_sibling - dbroff;
 974         }
 975       else
 976         {
 977           nextdie = thisdie + mbr.die_length;
 978         }
 979       switch (mbr.die_tag)
 980         {
 981         case TAG_member:
 982           /* Static fields can be either TAG_global_variable (GCC) or else
 983              TAG_member with no location (Diab).  We could treat the latter like
 984              the former... but since we don't support the former, just avoid
 985              crashing on the latter for now.  */
 986           if (mbr.at_location == NULL)
 987             break;
 988
 989           /* Get space to record the next field's data.  */
 990           new = (struct nextfield *) alloca (sizeof (struct nextfield));
 991           new->next = list;
 992           list = new;
 993           /* Save the data.  */
 994           list->field.name =
 995             obsavestring (mbr.at_name, strlen (mbr.at_name),
 996                           &objfile->type_obstack);
 997           FIELD_TYPE (list->field) = decode_die_type (&mbr);
 998           FIELD_BITPOS (list->field) = 8 * locval (&mbr);
 999           FIELD_STATIC_KIND (list->field) = 0;
1000           /* Handle bit fields. */
1001           FIELD_BITSIZE (list->field) = mbr.at_bit_size;
1002           if (BITS_BIG_ENDIAN)
1003             {
1004               /* For big endian bits, the at_bit_offset gives the
1005                  additional bit offset from the MSB of the containing
1006                  anonymous object to the MSB of the field.  We don't
1007                  have to do anything special since we don't need to
1008                  know the size of the anonymous object. */
1009               FIELD_BITPOS (list->field) += mbr.at_bit_offset;
1010             }
1011           else
1012             {
1013               /* For little endian bits, we need to have a non-zero
1014                  at_bit_size, so that we know we are in fact dealing
1015                  with a bitfield.  Compute the bit offset to the MSB
1016                  of the anonymous object, subtract off the number of
1017                  bits from the MSB of the field to the MSB of the
1018                  object, and then subtract off the number of bits of
1019                  the field itself.  The result is the bit offset of
1020                  the LSB of the field. */
1021               if (mbr.at_bit_size > 0)
1022                 {
1023                   if (mbr.has_at_byte_size)
1024                     {
1025                       /* The size of the anonymous object containing
1026                          the bit field is explicit, so use the
1027                          indicated size (in bytes). */
1028                       anonymous_size = mbr.at_byte_size;
1029                     }
1030                   else
1031                     {
1032                       /* The size of the anonymous object containing
1033                          the bit field matches the size of an object
1034                          of the bit field's type.  DWARF allows
1035                          at_byte_size to be left out in such cases, as
1036                          a debug information size optimization. */
1037                       anonymous_size = TYPE_LENGTH (list->field.type);
1038                     }
1039                   FIELD_BITPOS (list->field) +=
1040                     anonymous_size * 8 - mbr.at_bit_offset - mbr.at_bit_size;
1041                 }
1042             }
1043           nfields++;
1044           break;
1045         default:
1046           process_dies (thisdie, nextdie, objfile);
1047           break;
1048         }
1049       thisdie = nextdie;
1050     }
1051   /* Now create the vector of fields, and record how big it is.  We may
1052      not even have any fields, if this DIE was generated due to a reference
1053      to an anonymous structure or union.  In this case, TYPE_FLAG_STUB is
1054      set, which clues gdb in to the fact that it needs to search elsewhere
1055      for the full structure definition. */
1056   if (nfields == 0)
1057     {
1058       TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
1059     }
1060   else
1061     {
1062       TYPE_NFIELDS (type) = nfields;
1063       TYPE_FIELDS (type) = (struct field *)
1064         TYPE_ALLOC (type, sizeof (struct field) * nfields);
1065       /* Copy the saved-up fields into the field vector.  */
1066       for (n = nfields; list; list = list->next)
1067         {
1068           TYPE_FIELD (type, --n) = list->field;
1069         }
1070     }
1071   return (type);
1072 }
1073
1074 /*
1075
1076    LOCAL FUNCTION
1077
1078    read_structure_scope -- process all dies within struct or union
1079
1080    SYNOPSIS
1081
1082    static void read_structure_scope (struct dieinfo *dip,
1083    char *thisdie, char *enddie, struct objfile *objfile)
1084
1085    DESCRIPTION
1086
1087    Called when we find the DIE that starts a structure or union
1088    scope (definition) to process all dies that define the members
1089    of the structure or union.  DIP is a pointer to the die info
1090    struct for the DIE that names the structure or union.
1091
1092    NOTES
1093
1094    Note that we need to call struct_type regardless of whether or not
1095    the DIE has an at_name attribute, since it might be an anonymous
1096    structure or union.  This gets the type entered into our set of
1097    user defined types.
1098
1099    However, if the structure is incomplete (an opaque struct/union)
1100    then suppress creating a symbol table entry for it since gdb only
1101    wants to find the one with the complete definition.  Note that if
1102    it is complete, we just call new_symbol, which does it's own
1103    checking about whether the struct/union is anonymous or not (and
1104    suppresses creating a symbol table entry itself).
1105
1106  */
1107
1108 static void
1109 read_structure_scope (struct dieinfo *dip, char *thisdie, char *enddie,
1110                       struct objfile *objfile)
1111 {
1112   struct type *type;
1113   struct symbol *sym;
1114
1115   type = struct_type (dip, thisdie, enddie, objfile);
1116   if (!TYPE_STUB (type))
1117     {
1118       sym = new_symbol (dip, objfile);
1119       if (sym != NULL)
1120         {
1121           SYMBOL_TYPE (sym) = type;
1122           if (cu_language == language_cplus)
1123             {
1124               synthesize_typedef (dip, objfile, type);
1125             }
1126         }
1127     }
1128 }
1129
1130 /*
1131
1132    LOCAL FUNCTION
1133
1134    decode_array_element_type -- decode type of the array elements
1135
1136    SYNOPSIS
1137
1138    static struct type *decode_array_element_type (char *scan, char *end)
1139
1140    DESCRIPTION
1141
1142    As the last step in decoding the array subscript information for an
1143    array DIE, we need to decode the type of the array elements.  We are
1144    passed a pointer to this last part of the subscript information and
1145    must return the appropriate type.  If the type attribute is not
1146    recognized, just warn about the problem and return type int.
1147  */
1148
1149 static struct type *
1150 decode_array_element_type (char *scan)
1151 {
1152   struct type *typep;
1153   DIE_REF die_ref;
1154   unsigned short attribute;
1155   unsigned short fundtype;
1156   int nbytes;
1157
1158   attribute = target_to_host (scan, SIZEOF_ATTRIBUTE, GET_UNSIGNED,
1159                               current_objfile);
1160   scan += SIZEOF_ATTRIBUTE;
1161   nbytes = attribute_size (attribute);
1162   if (nbytes == -1)
1163     {
1164       bad_array_element_type_complaint (DIE_ID, DIE_NAME, attribute);
1165       typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1166     }
1167   else
1168     {
1169       switch (attribute)
1170         {
1171         case AT_fund_type:
1172           fundtype = target_to_host (scan, nbytes, GET_UNSIGNED,
1173                                      current_objfile);
1174           typep = decode_fund_type (fundtype);
1175           break;
1176         case AT_mod_fund_type:
1177           typep = decode_mod_fund_type (scan);
1178           break;
1179         case AT_user_def_type:
1180           die_ref = target_to_host (scan, nbytes, GET_UNSIGNED,
1181                                     current_objfile);
1182           typep = lookup_utype (die_ref);
1183           if (typep == NULL)
1184             {
1185               typep = alloc_utype (die_ref, NULL);
1186             }
1187           break;
1188         case AT_mod_u_d_type:
1189           typep = decode_mod_u_d_type (scan);
1190           break;
1191         default:
1192           bad_array_element_type_complaint (DIE_ID, DIE_NAME, attribute);
1193           typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1194           break;
1195         }
1196     }
1197   return (typep);
1198 }
1199
1200 /*
1201
1202    LOCAL FUNCTION
1203
1204    decode_subscript_data_item -- decode array subscript item
1205
1206    SYNOPSIS
1207
1208    static struct type *
1209    decode_subscript_data_item (char *scan, char *end)
1210
1211    DESCRIPTION
1212
1213    The array subscripts and the data type of the elements of an
1214    array are described by a list of data items, stored as a block
1215    of contiguous bytes.  There is a data item describing each array
1216    dimension, and a final data item describing the element type.
1217    The data items are ordered the same as their appearance in the
1218    source (I.E. leftmost dimension first, next to leftmost second,
1219    etc).
1220
1221    The data items describing each array dimension consist of four
1222    parts: (1) a format specifier, (2) type type of the subscript
1223    index, (3) a description of the low bound of the array dimension,
1224    and (4) a description of the high bound of the array dimension.
1225
1226    The last data item is the description of the type of each of
1227    the array elements.
1228
1229    We are passed a pointer to the start of the block of bytes
1230    containing the remaining data items, and a pointer to the first
1231    byte past the data.  This function recursively decodes the
1232    remaining data items and returns a type.
1233
1234    If we somehow fail to decode some data, we complain about it
1235    and return a type "array of int".
1236
1237    BUGS
1238    FIXME:  This code only implements the forms currently used
1239    by the AT&T and GNU C compilers.
1240
1241    The end pointer is supplied for error checking, maybe we should
1242    use it for that...
1243  */
1244
1245 static struct type *
1246 decode_subscript_data_item (char *scan, char *end)
1247 {
1248   struct type *typep = NULL;    /* Array type we are building */
1249   struct type *nexttype;        /* Type of each element (may be array) */
1250   struct type *indextype;       /* Type of this index */
1251   struct type *rangetype;
1252   unsigned int format;
1253   unsigned short fundtype;
1254   unsigned long lowbound;
1255   unsigned long highbound;
1256   int nbytes;
1257
1258   format = target_to_host (scan, SIZEOF_FORMAT_SPECIFIER, GET_UNSIGNED,
1259                            current_objfile);
1260   scan += SIZEOF_FORMAT_SPECIFIER;
1261   switch (format)
1262     {
1263     case FMT_ET:
1264       typep = decode_array_element_type (scan);
1265       break;
1266     case FMT_FT_C_C:
1267       fundtype = target_to_host (scan, SIZEOF_FMT_FT, GET_UNSIGNED,
1268                                  current_objfile);
1269       indextype = decode_fund_type (fundtype);
1270       scan += SIZEOF_FMT_FT;
1271       nbytes = TARGET_FT_LONG_SIZE (current_objfile);
1272       lowbound = target_to_host (scan, nbytes, GET_UNSIGNED, current_objfile);
1273       scan += nbytes;
1274       highbound = target_to_host (scan, nbytes, GET_UNSIGNED, current_objfile);
1275       scan += nbytes;
1276       nexttype = decode_subscript_data_item (scan, end);
1277       if (nexttype == NULL)
1278         {
1279           /* Munged subscript data or other problem, fake it. */
1280           complaint (&symfile_complaints,
1281                      "DIE @ 0x%x \"%s\", can't decode subscript data items",
1282                      DIE_ID, DIE_NAME);
1283           nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1284         }
1285       rangetype = create_range_type ((struct type *) NULL, indextype,
1286                                      lowbound, highbound);
1287       typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1288       break;
1289     case FMT_FT_C_X:
1290     case FMT_FT_X_C:
1291     case FMT_FT_X_X:
1292     case FMT_UT_C_C:
1293     case FMT_UT_C_X:
1294     case FMT_UT_X_C:
1295     case FMT_UT_X_X:
1296       complaint (&symfile_complaints,
1297                  "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet",
1298                  DIE_ID, DIE_NAME, format);
1299       nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1300       rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
1301       typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1302       break;
1303     default:
1304       complaint (&symfile_complaints,
1305                  "DIE @ 0x%x \"%s\", unknown array subscript format %x", DIE_ID,
1306                  DIE_NAME, format);
1307       nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1308       rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
1309       typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1310       break;
1311     }
1312   return (typep);
1313 }
1314
1315 /*
1316
1317    LOCAL FUNCTION
1318
1319    dwarf_read_array_type -- read TAG_array_type DIE
1320
1321    SYNOPSIS
1322
1323    static void dwarf_read_array_type (struct dieinfo *dip)
1324
1325    DESCRIPTION
1326
1327    Extract all information from a TAG_array_type DIE and add to
1328    the user defined type vector.
1329  */
1330
1331 static void
1332 dwarf_read_array_type (struct dieinfo *dip)
1333 {
1334   struct type *type;
1335   struct type *utype;
1336   char *sub;
1337   char *subend;
1338   unsigned short blocksz;
1339   int nbytes;
1340
1341   if (dip->at_ordering != ORD_row_major)
1342     {
1343       /* FIXME:  Can gdb even handle column major arrays? */
1344       complaint (&symfile_complaints,
1345                  "DIE @ 0x%x \"%s\", array not row major; not handled correctly",
1346                  DIE_ID, DIE_NAME);
1347     }
1348   sub = dip->at_subscr_data;
1349   if (sub != NULL)
1350     {
1351       nbytes = attribute_size (AT_subscr_data);
1352       blocksz = target_to_host (sub, nbytes, GET_UNSIGNED, current_objfile);
1353       subend = sub + nbytes + blocksz;
1354       sub += nbytes;
1355       type = decode_subscript_data_item (sub, subend);
1356       utype = lookup_utype (dip->die_ref);
1357       if (utype == NULL)
1358         {
1359           /* Install user defined type that has not been referenced yet. */
1360           alloc_utype (dip->die_ref, type);
1361         }
1362       else if (TYPE_CODE (utype) == TYPE_CODE_UNDEF)
1363         {
1364           /* Ick!  A forward ref has already generated a blank type in our
1365              slot, and this type probably already has things pointing to it
1366              (which is what caused it to be created in the first place).
1367              If it's just a place holder we can plop our fully defined type
1368              on top of it.  We can't recover the space allocated for our
1369              new type since it might be on an obstack, but we could reuse
1370              it if we kept a list of them, but it might not be worth it
1371              (FIXME). */
1372           *utype = *type;
1373         }
1374       else
1375         {
1376           /* Double ick!  Not only is a type already in our slot, but
1377              someone has decorated it.  Complain and leave it alone. */
1378           dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
1379         }
1380     }
1381 }
1382
1383 /*
1384
1385    LOCAL FUNCTION
1386
1387    read_tag_pointer_type -- read TAG_pointer_type DIE
1388
1389    SYNOPSIS
1390
1391    static void read_tag_pointer_type (struct dieinfo *dip)
1392
1393    DESCRIPTION
1394
1395    Extract all information from a TAG_pointer_type DIE and add to
1396    the user defined type vector.
1397  */
1398
1399 static void
1400 read_tag_pointer_type (struct dieinfo *dip)
1401 {
1402   struct type *type;
1403   struct type *utype;
1404
1405   type = decode_die_type (dip);
1406   utype = lookup_utype (dip->die_ref);
1407   if (utype == NULL)
1408     {
1409       utype = lookup_pointer_type (type);
1410       alloc_utype (dip->die_ref, utype);
1411     }
1412   else
1413     {
1414       TYPE_TARGET_TYPE (utype) = type;
1415       TYPE_POINTER_TYPE (type) = utype;
1416
1417       /* We assume the machine has only one representation for pointers!  */
1418       /* FIXME:  Possably a poor assumption  */
1419       TYPE_LENGTH (utype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
1420       TYPE_CODE (utype) = TYPE_CODE_PTR;
1421     }
1422 }
1423
1424 /*
1425
1426    LOCAL FUNCTION
1427
1428    read_tag_string_type -- read TAG_string_type DIE
1429
1430    SYNOPSIS
1431
1432    static void read_tag_string_type (struct dieinfo *dip)
1433
1434    DESCRIPTION
1435
1436    Extract all information from a TAG_string_type DIE and add to
1437    the user defined type vector.  It isn't really a user defined
1438    type, but it behaves like one, with other DIE's using an
1439    AT_user_def_type attribute to reference it.
1440  */
1441
1442 static void
1443 read_tag_string_type (struct dieinfo *dip)
1444 {
1445   struct type *utype;
1446   struct type *indextype;
1447   struct type *rangetype;
1448   unsigned long lowbound = 0;
1449   unsigned long highbound;
1450
1451   if (dip->has_at_byte_size)
1452     {
1453       /* A fixed bounds string */
1454       highbound = dip->at_byte_size - 1;
1455     }
1456   else
1457     {
1458       /* A varying length string.  Stub for now.  (FIXME) */
1459       highbound = 1;
1460     }
1461   indextype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1462   rangetype = create_range_type ((struct type *) NULL, indextype, lowbound,
1463                                  highbound);
1464
1465   utype = lookup_utype (dip->die_ref);
1466   if (utype == NULL)
1467     {
1468       /* No type defined, go ahead and create a blank one to use. */
1469       utype = alloc_utype (dip->die_ref, (struct type *) NULL);
1470     }
1471   else
1472     {
1473       /* Already a type in our slot due to a forward reference. Make sure it
1474          is a blank one.  If not, complain and leave it alone. */
1475       if (TYPE_CODE (utype) != TYPE_CODE_UNDEF)
1476         {
1477           dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
1478           return;
1479         }
1480     }
1481
1482   /* Create the string type using the blank type we either found or created. */
1483   utype = create_string_type (utype, rangetype);
1484 }
1485
1486 /*
1487
1488    LOCAL FUNCTION
1489
1490    read_subroutine_type -- process TAG_subroutine_type dies
1491
1492    SYNOPSIS
1493
1494    static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1495    char *enddie)
1496
1497    DESCRIPTION
1498
1499    Handle DIES due to C code like:
1500
1501    struct foo {
1502    int (*funcp)(int a, long l);  (Generates TAG_subroutine_type DIE)
1503    int b;
1504    };
1505
1506    NOTES
1507
1508    The parameter DIES are currently ignored.  See if gdb has a way to
1509    include this info in it's type system, and decode them if so.  Is
1510    this what the type structure's "arg_types" field is for?  (FIXME)
1511  */
1512
1513 static void
1514 read_subroutine_type (struct dieinfo *dip, char *thisdie, char *enddie)
1515 {
1516   struct type *type;            /* Type that this function returns */
1517   struct type *ftype;           /* Function that returns above type */
1518
1519   /* Decode the type that this subroutine returns */
1520
1521   type = decode_die_type (dip);
1522
1523   /* Check to see if we already have a partially constructed user
1524      defined type for this DIE, from a forward reference. */
1525
1526   ftype = lookup_utype (dip->die_ref);
1527   if (ftype == NULL)
1528     {
1529       /* This is the first reference to one of these types.  Make
1530          a new one and place it in the user defined types. */
1531       ftype = lookup_function_type (type);
1532       alloc_utype (dip->die_ref, ftype);
1533     }
1534   else if (TYPE_CODE (ftype) == TYPE_CODE_UNDEF)
1535     {
1536       /* We have an existing partially constructed type, so bash it
1537          into the correct type. */
1538       TYPE_TARGET_TYPE (ftype) = type;
1539       TYPE_LENGTH (ftype) = 1;
1540       TYPE_CODE (ftype) = TYPE_CODE_FUNC;
1541     }
1542   else
1543     {
1544       dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
1545     }
1546 }
1547
1548 /*
1549
1550    LOCAL FUNCTION
1551
1552    read_enumeration -- process dies which define an enumeration
1553
1554    SYNOPSIS
1555
1556    static void read_enumeration (struct dieinfo *dip, char *thisdie,
1557    char *enddie, struct objfile *objfile)
1558
1559    DESCRIPTION
1560
1561    Given a pointer to a die which begins an enumeration, process all
1562    the dies that define the members of the enumeration.
1563
1564    NOTES
1565
1566    Note that we need to call enum_type regardless of whether or not we
1567    have a symbol, since we might have an enum without a tag name (thus
1568    no symbol for the tagname).
1569  */
1570
1571 static void
1572 read_enumeration (struct dieinfo *dip, char *thisdie, char *enddie,
1573                   struct objfile *objfile)
1574 {
1575   struct type *type;
1576   struct symbol *sym;
1577
1578   type = enum_type (dip, objfile);
1579   sym = new_symbol (dip, objfile);
1580   if (sym != NULL)
1581     {
1582       SYMBOL_TYPE (sym) = type;
1583       if (cu_language == language_cplus)
1584         {
1585           synthesize_typedef (dip, objfile, type);
1586         }
1587     }
1588 }
1589
1590 /*
1591
1592    LOCAL FUNCTION
1593
1594    enum_type -- decode and return a type for an enumeration
1595
1596    SYNOPSIS
1597
1598    static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1599
1600    DESCRIPTION
1601
1602    Given a pointer to a die information structure for the die which
1603    starts an enumeration, process all the dies that define the members
1604    of the enumeration and return a type pointer for the enumeration.
1605
1606    At the same time, for each member of the enumeration, create a
1607    symbol for it with domain VAR_DOMAIN and class LOC_CONST,
1608    and give it the type of the enumeration itself.
1609
1610    NOTES
1611
1612    Note that the DWARF specification explicitly mandates that enum
1613    constants occur in reverse order from the source program order,
1614    for "consistency" and because this ordering is easier for many
1615    compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1616    Entries).  Because gdb wants to see the enum members in program
1617    source order, we have to ensure that the order gets reversed while
1618    we are processing them.
1619  */
1620
1621 static struct type *
1622 enum_type (struct dieinfo *dip, struct objfile *objfile)
1623 {
1624   struct type *type;
1625   struct nextfield
1626     {
1627       struct nextfield *next;
1628       struct field field;
1629     };
1630   struct nextfield *list = NULL;
1631   struct nextfield *new;
1632   int nfields = 0;
1633   int n;
1634   char *scan;
1635   char *listend;
1636   unsigned short blocksz;
1637   struct symbol *sym;
1638   int nbytes;
1639   int unsigned_enum = 1;
1640
1641   type = lookup_utype (dip->die_ref);
1642   if (type == NULL)
1643     {
1644       /* No forward references created an empty type, so install one now */
1645       type = alloc_utype (dip->die_ref, NULL);
1646     }
1647   TYPE_CODE (type) = TYPE_CODE_ENUM;
1648   /* Some compilers try to be helpful by inventing "fake" names for
1649      anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1650      Thanks, but no thanks... */
1651   if (dip->at_name != NULL
1652       && *dip->at_name != '~'
1653       && *dip->at_name != '.')
1654     {
1655       TYPE_TAG_NAME (type) = obconcat (&objfile->type_obstack,
1656                                        "", "", dip->at_name);
1657     }
1658   if (dip->at_byte_size != 0)
1659     {
1660       TYPE_LENGTH (type) = dip->at_byte_size;
1661     }
1662   scan = dip->at_element_list;
1663   if (scan != NULL)
1664     {
1665       if (dip->short_element_list)
1666         {
1667           nbytes = attribute_size (AT_short_element_list);
1668         }
1669       else
1670         {
1671           nbytes = attribute_size (AT_element_list);
1672         }
1673       blocksz = target_to_host (scan, nbytes, GET_UNSIGNED, objfile);
1674       listend = scan + nbytes + blocksz;
1675       scan += nbytes;
1676       while (scan < listend)
1677         {
1678           new = (struct nextfield *) alloca (sizeof (struct nextfield));
1679           new->next = list;
1680           list = new;
1681           FIELD_TYPE (list->field) = NULL;
1682           FIELD_BITSIZE (list->field) = 0;
1683           FIELD_STATIC_KIND (list->field) = 0;
1684           FIELD_BITPOS (list->field) =
1685             target_to_host (scan, TARGET_FT_LONG_SIZE (objfile), GET_SIGNED,
1686                             objfile);
1687           scan += TARGET_FT_LONG_SIZE (objfile);
1688           list->field.name = obsavestring (scan, strlen (scan),
1689                                            &objfile->type_obstack);
1690           scan += strlen (scan) + 1;
1691           nfields++;
1692           /* Handcraft a new symbol for this enum member. */
1693           sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
1694                                                  sizeof (struct symbol));
1695           memset (sym, 0, sizeof (struct symbol));
1696           DEPRECATED_SYMBOL_NAME (sym) = create_name (list->field.name,
1697                                            &objfile->symbol_obstack);
1698           SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
1699           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1700           SYMBOL_CLASS (sym) = LOC_CONST;
1701           SYMBOL_TYPE (sym) = type;
1702           SYMBOL_VALUE (sym) = FIELD_BITPOS (list->field);
1703           if (SYMBOL_VALUE (sym) < 0)
1704             unsigned_enum = 0;
1705           add_symbol_to_list (sym, list_in_scope);
1706         }
1707       /* Now create the vector of fields, and record how big it is. This is
1708          where we reverse the order, by pulling the members off the list in
1709          reverse order from how they were inserted.  If we have no fields
1710          (this is apparently possible in C++) then skip building a field
1711          vector. */
1712       if (nfields > 0)
1713         {
1714           if (unsigned_enum)
1715             TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
1716           TYPE_NFIELDS (type) = nfields;
1717           TYPE_FIELDS (type) = (struct field *)
1718             obstack_alloc (&objfile->symbol_obstack, sizeof (struct field) * nfields);
1719           /* Copy the saved-up fields into the field vector.  */
1720           for (n = 0; (n < nfields) && (list != NULL); list = list->next)
1721             {
1722               TYPE_FIELD (type, n++) = list->field;
1723             }
1724         }
1725     }
1726   return (type);
1727 }
1728
1729 /*
1730
1731    LOCAL FUNCTION
1732
1733    read_func_scope -- process all dies within a function scope
1734
1735    DESCRIPTION
1736
1737    Process all dies within a given function scope.  We are passed
1738    a die information structure pointer DIP for the die which
1739    starts the function scope, and pointers into the raw die data
1740    that define the dies within the function scope.
1741
1742    For now, we ignore lexical block scopes within the function.
1743    The problem is that AT&T cc does not define a DWARF lexical
1744    block scope for the function itself, while gcc defines a
1745    lexical block scope for the function.  We need to think about
1746    how to handle this difference, or if it is even a problem.
1747    (FIXME)
1748  */
1749
1750 static void
1751 read_func_scope (struct dieinfo *dip, char *thisdie, char *enddie,
1752                  struct objfile *objfile)
1753 {
1754   struct context_stack *new;
1755
1756   /* AT_name is absent if the function is described with an
1757      AT_abstract_origin tag.
1758      Ignore the function description for now to avoid GDB core dumps.
1759      FIXME: Add code to handle AT_abstract_origin tags properly.  */
1760   if (dip->at_name == NULL)
1761     {
1762       complaint (&symfile_complaints, "DIE @ 0x%x, AT_name tag missing",
1763                  DIE_ID);
1764       return;
1765     }
1766
1767   if (objfile->ei.entry_point >= dip->at_low_pc &&
1768       objfile->ei.entry_point < dip->at_high_pc)
1769     {
1770       objfile->ei.entry_func_lowpc = dip->at_low_pc;
1771       objfile->ei.entry_func_highpc = dip->at_high_pc;
1772     }
1773   new = push_context (0, dip->at_low_pc);
1774   new->name = new_symbol (dip, objfile);
1775   list_in_scope = &local_symbols;
1776   process_dies (thisdie + dip->die_length, enddie, objfile);
1777   new = pop_context ();
1778   /* Make a block for the local symbols within.  */
1779   finish_block (new->name, &local_symbols, new->old_blocks,
1780                 new->start_addr, dip->at_high_pc, objfile);
1781   list_in_scope = &file_symbols;
1782 }
1783
1784
1785 /*
1786
1787    LOCAL FUNCTION
1788
1789    handle_producer -- process the AT_producer attribute
1790
1791    DESCRIPTION
1792
1793    Perform any operations that depend on finding a particular
1794    AT_producer attribute.
1795
1796  */
1797
1798 static void
1799 handle_producer (char *producer)
1800 {
1801
1802   /* If this compilation unit was compiled with g++ or gcc, then set the
1803      processing_gcc_compilation flag. */
1804
1805   if (STREQN (producer, GCC_PRODUCER, strlen (GCC_PRODUCER)))
1806     {
1807       char version = producer[strlen (GCC_PRODUCER)];
1808       processing_gcc_compilation = (version == '2' ? 2 : 1);
1809     }
1810   else
1811     {
1812       processing_gcc_compilation =
1813         STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER));
1814     }
1815
1816   /* Select a demangling style if we can identify the producer and if
1817      the current style is auto.  We leave the current style alone if it
1818      is not auto.  We also leave the demangling style alone if we find a
1819      gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1820
1821   if (AUTO_DEMANGLING)
1822     {
1823       if (STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER)))
1824         {
1825 #if 0
1826           /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
1827              know whether it will use the old style or v3 mangling.  */
1828           set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1829 #endif
1830         }
1831       else if (STREQN (producer, LCC_PRODUCER, strlen (LCC_PRODUCER)))
1832         {
1833           set_demangling_style (LUCID_DEMANGLING_STYLE_STRING);
1834         }
1835     }
1836 }
1837
1838
1839 /*
1840
1841    LOCAL FUNCTION
1842
1843    read_file_scope -- process all dies within a file scope
1844
1845    DESCRIPTION
1846
1847    Process all dies within a given file scope.  We are passed a
1848    pointer to the die information structure for the die which
1849    starts the file scope, and pointers into the raw die data which
1850    mark the range of dies within the file scope.
1851
1852    When the partial symbol table is built, the file offset for the line
1853    number table for each compilation unit is saved in the partial symbol
1854    table entry for that compilation unit.  As the symbols for each
1855    compilation unit are read, the line number table is read into memory
1856    and the variable lnbase is set to point to it.  Thus all we have to
1857    do is use lnbase to access the line number table for the current
1858    compilation unit.
1859  */
1860
1861 static void
1862 read_file_scope (struct dieinfo *dip, char *thisdie, char *enddie,
1863                  struct objfile *objfile)
1864 {
1865   struct cleanup *back_to;
1866   struct symtab *symtab;
1867
1868   if (objfile->ei.entry_point >= dip->at_low_pc &&
1869       objfile->ei.entry_point < dip->at_high_pc)
1870     {
1871       objfile->ei.deprecated_entry_file_lowpc = dip->at_low_pc;
1872       objfile->ei.deprecated_entry_file_highpc = dip->at_high_pc;
1873     }
1874   set_cu_language (dip);
1875   if (dip->at_producer != NULL)
1876     {
1877       handle_producer (dip->at_producer);
1878     }
1879   numutypes = (enddie - thisdie) / 4;
1880   utypes = (struct type **) xmalloc (numutypes * sizeof (struct type *));
1881   back_to = make_cleanup (free_utypes, NULL);
1882   memset (utypes, 0, numutypes * sizeof (struct type *));
1883   memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
1884   start_symtab (dip->at_name, dip->at_comp_dir, dip->at_low_pc);
1885   record_debugformat ("DWARF 1");
1886   decode_line_numbers (lnbase);
1887   process_dies (thisdie + dip->die_length, enddie, objfile);
1888
1889   symtab = end_symtab (dip->at_high_pc, objfile, 0);
1890   if (symtab != NULL)
1891     {
1892       symtab->language = cu_language;
1893     }
1894   do_cleanups (back_to);
1895 }
1896
1897 /*
1898
1899    LOCAL FUNCTION
1900
1901    process_dies -- process a range of DWARF Information Entries
1902
1903    SYNOPSIS
1904
1905    static void process_dies (char *thisdie, char *enddie,
1906    struct objfile *objfile)
1907
1908    DESCRIPTION
1909
1910    Process all DIE's in a specified range.  May be (and almost
1911    certainly will be) called recursively.
1912  */
1913
1914 static void
1915 process_dies (char *thisdie, char *enddie, struct objfile *objfile)
1916 {
1917   char *nextdie;
1918   struct dieinfo di;
1919
1920   while (thisdie < enddie)
1921     {
1922       basicdieinfo (&di, thisdie, objfile);
1923       if (di.die_length < SIZEOF_DIE_LENGTH)
1924         {
1925           break;
1926         }
1927       else if (di.die_tag == TAG_padding)
1928         {
1929           nextdie = thisdie + di.die_length;
1930         }
1931       else
1932         {
1933           completedieinfo (&di, objfile);
1934           if (di.at_sibling != 0)
1935             {
1936               nextdie = dbbase + di.at_sibling - dbroff;
1937             }
1938           else
1939             {
1940               nextdie = thisdie + di.die_length;
1941             }
1942           /* I think that these are always text, not data, addresses.  */
1943           di.at_low_pc = SMASH_TEXT_ADDRESS (di.at_low_pc);
1944           di.at_high_pc = SMASH_TEXT_ADDRESS (di.at_high_pc);
1945           switch (di.die_tag)
1946             {
1947             case TAG_compile_unit:
1948               /* Skip Tag_compile_unit if we are already inside a compilation
1949                  unit, we are unable to handle nested compilation units
1950                  properly (FIXME).  */
1951               if (current_subfile == NULL)
1952                 read_file_scope (&di, thisdie, nextdie, objfile);
1953               else
1954                 nextdie = thisdie + di.die_length;
1955               break;
1956             case TAG_global_subroutine:
1957             case TAG_subroutine:
1958               if (di.has_at_low_pc)
1959                 {
1960                   read_func_scope (&di, thisdie, nextdie, objfile);
1961                 }
1962               break;
1963             case TAG_lexical_block:
1964               read_lexical_block_scope (&di, thisdie, nextdie, objfile);
1965               break;
1966             case TAG_class_type:
1967             case TAG_structure_type:
1968             case TAG_union_type:
1969               read_structure_scope (&di, thisdie, nextdie, objfile);
1970               break;
1971             case TAG_enumeration_type:
1972               read_enumeration (&di, thisdie, nextdie, objfile);
1973               break;
1974             case TAG_subroutine_type:
1975               read_subroutine_type (&di, thisdie, nextdie);
1976               break;
1977             case TAG_array_type:
1978               dwarf_read_array_type (&di);
1979               break;
1980             case TAG_pointer_type:
1981               read_tag_pointer_type (&di);
1982               break;
1983             case TAG_string_type:
1984               read_tag_string_type (&di);
1985               break;
1986             default:
1987               new_symbol (&di, objfile);
1988               break;
1989             }
1990         }
1991       thisdie = nextdie;
1992     }
1993 }
1994
1995 /*
1996
1997    LOCAL FUNCTION
1998
1999    decode_line_numbers -- decode a line number table fragment
2000
2001    SYNOPSIS
2002
2003    static void decode_line_numbers (char *tblscan, char *tblend,
2004    long length, long base, long line, long pc)
2005
2006    DESCRIPTION
2007
2008    Translate the DWARF line number information to gdb form.
2009
2010    The ".line" section contains one or more line number tables, one for
2011    each ".line" section from the objects that were linked.
2012
2013    The AT_stmt_list attribute for each TAG_source_file entry in the
2014    ".debug" section contains the offset into the ".line" section for the
2015    start of the table for that file.
2016
2017    The table itself has the following structure:
2018
2019    <table length><base address><source statement entry>
2020    4 bytes       4 bytes       10 bytes
2021
2022    The table length is the total size of the table, including the 4 bytes
2023    for the length information.
2024
2025    The base address is the address of the first instruction generated
2026    for the source file.
2027
2028    Each source statement entry has the following structure:
2029
2030    <line number><statement position><address delta>
2031    4 bytes      2 bytes             4 bytes
2032
2033    The line number is relative to the start of the file, starting with
2034    line 1.
2035
2036    The statement position either -1 (0xFFFF) or the number of characters
2037    from the beginning of the line to the beginning of the statement.
2038
2039    The address delta is the difference between the base address and
2040    the address of the first instruction for the statement.
2041
2042    Note that we must copy the bytes from the packed table to our local
2043    variables before attempting to use them, to avoid alignment problems
2044    on some machines, particularly RISC processors.
2045
2046    BUGS
2047
2048    Does gdb expect the line numbers to be sorted?  They are now by
2049    chance/luck, but are not required to be.  (FIXME)
2050
2051    The line with number 0 is unused, gdb apparently can discover the
2052    span of the last line some other way. How?  (FIXME)
2053  */
2054
2055 static void
2056 decode_line_numbers (char *linetable)
2057 {
2058   char *tblscan;
2059   char *tblend;
2060   unsigned long length;
2061   unsigned long base;
2062   unsigned long line;
2063   unsigned long pc;
2064
2065   if (linetable != NULL)
2066     {
2067       tblscan = tblend = linetable;
2068       length = target_to_host (tblscan, SIZEOF_LINETBL_LENGTH, GET_UNSIGNED,
2069                                current_objfile);
2070       tblscan += SIZEOF_LINETBL_LENGTH;
2071       tblend += length;
2072       base = target_to_host (tblscan, TARGET_FT_POINTER_SIZE (objfile),
2073                              GET_UNSIGNED, current_objfile);
2074       tblscan += TARGET_FT_POINTER_SIZE (objfile);
2075       base += baseaddr;
2076       while (tblscan < tblend)
2077         {
2078           line = target_to_host (tblscan, SIZEOF_LINETBL_LINENO, GET_UNSIGNED,
2079                                  current_objfile);
2080           tblscan += SIZEOF_LINETBL_LINENO + SIZEOF_LINETBL_STMT;
2081           pc = target_to_host (tblscan, SIZEOF_LINETBL_DELTA, GET_UNSIGNED,
2082                                current_objfile);
2083           tblscan += SIZEOF_LINETBL_DELTA;
2084           pc += base;
2085           if (line != 0)
2086             {
2087               record_line (current_subfile, line, pc);
2088             }
2089         }
2090     }
2091 }
2092
2093 /*
2094
2095    LOCAL FUNCTION
2096
2097    locval -- compute the value of a location attribute
2098
2099    SYNOPSIS
2100
2101    static int locval (struct dieinfo *dip)
2102
2103    DESCRIPTION
2104
2105    Given pointer to a string of bytes that define a location, compute
2106    the location and return the value.
2107    A location description containing no atoms indicates that the
2108    object is optimized out. The optimized_out flag is set for those,
2109    the return value is meaningless.
2110
2111    When computing values involving the current value of the frame pointer,
2112    the value zero is used, which results in a value relative to the frame
2113    pointer, rather than the absolute value.  This is what GDB wants
2114    anyway.
2115
2116    When the result is a register number, the isreg flag is set, otherwise
2117    it is cleared.  This is a kludge until we figure out a better
2118    way to handle the problem.  Gdb's design does not mesh well with the
2119    DWARF notion of a location computing interpreter, which is a shame
2120    because the flexibility goes unused.
2121
2122    NOTES
2123
2124    Note that stack[0] is unused except as a default error return.
2125    Note that stack overflow is not yet handled.
2126  */
2127
2128 static int
2129 locval (struct dieinfo *dip)
2130 {
2131   unsigned short nbytes;
2132   unsigned short locsize;
2133   auto long stack[64];
2134   int stacki;
2135   char *loc;
2136   char *end;
2137   int loc_atom_code;
2138   int loc_value_size;
2139
2140   loc = dip->at_location;
2141   nbytes = attribute_size (AT_location);
2142   locsize = target_to_host (loc, nbytes, GET_UNSIGNED, current_objfile);
2143   loc += nbytes;
2144   end = loc + locsize;
2145   stacki = 0;
2146   stack[stacki] = 0;
2147   dip->isreg = 0;
2148   dip->offreg = 0;
2149   dip->optimized_out = 1;
2150   loc_value_size = TARGET_FT_LONG_SIZE (current_objfile);
2151   while (loc < end)
2152     {
2153       dip->optimized_out = 0;
2154       loc_atom_code = target_to_host (loc, SIZEOF_LOC_ATOM_CODE, GET_UNSIGNED,
2155                                       current_objfile);
2156       loc += SIZEOF_LOC_ATOM_CODE;
2157       switch (loc_atom_code)
2158         {
2159         case 0:
2160           /* error */
2161           loc = end;
2162           break;
2163         case OP_REG:
2164           /* push register (number) */
2165           stack[++stacki]
2166             = DWARF_REG_TO_REGNUM (target_to_host (loc, loc_value_size,
2167                                                    GET_UNSIGNED,
2168                                                    current_objfile));
2169           loc += loc_value_size;
2170           dip->isreg = 1;
2171           break;
2172         case OP_BASEREG:
2173           /* push value of register (number) */
2174           /* Actually, we compute the value as if register has 0, so the
2175              value ends up being the offset from that register.  */
2176           dip->offreg = 1;
2177           dip->basereg = target_to_host (loc, loc_value_size, GET_UNSIGNED,
2178                                          current_objfile);
2179           loc += loc_value_size;
2180           stack[++stacki] = 0;
2181           break;
2182         case OP_ADDR:
2183           /* push address (relocated address) */
2184           stack[++stacki] = target_to_host (loc, loc_value_size,
2185                                             GET_UNSIGNED, current_objfile);
2186           loc += loc_value_size;
2187           break;
2188         case OP_CONST:
2189           /* push constant (number)   FIXME: signed or unsigned! */
2190           stack[++stacki] = target_to_host (loc, loc_value_size,
2191                                             GET_SIGNED, current_objfile);
2192           loc += loc_value_size;
2193           break;
2194         case OP_DEREF2:
2195           /* pop, deref and push 2 bytes (as a long) */
2196           complaint (&symfile_complaints,
2197                      "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%lx not handled",
2198                      DIE_ID, DIE_NAME, stack[stacki]);
2199           break;
2200         case OP_DEREF4: /* pop, deref and push 4 bytes (as a long) */
2201           complaint (&symfile_complaints,
2202                      "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%lx not handled",
2203                      DIE_ID, DIE_NAME, stack[stacki]);
2204           break;
2205         case OP_ADD:            /* pop top 2 items, add, push result */
2206           stack[stacki - 1] += stack[stacki];
2207           stacki--;
2208           break;
2209         }
2210     }
2211   return (stack[stacki]);
2212 }
2213
2214 /*
2215
2216    LOCAL FUNCTION
2217
2218    read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2219
2220    SYNOPSIS
2221
2222    static void read_ofile_symtab (struct partial_symtab *pst)
2223
2224    DESCRIPTION
2225
2226    When expanding a partial symbol table entry to a full symbol table
2227    entry, this is the function that gets called to read in the symbols
2228    for the compilation unit.  A pointer to the newly constructed symtab,
2229    which is now the new first one on the objfile's symtab list, is
2230    stashed in the partial symbol table entry.
2231  */
2232
2233 static void
2234 read_ofile_symtab (struct partial_symtab *pst)
2235 {
2236   struct cleanup *back_to;
2237   unsigned long lnsize;
2238   file_ptr foffset;
2239   bfd *abfd;
2240   char lnsizedata[SIZEOF_LINETBL_LENGTH];
2241
2242   abfd = pst->objfile->obfd;
2243   current_objfile = pst->objfile;
2244
2245   /* Allocate a buffer for the entire chunk of DIE's for this compilation
2246      unit, seek to the location in the file, and read in all the DIE's. */
2247
2248   diecount = 0;
2249   dbsize = DBLENGTH (pst);
2250   dbbase = xmalloc (dbsize);
2251   dbroff = DBROFF (pst);
2252   foffset = DBFOFF (pst) + dbroff;
2253   base_section_offsets = pst->section_offsets;
2254   baseaddr = ANOFFSET (pst->section_offsets, 0);
2255   if (bfd_seek (abfd, foffset, SEEK_SET) ||
2256       (bfd_bread (dbbase, dbsize, abfd) != dbsize))
2257     {
2258       xfree (dbbase);
2259       error ("can't read DWARF data");
2260     }
2261   back_to = make_cleanup (xfree, dbbase);
2262
2263   /* If there is a line number table associated with this compilation unit
2264      then read the size of this fragment in bytes, from the fragment itself.
2265      Allocate a buffer for the fragment and read it in for future
2266      processing. */
2267
2268   lnbase = NULL;
2269   if (LNFOFF (pst))
2270     {
2271       if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) ||
2272           (bfd_bread (lnsizedata, sizeof (lnsizedata), abfd)
2273            != sizeof (lnsizedata)))
2274         {
2275           error ("can't read DWARF line number table size");
2276         }
2277       lnsize = target_to_host (lnsizedata, SIZEOF_LINETBL_LENGTH,
2278                                GET_UNSIGNED, pst->objfile);
2279       lnbase = xmalloc (lnsize);
2280       if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) ||
2281           (bfd_bread (lnbase, lnsize, abfd) != lnsize))
2282         {
2283           xfree (lnbase);
2284           error ("can't read DWARF line numbers");
2285         }
2286       make_cleanup (xfree, lnbase);
2287     }
2288
2289   process_dies (dbbase, dbbase + dbsize, pst->objfile);
2290   do_cleanups (back_to);
2291   current_objfile = NULL;
2292   pst->symtab = pst->objfile->symtabs;
2293 }
2294
2295 /*
2296
2297    LOCAL FUNCTION
2298
2299    psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2300
2301    SYNOPSIS
2302
2303    static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2304
2305    DESCRIPTION
2306
2307    Called once for each partial symbol table entry that needs to be
2308    expanded into a full symbol table entry.
2309
2310  */
2311
2312 static void
2313 psymtab_to_symtab_1 (struct partial_symtab *pst)
2314 {
2315   int i;
2316   struct cleanup *old_chain;
2317
2318   if (pst != NULL)
2319     {
2320       if (pst->readin)
2321         {
2322           warning ("psymtab for %s already read in.  Shouldn't happen.",
2323                    pst->filename);
2324         }
2325       else
2326         {
2327           /* Read in all partial symtabs on which this one is dependent */
2328           for (i = 0; i < pst->number_of_dependencies; i++)
2329             {
2330               if (!pst->dependencies[i]->readin)
2331                 {
2332                   /* Inform about additional files that need to be read in. */
2333                   if (info_verbose)
2334                     {
2335                       fputs_filtered (" ", gdb_stdout);
2336                       wrap_here ("");
2337                       fputs_filtered ("and ", gdb_stdout);
2338                       wrap_here ("");
2339                       printf_filtered ("%s...",
2340                                        pst->dependencies[i]->filename);
2341                       wrap_here ("");
2342                       gdb_flush (gdb_stdout);   /* Flush output */
2343                     }
2344                   psymtab_to_symtab_1 (pst->dependencies[i]);
2345                 }
2346             }
2347           if (DBLENGTH (pst))   /* Otherwise it's a dummy */
2348             {
2349               buildsym_init ();
2350               old_chain = make_cleanup (really_free_pendings, 0);
2351               read_ofile_symtab (pst);
2352               if (info_verbose)
2353                 {
2354                   printf_filtered ("%d DIE's, sorting...", diecount);
2355                   wrap_here ("");
2356                   gdb_flush (gdb_stdout);
2357                 }
2358               do_cleanups (old_chain);
2359             }
2360           pst->readin = 1;
2361         }
2362     }
2363 }
2364
2365 /*
2366
2367    LOCAL FUNCTION
2368
2369    dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2370
2371    SYNOPSIS
2372
2373    static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2374
2375    DESCRIPTION
2376
2377    This is the DWARF support entry point for building a full symbol
2378    table entry from a partial symbol table entry.  We are passed a
2379    pointer to the partial symbol table entry that needs to be expanded.
2380
2381  */
2382
2383 static void
2384 dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2385 {
2386
2387   if (pst != NULL)
2388     {
2389       if (pst->readin)
2390         {
2391           warning ("psymtab for %s already read in.  Shouldn't happen.",
2392                    pst->filename);
2393         }
2394       else
2395         {
2396           if (DBLENGTH (pst) || pst->number_of_dependencies)
2397             {
2398               /* Print the message now, before starting serious work, to avoid
2399                  disconcerting pauses.  */
2400               if (info_verbose)
2401                 {
2402                   printf_filtered ("Reading in symbols for %s...",
2403                                    pst->filename);
2404                   gdb_flush (gdb_stdout);
2405                 }
2406
2407               psymtab_to_symtab_1 (pst);
2408
2409 #if 0                           /* FIXME:  Check to see what dbxread is doing here and see if
2410                                    we need to do an equivalent or is this something peculiar to
2411                                    stabs/a.out format.
2412                                    Match with global symbols.  This only needs to be done once,
2413                                    after all of the symtabs and dependencies have been read in.
2414                                  */
2415               scan_file_globals (pst->objfile);
2416 #endif
2417
2418               /* Finish up the verbose info message.  */
2419               if (info_verbose)
2420                 {
2421                   printf_filtered ("done.\n");
2422                   gdb_flush (gdb_stdout);
2423                 }
2424             }
2425         }
2426     }
2427 }
2428
2429 /*
2430
2431    LOCAL FUNCTION
2432
2433    add_enum_psymbol -- add enumeration members to partial symbol table
2434
2435    DESCRIPTION
2436
2437    Given pointer to a DIE that is known to be for an enumeration,
2438    extract the symbolic names of the enumeration members and add
2439    partial symbols for them.
2440  */
2441
2442 static void
2443 add_enum_psymbol (struct dieinfo *dip, struct objfile *objfile)
2444 {
2445   char *scan;
2446   char *listend;
2447   unsigned short blocksz;
2448   int nbytes;
2449
2450   scan = dip->at_element_list;
2451   if (scan != NULL)
2452     {
2453       if (dip->short_element_list)
2454         {
2455           nbytes = attribute_size (AT_short_element_list);
2456         }
2457       else
2458         {
2459           nbytes = attribute_size (AT_element_list);
2460         }
2461       blocksz = target_to_host (scan, nbytes, GET_UNSIGNED, objfile);
2462       scan += nbytes;
2463       listend = scan + blocksz;
2464       while (scan < listend)
2465         {
2466           scan += TARGET_FT_LONG_SIZE (objfile);
2467           add_psymbol_to_list (scan, strlen (scan), VAR_DOMAIN, LOC_CONST,
2468                                &objfile->static_psymbols, 0, 0, cu_language,
2469                                objfile);
2470           scan += strlen (scan) + 1;
2471         }
2472     }
2473 }
2474
2475 /*
2476
2477    LOCAL FUNCTION
2478
2479    add_partial_symbol -- add symbol to partial symbol table
2480
2481    DESCRIPTION
2482
2483    Given a DIE, if it is one of the types that we want to
2484    add to a partial symbol table, finish filling in the die info
2485    and then add a partial symbol table entry for it.
2486
2487    NOTES
2488
2489    The caller must ensure that the DIE has a valid name attribute.
2490  */
2491
2492 static void
2493 add_partial_symbol (struct dieinfo *dip, struct objfile *objfile)
2494 {
2495   switch (dip->die_tag)
2496     {
2497     case TAG_global_subroutine:
2498       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2499                            VAR_DOMAIN, LOC_BLOCK,
2500                            &objfile->global_psymbols,
2501                            0, dip->at_low_pc, cu_language, objfile);
2502       break;
2503     case TAG_global_variable:
2504       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2505                            VAR_DOMAIN, LOC_STATIC,
2506                            &objfile->global_psymbols,
2507                            0, 0, cu_language, objfile);
2508       break;
2509     case TAG_subroutine:
2510       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2511                            VAR_DOMAIN, LOC_BLOCK,
2512                            &objfile->static_psymbols,
2513                            0, dip->at_low_pc, cu_language, objfile);
2514       break;
2515     case TAG_local_variable:
2516       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2517                            VAR_DOMAIN, LOC_STATIC,
2518                            &objfile->static_psymbols,
2519                            0, 0, cu_language, objfile);
2520       break;
2521     case TAG_typedef:
2522       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2523                            VAR_DOMAIN, LOC_TYPEDEF,
2524                            &objfile->static_psymbols,
2525                            0, 0, cu_language, objfile);
2526       break;
2527     case TAG_class_type:
2528     case TAG_structure_type:
2529     case TAG_union_type:
2530     case TAG_enumeration_type:
2531       /* Do not add opaque aggregate definitions to the psymtab.  */
2532       if (!dip->has_at_byte_size)
2533         break;
2534       add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2535                            STRUCT_DOMAIN, LOC_TYPEDEF,
2536                            &objfile->static_psymbols,
2537                            0, 0, cu_language, objfile);
2538       if (cu_language == language_cplus)
2539         {
2540           /* For C++, these implicitly act as typedefs as well. */
2541           add_psymbol_to_list (dip->at_name, strlen (dip->at_name),
2542                                VAR_DOMAIN, LOC_TYPEDEF,
2543                                &objfile->static_psymbols,
2544                                0, 0, cu_language, objfile);
2545         }
2546       break;
2547     }
2548 }
2549 /* *INDENT-OFF* */
2550 /*
2551
2552 LOCAL FUNCTION
2553
2554         scan_partial_symbols -- scan DIE's within a single compilation unit
2555
2556 DESCRIPTION
2557
2558         Process the DIE's within a single compilation unit, looking for
2559         interesting DIE's that contribute to the partial symbol table entry
2560         for this compilation unit.
2561
2562 NOTES
2563
2564         There are some DIE's that may appear both at file scope and within
2565         the scope of a function.  We are only interested in the ones at file
2566         scope, and the only way to tell them apart is to keep track of the
2567         scope.  For example, consider the test case:
2568
2569                 static int i;
2570                 main () { int j; }
2571
2572         for which the relevant DWARF segment has the structure:
2573
2574                 0x51:
2575                 0x23   global subrtn   sibling     0x9b
2576                                        name        main
2577                                        fund_type   FT_integer
2578                                        low_pc      0x800004cc
2579                                        high_pc     0x800004d4
2580
2581                 0x74:
2582                 0x23   local var       sibling     0x97
2583                                        name        j
2584                                        fund_type   FT_integer
2585                                        location    OP_BASEREG 0xe
2586                                                    OP_CONST 0xfffffffc
2587                                                    OP_ADD
2588                 0x97:
2589                 0x4
2590
2591                 0x9b:
2592                 0x1d   local var       sibling     0xb8
2593                                        name        i
2594                                        fund_type   FT_integer
2595                                        location    OP_ADDR 0x800025dc
2596
2597                 0xb8:
2598                 0x4
2599
2600         We want to include the symbol 'i' in the partial symbol table, but
2601         not the symbol 'j'.  In essence, we want to skip all the dies within
2602         the scope of a TAG_global_subroutine DIE.
2603
2604         Don't attempt to add anonymous structures or unions since they have
2605         no name.  Anonymous enumerations however are processed, because we
2606         want to extract their member names (the check for a tag name is
2607         done later).
2608
2609         Also, for variables and subroutines, check that this is the place
2610         where the actual definition occurs, rather than just a reference
2611         to an external.
2612  */
2613 /* *INDENT-ON* */
2614
2615
2616
2617 static void
2618 scan_partial_symbols (char *thisdie, char *enddie, struct objfile *objfile)
2619 {
2620   char *nextdie;
2621   char *temp;
2622   struct dieinfo di;
2623
2624   while (thisdie < enddie)
2625     {
2626       basicdieinfo (&di, thisdie, objfile);
2627       if (di.die_length < SIZEOF_DIE_LENGTH)
2628         {
2629           break;
2630         }
2631       else
2632         {
2633           nextdie = thisdie + di.die_length;
2634           /* To avoid getting complete die information for every die, we
2635              only do it (below) for the cases we are interested in. */
2636           switch (di.die_tag)
2637             {
2638             case TAG_global_subroutine:
2639             case TAG_subroutine:
2640               completedieinfo (&di, objfile);
2641               if (di.at_name && (di.has_at_low_pc || di.at_location))
2642                 {
2643                   add_partial_symbol (&di, objfile);
2644                   /* If there is a sibling attribute, adjust the nextdie
2645                      pointer to skip the entire scope of the subroutine.
2646                      Apply some sanity checking to make sure we don't
2647                      overrun or underrun the range of remaining DIE's */
2648                   if (di.at_sibling != 0)
2649                     {
2650                       temp = dbbase + di.at_sibling - dbroff;
2651                       if ((temp < thisdie) || (temp >= enddie))
2652                         {
2653                           bad_die_ref_complaint (DIE_ID, DIE_NAME,
2654                                                  di.at_sibling);
2655                         }
2656                       else
2657                         {
2658                           nextdie = temp;
2659                         }
2660                     }
2661                 }
2662               break;
2663             case TAG_global_variable:
2664             case TAG_local_variable:
2665               completedieinfo (&di, objfile);
2666               if (di.at_name && (di.has_at_low_pc || di.at_location))
2667                 {
2668                   add_partial_symbol (&di, objfile);
2669                 }
2670               break;
2671             case TAG_typedef:
2672             case TAG_class_type:
2673             case TAG_structure_type:
2674             case TAG_union_type:
2675               completedieinfo (&di, objfile);
2676               if (di.at_name)
2677                 {
2678                   add_partial_symbol (&di, objfile);
2679                 }
2680               break;
2681             case TAG_enumeration_type:
2682               completedieinfo (&di, objfile);
2683               if (di.at_name)
2684                 {
2685                   add_partial_symbol (&di, objfile);
2686                 }
2687               add_enum_psymbol (&di, objfile);
2688               break;
2689             }
2690         }
2691       thisdie = nextdie;
2692     }
2693 }
2694
2695 /*
2696
2697    LOCAL FUNCTION
2698
2699    scan_compilation_units -- build a psymtab entry for each compilation
2700
2701    DESCRIPTION
2702
2703    This is the top level dwarf parsing routine for building partial
2704    symbol tables.
2705
2706    It scans from the beginning of the DWARF table looking for the first
2707    TAG_compile_unit DIE, and then follows the sibling chain to locate
2708    each additional TAG_compile_unit DIE.
2709
2710    For each TAG_compile_unit DIE it creates a partial symtab structure,
2711    calls a subordinate routine to collect all the compilation unit's
2712    global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2713    new partial symtab structure into the partial symbol table.  It also
2714    records the appropriate information in the partial symbol table entry
2715    to allow the chunk of DIE's and line number table for this compilation
2716    unit to be located and re-read later, to generate a complete symbol
2717    table entry for the compilation unit.
2718
2719    Thus it effectively partitions up a chunk of DIE's for multiple
2720    compilation units into smaller DIE chunks and line number tables,
2721    and associates them with a partial symbol table entry.
2722
2723    NOTES
2724
2725    If any compilation unit has no line number table associated with
2726    it for some reason (a missing at_stmt_list attribute, rather than
2727    just one with a value of zero, which is valid) then we ensure that
2728    the recorded file offset is zero so that the routine which later
2729    reads line number table fragments knows that there is no fragment
2730    to read.
2731
2732    RETURNS
2733
2734    Returns no value.
2735
2736  */
2737
2738 static void
2739 scan_compilation_units (char *thisdie, char *enddie, file_ptr dbfoff,
2740                         file_ptr lnoffset, struct objfile *objfile)
2741 {
2742   char *nextdie;
2743   struct dieinfo di;
2744   struct partial_symtab *pst;
2745   int culength;
2746   int curoff;
2747   file_ptr curlnoffset;
2748
2749   while (thisdie < enddie)
2750     {
2751       basicdieinfo (&di, thisdie, objfile);
2752       if (di.die_length < SIZEOF_DIE_LENGTH)
2753         {
2754           break;
2755         }
2756       else if (di.die_tag != TAG_compile_unit)
2757         {
2758           nextdie = thisdie + di.die_length;
2759         }
2760       else
2761         {
2762           completedieinfo (&di, objfile);
2763           set_cu_language (&di);
2764           if (di.at_sibling != 0)
2765             {
2766               nextdie = dbbase + di.at_sibling - dbroff;
2767             }
2768           else
2769             {
2770               nextdie = thisdie + di.die_length;
2771             }
2772           curoff = thisdie - dbbase;
2773           culength = nextdie - thisdie;
2774           curlnoffset = di.has_at_stmt_list ? lnoffset + di.at_stmt_list : 0;
2775
2776           /* First allocate a new partial symbol table structure */
2777
2778           pst = start_psymtab_common (objfile, base_section_offsets,
2779                                       di.at_name, di.at_low_pc,
2780                                       objfile->global_psymbols.next,
2781                                       objfile->static_psymbols.next);
2782
2783           pst->texthigh = di.at_high_pc;
2784           pst->read_symtab_private = (char *)
2785             obstack_alloc (&objfile->psymbol_obstack,
2786                            sizeof (struct dwfinfo));
2787           DBFOFF (pst) = dbfoff;
2788           DBROFF (pst) = curoff;
2789           DBLENGTH (pst) = culength;
2790           LNFOFF (pst) = curlnoffset;
2791           pst->read_symtab = dwarf_psymtab_to_symtab;
2792
2793           /* Now look for partial symbols */
2794
2795           scan_partial_symbols (thisdie + di.die_length, nextdie, objfile);
2796
2797           pst->n_global_syms = objfile->global_psymbols.next -
2798             (objfile->global_psymbols.list + pst->globals_offset);
2799           pst->n_static_syms = objfile->static_psymbols.next -
2800             (objfile->static_psymbols.list + pst->statics_offset);
2801           sort_pst_symbols (pst);
2802           /* If there is already a psymtab or symtab for a file of this name,
2803              remove it. (If there is a symtab, more drastic things also
2804              happen.)  This happens in VxWorks.  */
2805           free_named_symtabs (pst->filename);
2806         }
2807       thisdie = nextdie;
2808     }
2809 }
2810
2811 /*
2812
2813    LOCAL FUNCTION
2814
2815    new_symbol -- make a symbol table entry for a new symbol
2816
2817    SYNOPSIS
2818
2819    static struct symbol *new_symbol (struct dieinfo *dip,
2820    struct objfile *objfile)
2821
2822    DESCRIPTION
2823
2824    Given a pointer to a DWARF information entry, figure out if we need
2825    to make a symbol table entry for it, and if so, create a new entry
2826    and return a pointer to it.
2827  */
2828
2829 static struct symbol *
2830 new_symbol (struct dieinfo *dip, struct objfile *objfile)
2831 {
2832   struct symbol *sym = NULL;
2833
2834   if (dip->at_name != NULL)
2835     {
2836       sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
2837                                              sizeof (struct symbol));
2838       OBJSTAT (objfile, n_syms++);
2839       memset (sym, 0, sizeof (struct symbol));
2840       /* default assumptions */
2841       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2842       SYMBOL_CLASS (sym) = LOC_STATIC;
2843       SYMBOL_TYPE (sym) = decode_die_type (dip);
2844
2845       /* If this symbol is from a C++ compilation, then attempt to cache the
2846          demangled form for future reference.  This is a typical time versus
2847          space tradeoff, that was decided in favor of time because it sped up
2848          C++ symbol lookups by a factor of about 20. */
2849
2850       SYMBOL_LANGUAGE (sym) = cu_language;
2851       SYMBOL_SET_NAMES (sym, dip->at_name, strlen (dip->at_name), objfile);
2852       switch (dip->die_tag)
2853         {
2854         case TAG_label:
2855           SYMBOL_VALUE_ADDRESS (sym) = dip->at_low_pc;
2856           SYMBOL_CLASS (sym) = LOC_LABEL;
2857           break;
2858         case TAG_global_subroutine:
2859         case TAG_subroutine:
2860           SYMBOL_VALUE_ADDRESS (sym) = dip->at_low_pc;
2861           SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
2862           if (dip->at_prototyped)
2863             TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
2864           SYMBOL_CLASS (sym) = LOC_BLOCK;
2865           if (dip->die_tag == TAG_global_subroutine)
2866             {
2867               add_symbol_to_list (sym, &global_symbols);
2868             }
2869           else
2870             {
2871               add_symbol_to_list (sym, list_in_scope);
2872             }
2873           break;
2874         case TAG_global_variable:
2875           if (dip->at_location != NULL)
2876             {
2877               SYMBOL_VALUE_ADDRESS (sym) = locval (dip);
2878               add_symbol_to_list (sym, &global_symbols);
2879               SYMBOL_CLASS (sym) = LOC_STATIC;
2880               SYMBOL_VALUE (sym) += baseaddr;
2881             }
2882           break;
2883         case TAG_local_variable:
2884           if (dip->at_location != NULL)
2885             {
2886               int loc = locval (dip);
2887               if (dip->optimized_out)
2888                 {
2889                   SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
2890                 }
2891               else if (dip->isreg)
2892                 {
2893                   SYMBOL_CLASS (sym) = LOC_REGISTER;
2894                 }
2895               else if (dip->offreg)
2896                 {
2897                   SYMBOL_CLASS (sym) = LOC_BASEREG;
2898                   SYMBOL_BASEREG (sym) = dip->basereg;
2899                 }
2900               else
2901                 {
2902                   SYMBOL_CLASS (sym) = LOC_STATIC;
2903                   SYMBOL_VALUE (sym) += baseaddr;
2904                 }
2905               if (SYMBOL_CLASS (sym) == LOC_STATIC)
2906                 {
2907                   /* LOC_STATIC address class MUST use SYMBOL_VALUE_ADDRESS,
2908                      which may store to a bigger location than SYMBOL_VALUE. */
2909                   SYMBOL_VALUE_ADDRESS (sym) = loc;
2910                 }
2911               else
2912                 {
2913                   SYMBOL_VALUE (sym) = loc;
2914                 }
2915               add_symbol_to_list (sym, list_in_scope);
2916             }
2917           break;
2918         case TAG_formal_parameter:
2919           if (dip->at_location != NULL)
2920             {
2921               SYMBOL_VALUE (sym) = locval (dip);
2922             }
2923           add_symbol_to_list (sym, list_in_scope);
2924           if (dip->isreg)
2925             {
2926               SYMBOL_CLASS (sym) = LOC_REGPARM;
2927             }
2928           else if (dip->offreg)
2929             {
2930               SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
2931               SYMBOL_BASEREG (sym) = dip->basereg;
2932             }
2933           else
2934             {
2935               SYMBOL_CLASS (sym) = LOC_ARG;
2936             }
2937           break;
2938         case TAG_unspecified_parameters:
2939           /* From varargs functions; gdb doesn't seem to have any interest in
2940              this information, so just ignore it for now. (FIXME?) */
2941           break;
2942         case TAG_class_type:
2943         case TAG_structure_type:
2944         case TAG_union_type:
2945         case TAG_enumeration_type:
2946           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2947           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
2948           add_symbol_to_list (sym, list_in_scope);
2949           break;
2950         case TAG_typedef:
2951           SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2952           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2953           add_symbol_to_list (sym, list_in_scope);
2954           break;
2955         default:
2956           /* Not a tag we recognize.  Hopefully we aren't processing trash
2957              data, but since we must specifically ignore things we don't
2958              recognize, there is nothing else we should do at this point. */
2959           break;
2960         }
2961     }
2962   return (sym);
2963 }
2964
2965 /*
2966
2967    LOCAL FUNCTION
2968
2969    synthesize_typedef -- make a symbol table entry for a "fake" typedef
2970
2971    SYNOPSIS
2972
2973    static void synthesize_typedef (struct dieinfo *dip,
2974    struct objfile *objfile,
2975    struct type *type);
2976
2977    DESCRIPTION
2978
2979    Given a pointer to a DWARF information entry, synthesize a typedef
2980    for the name in the DIE, using the specified type.
2981
2982    This is used for C++ class, structs, unions, and enumerations to
2983    set up the tag name as a type.
2984
2985  */
2986
2987 static void
2988 synthesize_typedef (struct dieinfo *dip, struct objfile *objfile,
2989                     struct type *type)
2990 {
2991   struct symbol *sym = NULL;
2992
2993   if (dip->at_name != NULL)
2994     {
2995       sym = (struct symbol *)
2996         obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
2997       OBJSTAT (objfile, n_syms++);
2998       memset (sym, 0, sizeof (struct symbol));
2999       DEPRECATED_SYMBOL_NAME (sym) = create_name (dip->at_name,
3000                                        &objfile->symbol_obstack);
3001       SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
3002       SYMBOL_TYPE (sym) = type;
3003       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
3004       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3005       add_symbol_to_list (sym, list_in_scope);
3006     }
3007 }
3008
3009 /*
3010
3011    LOCAL FUNCTION
3012
3013    decode_mod_fund_type -- decode a modified fundamental type
3014
3015    SYNOPSIS
3016
3017    static struct type *decode_mod_fund_type (char *typedata)
3018
3019    DESCRIPTION
3020
3021    Decode a block of data containing a modified fundamental
3022    type specification.  TYPEDATA is a pointer to the block,
3023    which starts with a length containing the size of the rest
3024    of the block.  At the end of the block is a fundmental type
3025    code value that gives the fundamental type.  Everything
3026    in between are type modifiers.
3027
3028    We simply compute the number of modifiers and call the general
3029    function decode_modified_type to do the actual work.
3030  */
3031
3032 static struct type *
3033 decode_mod_fund_type (char *typedata)
3034 {
3035   struct type *typep = NULL;
3036   unsigned short modcount;
3037   int nbytes;
3038
3039   /* Get the total size of the block, exclusive of the size itself */
3040
3041   nbytes = attribute_size (AT_mod_fund_type);
3042   modcount = target_to_host (typedata, nbytes, GET_UNSIGNED, current_objfile);
3043   typedata += nbytes;
3044
3045   /* Deduct the size of the fundamental type bytes at the end of the block. */
3046
3047   modcount -= attribute_size (AT_fund_type);
3048
3049   /* Now do the actual decoding */
3050
3051   typep = decode_modified_type (typedata, modcount, AT_mod_fund_type);
3052   return (typep);
3053 }
3054
3055 /*
3056
3057    LOCAL FUNCTION
3058
3059    decode_mod_u_d_type -- decode a modified user defined type
3060
3061    SYNOPSIS
3062
3063    static struct type *decode_mod_u_d_type (char *typedata)
3064
3065    DESCRIPTION
3066
3067    Decode a block of data containing a modified user defined
3068    type specification.  TYPEDATA is a pointer to the block,
3069    which consists of a two byte length, containing the size
3070    of the rest of the block.  At the end of the block is a
3071    four byte value that gives a reference to a user defined type.
3072    Everything in between are type modifiers.
3073
3074    We simply compute the number of modifiers and call the general
3075    function decode_modified_type to do the actual work.
3076  */
3077
3078 static struct type *
3079 decode_mod_u_d_type (char *typedata)
3080 {
3081   struct type *typep = NULL;
3082   unsigned short modcount;
3083   int nbytes;
3084
3085   /* Get the total size of the block, exclusive of the size itself */
3086
3087   nbytes = attribute_size (AT_mod_u_d_type);
3088   modcount = target_to_host (typedata, nbytes, GET_UNSIGNED, current_objfile);
3089   typedata += nbytes;
3090
3091   /* Deduct the size of the reference type bytes at the end of the block. */
3092
3093   modcount -= attribute_size (AT_user_def_type);
3094
3095   /* Now do the actual decoding */
3096
3097   typep = decode_modified_type (typedata, modcount, AT_mod_u_d_type);
3098   return (typep);
3099 }
3100
3101 /*
3102
3103    LOCAL FUNCTION
3104
3105    decode_modified_type -- decode modified user or fundamental type
3106
3107    SYNOPSIS
3108
3109    static struct type *decode_modified_type (char *modifiers,
3110    unsigned short modcount, int mtype)
3111
3112    DESCRIPTION
3113
3114    Decode a modified type, either a modified fundamental type or
3115    a modified user defined type.  MODIFIERS is a pointer to the
3116    block of bytes that define MODCOUNT modifiers.  Immediately
3117    following the last modifier is a short containing the fundamental
3118    type or a long containing the reference to the user defined
3119    type.  Which one is determined by MTYPE, which is either
3120    AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3121    type we are generating.
3122
3123    We call ourself recursively to generate each modified type,`
3124    until MODCOUNT reaches zero, at which point we have consumed
3125    all the modifiers and generate either the fundamental type or
3126    user defined type.  When the recursion unwinds, each modifier
3127    is applied in turn to generate the full modified type.
3128
3129    NOTES
3130
3131    If we find a modifier that we don't recognize, and it is not one
3132    of those reserved for application specific use, then we issue a
3133    warning and simply ignore the modifier.
3134
3135    BUGS
3136
3137    We currently ignore MOD_const and MOD_volatile.  (FIXME)
3138
3139  */
3140
3141 static struct type *
3142 decode_modified_type (char *modifiers, unsigned int modcount, int mtype)
3143 {
3144   struct type *typep = NULL;
3145   unsigned short fundtype;
3146   DIE_REF die_ref;
3147   char modifier;
3148   int nbytes;
3149
3150   if (modcount == 0)
3151     {
3152       switch (mtype)
3153         {
3154         case AT_mod_fund_type:
3155           nbytes = attribute_size (AT_fund_type);
3156           fundtype = target_to_host (modifiers, nbytes, GET_UNSIGNED,
3157                                      current_objfile);
3158           typep = decode_fund_type (fundtype);
3159           break;
3160         case AT_mod_u_d_type:
3161           nbytes = attribute_size (AT_user_def_type);
3162           die_ref = target_to_host (modifiers, nbytes, GET_UNSIGNED,
3163                                     current_objfile);
3164           typep = lookup_utype (die_ref);
3165           if (typep == NULL)
3166             {
3167               typep = alloc_utype (die_ref, NULL);
3168             }
3169           break;
3170         default:
3171           complaint (&symfile_complaints,
3172                      "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)",
3173                      DIE_ID, DIE_NAME, mtype);
3174           typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3175           break;
3176         }
3177     }
3178   else
3179     {
3180       modifier = *modifiers++;
3181       typep = decode_modified_type (modifiers, --modcount, mtype);
3182       switch (modifier)
3183         {
3184         case MOD_pointer_to:
3185           typep = lookup_pointer_type (typep);
3186           break;
3187         case MOD_reference_to:
3188           typep = lookup_reference_type (typep);
3189           break;
3190         case MOD_const:
3191           complaint (&symfile_complaints,
3192                      "DIE @ 0x%x \"%s\", type modifier 'const' ignored", DIE_ID,
3193                      DIE_NAME); /* FIXME */
3194           break;
3195         case MOD_volatile:
3196           complaint (&symfile_complaints,
3197                      "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored",
3198                      DIE_ID, DIE_NAME); /* FIXME */
3199           break;
3200         default:
3201           if (!(MOD_lo_user <= (unsigned char) modifier))
3202 #if 0
3203 /* This part of the test would always be true, and it triggers a compiler
3204    warning.  */
3205                 && (unsigned char) modifier <= MOD_hi_user))
3206 #endif
3207             {
3208               complaint (&symfile_complaints,
3209                          "DIE @ 0x%x \"%s\", unknown type modifier %u", DIE_ID,
3210                          DIE_NAME, modifier);
3211             }
3212           break;
3213         }
3214     }
3215   return (typep);
3216 }
3217
3218 /*
3219
3220    LOCAL FUNCTION
3221
3222    decode_fund_type -- translate basic DWARF type to gdb base type
3223
3224    DESCRIPTION
3225
3226    Given an integer that is one of the fundamental DWARF types,
3227    translate it to one of the basic internal gdb types and return
3228    a pointer to the appropriate gdb type (a "struct type *").
3229
3230    NOTES
3231
3232    For robustness, if we are asked to translate a fundamental
3233    type that we are unprepared to deal with, we return int so
3234    callers can always depend upon a valid type being returned,
3235    and so gdb may at least do something reasonable by default.
3236    If the type is not in the range of those types defined as
3237    application specific types, we also issue a warning.
3238  */
3239
3240 static struct type *
3241 decode_fund_type (unsigned int fundtype)
3242 {
3243   struct type *typep = NULL;
3244
3245   switch (fundtype)
3246     {
3247
3248     case FT_void:
3249       typep = dwarf_fundamental_type (current_objfile, FT_VOID);
3250       break;
3251
3252     case FT_boolean:            /* Was FT_set in AT&T version */
3253       typep = dwarf_fundamental_type (current_objfile, FT_BOOLEAN);
3254       break;
3255
3256     case FT_pointer:            /* (void *) */
3257       typep = dwarf_fundamental_type (current_objfile, FT_VOID);
3258       typep = lookup_pointer_type (typep);
3259       break;
3260
3261     case FT_char:
3262       typep = dwarf_fundamental_type (current_objfile, FT_CHAR);
3263       break;
3264
3265     case FT_signed_char:
3266       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_CHAR);
3267       break;
3268
3269     case FT_unsigned_char:
3270       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
3271       break;
3272
3273     case FT_short:
3274       typep = dwarf_fundamental_type (current_objfile, FT_SHORT);
3275       break;
3276
3277     case FT_signed_short:
3278       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_SHORT);
3279       break;
3280
3281     case FT_unsigned_short:
3282       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
3283       break;
3284
3285     case FT_integer:
3286       typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3287       break;
3288
3289     case FT_signed_integer:
3290       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_INTEGER);
3291       break;
3292
3293     case FT_unsigned_integer:
3294       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
3295       break;
3296
3297     case FT_long:
3298       typep = dwarf_fundamental_type (current_objfile, FT_LONG);
3299       break;
3300
3301     case FT_signed_long:
3302       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_LONG);
3303       break;
3304
3305     case FT_unsigned_long:
3306       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
3307       break;
3308
3309     case FT_long_long:
3310       typep = dwarf_fundamental_type (current_objfile, FT_LONG_LONG);
3311       break;
3312
3313     case FT_signed_long_long:
3314       typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_LONG_LONG);
3315       break;
3316
3317     case FT_unsigned_long_long:
3318       typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
3319       break;
3320
3321     case FT_float:
3322       typep = dwarf_fundamental_type (current_objfile, FT_FLOAT);
3323       break;
3324
3325     case FT_dbl_prec_float:
3326       typep = dwarf_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
3327       break;
3328
3329     case FT_ext_prec_float:
3330       typep = dwarf_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
3331       break;
3332
3333     case FT_complex:
3334       typep = dwarf_fundamental_type (current_objfile, FT_COMPLEX);
3335       break;
3336
3337     case FT_dbl_prec_complex:
3338       typep = dwarf_fundamental_type (current_objfile, FT_DBL_PREC_COMPLEX);
3339       break;
3340
3341     case FT_ext_prec_complex:
3342       typep = dwarf_fundamental_type (current_objfile, FT_EXT_PREC_COMPLEX);
3343       break;
3344
3345     }
3346
3347   if (typep == NULL)
3348     {
3349       typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3350       if (!(FT_lo_user <= fundtype && fundtype <= FT_hi_user))
3351         {
3352           complaint (&symfile_complaints,
3353                      "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x",
3354                      DIE_ID, DIE_NAME, fundtype);
3355         }
3356     }
3357
3358   return (typep);
3359 }
3360
3361 /*
3362
3363    LOCAL FUNCTION
3364
3365    create_name -- allocate a fresh copy of a string on an obstack
3366
3367    DESCRIPTION
3368
3369    Given a pointer to a string and a pointer to an obstack, allocates
3370    a fresh copy of the string on the specified obstack.
3371
3372  */
3373
3374 static char *
3375 create_name (char *name, struct obstack *obstackp)
3376 {
3377   int length;
3378   char *newname;
3379
3380   length = strlen (name) + 1;
3381   newname = (char *) obstack_alloc (obstackp, length);
3382   strcpy (newname, name);
3383   return (newname);
3384 }
3385
3386 /*
3387
3388    LOCAL FUNCTION
3389
3390    basicdieinfo -- extract the minimal die info from raw die data
3391
3392    SYNOPSIS
3393
3394    void basicdieinfo (char *diep, struct dieinfo *dip,
3395    struct objfile *objfile)
3396
3397    DESCRIPTION
3398
3399    Given a pointer to raw DIE data, and a pointer to an instance of a
3400    die info structure, this function extracts the basic information
3401    from the DIE data required to continue processing this DIE, along
3402    with some bookkeeping information about the DIE.
3403
3404    The information we absolutely must have includes the DIE tag,
3405    and the DIE length.  If we need the sibling reference, then we
3406    will have to call completedieinfo() to process all the remaining
3407    DIE information.
3408
3409    Note that since there is no guarantee that the data is properly
3410    aligned in memory for the type of access required (indirection
3411    through anything other than a char pointer), and there is no
3412    guarantee that it is in the same byte order as the gdb host,
3413    we call a function which deals with both alignment and byte
3414    swapping issues.  Possibly inefficient, but quite portable.
3415
3416    We also take care of some other basic things at this point, such
3417    as ensuring that the instance of the die info structure starts
3418    out completely zero'd and that curdie is initialized for use
3419    in error reporting if we have a problem with the current die.
3420
3421    NOTES
3422
3423    All DIE's must have at least a valid length, thus the minimum
3424    DIE size is SIZEOF_DIE_LENGTH.  In order to have a valid tag, the
3425    DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3426    are forced to be TAG_padding DIES.
3427
3428    Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3429    that if a padding DIE is used for alignment and the amount needed is
3430    less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3431    enough to align to the next alignment boundry.
3432
3433    We do some basic sanity checking here, such as verifying that the
3434    length of the die would not cause it to overrun the recorded end of
3435    the buffer holding the DIE info.  If we find a DIE that is either
3436    too small or too large, we force it's length to zero which should
3437    cause the caller to take appropriate action.
3438  */
3439
3440 static void
3441 basicdieinfo (struct dieinfo *dip, char *diep, struct objfile *objfile)
3442 {
3443   curdie = dip;
3444   memset (dip, 0, sizeof (struct dieinfo));
3445   dip->die = diep;
3446   dip->die_ref = dbroff + (diep - dbbase);
3447   dip->die_length = target_to_host (diep, SIZEOF_DIE_LENGTH, GET_UNSIGNED,
3448                                     objfile);
3449   if ((dip->die_length < SIZEOF_DIE_LENGTH) ||
3450       ((diep + dip->die_length) > (dbbase + dbsize)))
3451     {
3452       complaint (&symfile_complaints,
3453                  "DIE @ 0x%x \"%s\", malformed DIE, bad length (%ld bytes)",
3454                  DIE_ID, DIE_NAME, dip->die_length);
3455       dip->die_length = 0;
3456     }
3457   else if (dip->die_length < (SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG))
3458     {
3459       dip->die_tag = TAG_padding;
3460     }
3461   else
3462     {
3463       diep += SIZEOF_DIE_LENGTH;
3464       dip->die_tag = target_to_host (diep, SIZEOF_DIE_TAG, GET_UNSIGNED,
3465                                      objfile);
3466     }
3467 }
3468
3469 /*
3470
3471    LOCAL FUNCTION
3472
3473    completedieinfo -- finish reading the information for a given DIE
3474
3475    SYNOPSIS
3476
3477    void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3478
3479    DESCRIPTION
3480
3481    Given a pointer to an already partially initialized die info structure,
3482    scan the raw DIE data and finish filling in the die info structure
3483    from the various attributes found.
3484
3485    Note that since there is no guarantee that the data is properly
3486    aligned in memory for the type of access required (indirection
3487    through anything other than a char pointer), and there is no
3488    guarantee that it is in the same byte order as the gdb host,
3489    we call a function which deals with both alignment and byte
3490    swapping issues.  Possibly inefficient, but quite portable.
3491
3492    NOTES
3493
3494    Each time we are called, we increment the diecount variable, which
3495    keeps an approximate count of the number of dies processed for
3496    each compilation unit.  This information is presented to the user
3497    if the info_verbose flag is set.
3498
3499  */
3500
3501 static void
3502 completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3503 {
3504   char *diep;                   /* Current pointer into raw DIE data */
3505   char *end;                    /* Terminate DIE scan here */
3506   unsigned short attr;          /* Current attribute being scanned */
3507   unsigned short form;          /* Form of the attribute */
3508   int nbytes;                   /* Size of next field to read */
3509
3510   diecount++;
3511   diep = dip->die;
3512   end = diep + dip->die_length;
3513   diep += SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG;
3514   while (diep < end)
3515     {
3516       attr = target_to_host (diep, SIZEOF_ATTRIBUTE, GET_UNSIGNED, objfile);
3517       diep += SIZEOF_ATTRIBUTE;
3518       nbytes = attribute_size (attr);
3519       if (nbytes == -1)
3520         {
3521           complaint (&symfile_complaints,
3522                      "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes",
3523                      DIE_ID, DIE_NAME);
3524           diep = end;
3525           continue;
3526         }
3527       switch (attr)
3528         {
3529         case AT_fund_type:
3530           dip->at_fund_type = target_to_host (diep, nbytes, GET_UNSIGNED,
3531                                               objfile);
3532           break;
3533         case AT_ordering:
3534           dip->at_ordering = target_to_host (diep, nbytes, GET_UNSIGNED,
3535                                              objfile);
3536           break;
3537         case AT_bit_offset:
3538           dip->at_bit_offset = target_to_host (diep, nbytes, GET_UNSIGNED,
3539                                                objfile);
3540           break;
3541         case AT_sibling:
3542           dip->at_sibling = target_to_host (diep, nbytes, GET_UNSIGNED,
3543                                             objfile);
3544           break;
3545         case AT_stmt_list:
3546           dip->at_stmt_list = target_to_host (diep, nbytes, GET_UNSIGNED,
3547                                               objfile);
3548           dip->has_at_stmt_list = 1;
3549           break;
3550         case AT_low_pc:
3551           dip->at_low_pc = target_to_host (diep, nbytes, GET_UNSIGNED,
3552                                            objfile);
3553           dip->at_low_pc += baseaddr;
3554           dip->has_at_low_pc = 1;
3555           break;
3556         case AT_high_pc:
3557           dip->at_high_pc = target_to_host (diep, nbytes, GET_UNSIGNED,
3558                                             objfile);
3559           dip->at_high_pc += baseaddr;
3560           break;
3561         case AT_language:
3562           dip->at_language = target_to_host (diep, nbytes, GET_UNSIGNED,
3563                                              objfile);
3564           break;
3565         case AT_user_def_type:
3566           dip->at_user_def_type = target_to_host (diep, nbytes,
3567                                                   GET_UNSIGNED, objfile);
3568           break;
3569         case AT_byte_size:
3570           dip->at_byte_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3571                                               objfile);
3572           dip->has_at_byte_size = 1;
3573           break;
3574         case AT_bit_size:
3575           dip->at_bit_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3576                                              objfile);
3577           break;
3578         case AT_member:
3579           dip->at_member = target_to_host (diep, nbytes, GET_UNSIGNED,
3580                                            objfile);
3581           break;
3582         case AT_discr:
3583           dip->at_discr = target_to_host (diep, nbytes, GET_UNSIGNED,
3584                                           objfile);
3585           break;
3586         case AT_location:
3587           dip->at_location = diep;
3588           break;
3589         case AT_mod_fund_type:
3590           dip->at_mod_fund_type = diep;
3591           break;
3592         case AT_subscr_data:
3593           dip->at_subscr_data = diep;
3594           break;
3595         case AT_mod_u_d_type:
3596           dip->at_mod_u_d_type = diep;
3597           break;
3598         case AT_element_list:
3599           dip->at_element_list = diep;
3600           dip->short_element_list = 0;
3601           break;
3602         case AT_short_element_list:
3603           dip->at_element_list = diep;
3604           dip->short_element_list = 1;
3605           break;
3606         case AT_discr_value:
3607           dip->at_discr_value = diep;
3608           break;
3609         case AT_string_length:
3610           dip->at_string_length = diep;
3611           break;
3612         case AT_name:
3613           dip->at_name = diep;
3614           break;
3615         case AT_comp_dir:
3616           /* For now, ignore any "hostname:" portion, since gdb doesn't
3617              know how to deal with it.  (FIXME). */
3618           dip->at_comp_dir = strrchr (diep, ':');
3619           if (dip->at_comp_dir != NULL)
3620             {
3621               dip->at_comp_dir++;
3622             }
3623           else
3624             {
3625               dip->at_comp_dir = diep;
3626             }
3627           break;
3628         case AT_producer:
3629           dip->at_producer = diep;
3630           break;
3631         case AT_start_scope:
3632           dip->at_start_scope = target_to_host (diep, nbytes, GET_UNSIGNED,
3633                                                 objfile);
3634           break;
3635         case AT_stride_size:
3636           dip->at_stride_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3637                                                 objfile);
3638           break;
3639         case AT_src_info:
3640           dip->at_src_info = target_to_host (diep, nbytes, GET_UNSIGNED,
3641                                              objfile);
3642           break;
3643         case AT_prototyped:
3644           dip->at_prototyped = diep;
3645           break;
3646         default:
3647           /* Found an attribute that we are unprepared to handle.  However
3648              it is specifically one of the design goals of DWARF that
3649              consumers should ignore unknown attributes.  As long as the
3650              form is one that we recognize (so we know how to skip it),
3651              we can just ignore the unknown attribute. */
3652           break;
3653         }
3654       form = FORM_FROM_ATTR (attr);
3655       switch (form)
3656         {
3657         case FORM_DATA2:
3658           diep += 2;
3659           break;
3660         case FORM_DATA4:
3661         case FORM_REF:
3662           diep += 4;
3663           break;
3664         case FORM_DATA8:
3665           diep += 8;
3666           break;
3667         case FORM_ADDR:
3668           diep += TARGET_FT_POINTER_SIZE (objfile);
3669           break;
3670         case FORM_BLOCK2:
3671           diep += 2 + target_to_host (diep, nbytes, GET_UNSIGNED, objfile);
3672           break;
3673         case FORM_BLOCK4:
3674           diep += 4 + target_to_host (diep, nbytes, GET_UNSIGNED, objfile);
3675           break;
3676         case FORM_STRING:
3677           diep += strlen (diep) + 1;
3678           break;
3679         default:
3680           unknown_attribute_form_complaint (DIE_ID, DIE_NAME, form);
3681           diep = end;
3682           break;
3683         }
3684     }
3685 }
3686
3687 /*
3688
3689    LOCAL FUNCTION
3690
3691    target_to_host -- swap in target data to host
3692
3693    SYNOPSIS
3694
3695    target_to_host (char *from, int nbytes, int signextend,
3696    struct objfile *objfile)
3697
3698    DESCRIPTION
3699
3700    Given pointer to data in target format in FROM, a byte count for
3701    the size of the data in NBYTES, a flag indicating whether or not
3702    the data is signed in SIGNEXTEND, and a pointer to the current
3703    objfile in OBJFILE, convert the data to host format and return
3704    the converted value.
3705
3706    NOTES
3707
3708    FIXME:  If we read data that is known to be signed, and expect to
3709    use it as signed data, then we need to explicitly sign extend the
3710    result until the bfd library is able to do this for us.
3711
3712    FIXME: Would a 32 bit target ever need an 8 byte result?
3713
3714  */
3715
3716 static CORE_ADDR
3717 target_to_host (char *from, int nbytes, int signextend, /* FIXME:  Unused */
3718                 struct objfile *objfile)
3719 {
3720   CORE_ADDR rtnval;
3721
3722   switch (nbytes)
3723     {
3724     case 8:
3725       rtnval = bfd_get_64 (objfile->obfd, (bfd_byte *) from);
3726       break;
3727     case 4:
3728       rtnval = bfd_get_32 (objfile->obfd, (bfd_byte *) from);
3729       break;
3730     case 2:
3731       rtnval = bfd_get_16 (objfile->obfd, (bfd_byte *) from);
3732       break;
3733     case 1:
3734       rtnval = bfd_get_8 (objfile->obfd, (bfd_byte *) from);
3735       break;
3736     default:
3737       complaint (&symfile_complaints,
3738                  "DIE @ 0x%x \"%s\", no bfd support for %d byte data object",
3739                  DIE_ID, DIE_NAME, nbytes);
3740       rtnval = 0;
3741       break;
3742     }
3743   return (rtnval);
3744 }
3745
3746 /*
3747
3748    LOCAL FUNCTION
3749
3750    attribute_size -- compute size of data for a DWARF attribute
3751
3752    SYNOPSIS
3753
3754    static int attribute_size (unsigned int attr)
3755
3756    DESCRIPTION
3757
3758    Given a DWARF attribute in ATTR, compute the size of the first
3759    piece of data associated with this attribute and return that
3760    size.
3761
3762    Returns -1 for unrecognized attributes.
3763
3764  */
3765
3766 static int
3767 attribute_size (unsigned int attr)
3768 {
3769   int nbytes;                   /* Size of next data for this attribute */
3770   unsigned short form;          /* Form of the attribute */
3771
3772   form = FORM_FROM_ATTR (attr);
3773   switch (form)
3774     {
3775     case FORM_STRING:           /* A variable length field is next */
3776       nbytes = 0;
3777       break;
3778     case FORM_DATA2:            /* Next 2 byte field is the data itself */
3779     case FORM_BLOCK2:           /* Next 2 byte field is a block length */
3780       nbytes = 2;
3781       break;
3782     case FORM_DATA4:            /* Next 4 byte field is the data itself */
3783     case FORM_BLOCK4:           /* Next 4 byte field is a block length */
3784     case FORM_REF:              /* Next 4 byte field is a DIE offset */
3785       nbytes = 4;
3786       break;
3787     case FORM_DATA8:            /* Next 8 byte field is the data itself */
3788       nbytes = 8;
3789       break;
3790     case FORM_ADDR:             /* Next field size is target sizeof(void *) */
3791       nbytes = TARGET_FT_POINTER_SIZE (objfile);
3792       break;
3793     default:
3794       unknown_attribute_form_complaint (DIE_ID, DIE_NAME, form);
3795       nbytes = -1;
3796       break;
3797     }
3798   return (nbytes);
3799 }