gdb/dwarfread.c

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