gdb/dwarfread.c

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