gdb/dwarfread.c

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