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