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