gdb/dwarfread.c

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