gdb/dwarfread.c

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