gdb/dwarfread.c

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