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