gdb/dwarfread.c

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