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