gdb/dwarfread.c

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