gdb/dwarfread.c

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