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