contrib/gdb/gdb/dwarfread.c

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