gdb/dwarfread.c

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