gcc/dwarf2out.c

   1 /* Output Dwarf2 format symbol table information from the GNU C compiler.
   2    Copyright (C) 1992, 1993, 1995, 1996 Free Software Foundation, Inc.
   3    Contributed by Gary Funck (gary@intrepid.com).  Derived from the
   4    DWARF 1 implementation written by Ron Guilmette (rfg@monkeys.com).
   5    Extensively modified by Jason Merrill (jason@cygnus.com).
   6
   7 This file is part of GNU CC.
   8
   9 GNU CC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GNU CC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU CC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22
  23 #include "config.h"
  24
  25 #ifdef DWARF2_DEBUGGING_INFO
  26 #include <stdio.h>
  27 #include <setjmp.h>
  28 #include "dwarf2.h"
  29 #include "tree.h"
  30 #include "flags.h"
  31 #include "rtl.h"
  32 #include "hard-reg-set.h"
  33 #include "regs.h"
  34 #include "insn-config.h"
  35 #include "reload.h"
  36 #include "output.h"
  37 #include "defaults.h"
  38
  39 /* #define NDEBUG 1 */
  40 #include "assert.h"
  41
  42 extern char *getpwd ();
  43
  44 /* IMPORTANT NOTE: Please see the file README.DWARF for important details
  45    regarding the GNU implementation of DWARF.  */
  46
  47 /* NOTE: In the comments in this file, many references are made to
  48    "Debugging Information Entries".  This term is abbreviated as `DIE'
  49    throughout the remainder of this file.  */
  50
  51 #if defined(__GNUC__) && (NDEBUG == 1)
  52 #define inline static inline
  53 #else
  54 #define inline static
  55 #endif
  56
  57
  58 /* An internal representation of the DWARF output is built, and then
  59    walked to generate the DWARF debugging info.  The walk of the internal
  60    representation is done after the entire program has been compiled.
  61    The types below are used to describe the internal representation.  */
  62
  63 /* Each DIE may have a series of attribute/value pairs.  Values
  64    can take on several forms.  The forms that are used in this
  65    impelementation are listed below.  */
  66 typedef enum
  67   {
  68     dw_val_class_addr,
  69     dw_val_class_loc,
  70     dw_val_class_const,
  71     dw_val_class_unsigned_const,
  72     dw_val_class_long_long,
  73     dw_val_class_float,
  74     dw_val_class_flag,
  75     dw_val_class_die_ref,
  76     dw_val_class_fde_ref,
  77     dw_val_class_lbl_id,
  78     dw_val_class_section_offset,
  79     dw_val_class_str
  80   }
  81 dw_val_class;
  82
  83 /* Various DIE's use offsets relative to the beginning of the
  84    .debug_info section to refer to each other.  */
  85 typedef long int dw_offset;
  86
  87 /* Define typedefs here to avoid circular dependencies.  */
  88 typedef struct die_struct *dw_die_ref;
  89 typedef struct dw_attr_struct *dw_attr_ref;
  90 typedef struct dw_val_struct *dw_val_ref;
  91 typedef struct dw_line_info_struct *dw_line_info_ref;
  92 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
  93 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
  94 typedef struct dw_cfi_struct *dw_cfi_ref;
  95 typedef struct dw_fde_struct *dw_fde_ref;
  96 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
  97 typedef struct pubname_struct *pubname_ref;
  98 typedef dw_die_ref *arange_ref;
  99
 100 /* Describe a double word constant value.  */
 101 typedef struct dw_long_long_struct
 102   {
 103     unsigned long hi;
 104     unsigned long low;
 105   }
 106 dw_long_long_const;
 107
 108 /* Describe a floating point constant value.  */
 109 typedef struct dw_fp_struct
 110   {
 111     long *array;
 112     unsigned length;
 113   }
 114 dw_float_const;
 115
 116 /* Each entry in the line_info_table maintains the file and
 117    line nuber associated with the label generated for that
 118    entry.  The label gives the PC value associated with
 119    the line number entry.  */
 120 typedef struct dw_line_info_struct
 121   {
 122     unsigned long dw_file_num;
 123     unsigned long dw_line_num;
 124   }
 125 dw_line_info_entry;
 126
 127 /* Line information for functions in separate sections; each one gets its
 128    own sequence.  */
 129 typedef struct dw_separate_line_info_struct
 130   {
 131     unsigned long dw_file_num;
 132     unsigned long dw_line_num;
 133     unsigned long function;
 134   }
 135 dw_separate_line_info_entry;
 136
 137 /* The dw_val_node describes an attibute's value, as it is
 138    represnted internally.  */
 139 typedef struct dw_val_struct
 140   {
 141     dw_val_class val_class;
 142     union
 143       {
 144         char *val_addr;
 145         dw_loc_descr_ref val_loc;
 146         long int val_int;
 147         long unsigned val_unsigned;
 148         dw_long_long_const val_long_long;
 149         dw_float_const val_float;
 150         dw_die_ref val_die_ref;
 151         unsigned val_fde_index;
 152         char *val_str;
 153         char *val_lbl_id;
 154         char *val_section;
 155         unsigned char val_flag;
 156       }
 157     v;
 158   }
 159 dw_val_node;
 160
 161 /* Locations in memory are described using a sequence of stack machine
 162    operations.  */
 163 typedef struct dw_loc_descr_struct
 164   {
 165     dw_loc_descr_ref dw_loc_next;
 166     enum dwarf_location_atom dw_loc_opc;
 167     dw_val_node dw_loc_oprnd1;
 168     dw_val_node dw_loc_oprnd2;
 169   }
 170 dw_loc_descr_node;
 171
 172 /* Each DIE attribute has a field specifying the attribute kind,
 173    a link to the next attribute in the chain, and an attribute value.
 174    Attributes are typically linked below the DIE they modify.  */
 175 typedef struct dw_attr_struct
 176   {
 177     enum dwarf_attribute dw_attr;
 178     dw_attr_ref dw_attr_next;
 179     dw_val_node dw_attr_val;
 180   }
 181 dw_attr_node;
 182
 183 /* Call frames are described using a sequence of Call Frame
 184    Information instructions.  The register number, offset
 185    and address fields are provided as possible operands;
 186    their use is selected by the opcode field.  */
 187 typedef union dw_cfi_oprnd_struct
 188   {
 189     unsigned long dw_cfi_reg_num;
 190     long int dw_cfi_offset;
 191     char *dw_cfi_addr;
 192   }
 193 dw_cfi_oprnd;
 194
 195 typedef struct dw_cfi_struct
 196   {
 197     dw_cfi_ref dw_cfi_next;
 198     enum dwarf_call_frame_info dw_cfi_opc;
 199     dw_cfi_oprnd dw_cfi_oprnd1;
 200     dw_cfi_oprnd dw_cfi_oprnd2;
 201   }
 202 dw_cfi_node;
 203
 204 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 205    refer to a single Common Information Entry (CIE), defined at
 206    the beginning of the .debug_frame section.  This used of a single
 207    CIE obviates the need to keep track of multiple CIE's
 208    in the DWARF generation routines below.  */
 209 typedef struct dw_fde_struct
 210   {
 211     unsigned long dw_fde_offset;
 212     char *dw_fde_begin;
 213     char *dw_fde_current_label;
 214     char *dw_fde_end;
 215     dw_cfi_ref dw_fde_cfi;
 216   }
 217 dw_fde_node;
 218
 219 /* The Debugging Information Entry (DIE) structure */
 220 typedef struct die_struct
 221   {
 222     enum dwarf_tag die_tag;
 223     dw_attr_ref die_attr;
 224     dw_attr_ref die_attr_last;
 225     dw_die_ref die_parent;
 226     dw_die_ref die_child;
 227     dw_die_ref die_child_last;
 228     dw_die_ref die_sib;
 229     dw_offset die_offset;
 230     unsigned long die_abbrev;
 231   }
 232 die_node;
 233
 234 /* The pubname structure */
 235 typedef struct pubname_struct
 236 {
 237   dw_die_ref die;
 238   char * name;
 239 }
 240 pubname_entry;
 241
 242 /* How to start an assembler comment.  */
 243 #ifndef ASM_COMMENT_START
 244 #define ASM_COMMENT_START ";#"
 245 #endif
 246
 247 /* Define a macro which returns non-zero for a TYPE_DECL which was
 248    implicitly generated for a tagged type.
 249
 250    Note that unlike the gcc front end (which generates a NULL named
 251    TYPE_DECL node for each complete tagged type, each array type, and
 252    each function type node created) the g++ front end generates a
 253    _named_ TYPE_DECL node for each tagged type node created.
 254    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
 255    generate a DW_TAG_typedef DIE for them.  */
 256 #define TYPE_DECL_IS_STUB(decl)                         \
 257   (DECL_NAME (decl) == NULL                             \
 258    || (DECL_ARTIFICIAL (decl)                           \
 259        && is_tagged_type (TREE_TYPE (decl))             \
 260        && decl == TYPE_STUB_DECL (TREE_TYPE (decl))))
 261
 262 /* Information concerning the compilation unit's programming
 263    language, and compiler version.  */
 264 extern int flag_traditional;
 265 extern char *version_string;
 266 extern char *language_string;
 267
 268 /* Maximum size (in bytes) of an artificially generated label.   */
 269 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 270
 271 /* Make sure we know the sizes of the various types dwarf can describe. These
 272    are only defaults.  If the sizes are different for your target, you should
 273    override these values by defining the appropriate symbols in your tm.h
 274    file.  */
 275 #ifndef CHAR_TYPE_SIZE
 276 #define CHAR_TYPE_SIZE BITS_PER_UNIT
 277 #endif
 278 #ifndef PTR_SIZE
 279 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 280 #endif
 281
 282 /* The size in bytes of a DWARF field indicating an offset or length
 283    relative to a debug info section, specified to be 4 bytes in the DWARF-2
 284    specification.  The SGI/MIPS ABI defines it to be the same as PTR_SIZE.  */
 285 #ifndef DWARF_OFFSET_SIZE
 286 #define DWARF_OFFSET_SIZE 4
 287 #endif
 288
 289 #define DWARF_VERSION 2
 290
 291 /* Fixed size portion of the DWARF compilation unit header.  */
 292 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
 293
 294 /* Fixed size portion of debugging line information prolog.  */
 295 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
 296
 297 /* Fixed size portion of public names info.  */
 298 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
 299
 300 /* Round SIZE up to the nearest BOUNDARY.  */
 301 #define DWARF_ROUND(SIZE,BOUNDARY) \
 302   (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
 303
 304 /* Fixed size portion of the address range info.  */
 305 #define DWARF_ARANGES_HEADER_SIZE \
 306   (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
 307
 308 /* Fixed size portion of the CIE (including the length field).  */
 309 #define DWARF_CIE_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 5)
 310
 311 /* The un-padded size of the CIE.  Initialized in calc_fde_sizes, used
 312    in output_call_frame_info.  */
 313 static unsigned cie_size;
 314
 315 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 316 #ifdef STACK_GROWS_DOWNWARD
 317 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
 318 #else
 319 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
 320 #endif
 321
 322 /* Fixed size portion of the FDE.  */
 323 #define DWARF_FDE_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2 * PTR_SIZE)
 324
 325 /* Define the architecture-dependent minimum instruction length (in bytes).
 326    In this implementation of DWARF, this field is used for information
 327    purposes only.  Since GCC generates assembly language, we have
 328    no a priori knowledge of how many instruction bytes are generated
 329    for each source line, and therefore can use only the  DW_LNE_set_address
 330    and DW_LNS_fixed_advance_pc line information commands.  */
 331 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
 332 #define DWARF_LINE_MIN_INSTR_LENGTH 4
 333 #endif
 334
 335 /* Minimum line offset in a special line info. opcode.
 336    This value was chosen to give a reasonable range of values.  */
 337 #define DWARF_LINE_BASE  -10
 338
 339 /* First special line opcde - leave room for the standard opcodes.  */
 340 #define DWARF_LINE_OPCODE_BASE  10
 341
 342 /* Range of line offsets in a special line info. opcode.  */
 343 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
 344
 345 /* Flag that indicates the initial value of the is_stmt_start flag.
 346    In the present implementation, we do not mark any lines as
 347    the beginning of a source statement, because that information
 348    is not made available by the GCC front-end.  */
 349 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
 350
 351 /* This location is used by calc_die_sizes() to keep track
 352    the offset of each DIE within the .debug_info section.  */
 353 static unsigned long next_die_offset;
 354
 355 /* This location is used by calc_fde_sizes() to keep track
 356    the offset of each FDE within the .debug_frame section.  */
 357 static unsigned long next_fde_offset;
 358
 359 /* Record the root of the DIE's built for the current compilation unit.  */
 360 dw_die_ref comp_unit_die;
 361
 362 /* The number of DIEs with a NULL parent waiting to be relocated.  */
 363 static int limbo_die_count;
 364
 365 /* Pointer to an array of filenames referenced by this compilation unit.  */
 366 static char **file_table;
 367
 368 /* Total number of entries in the table (i.e. array) pointed to by
 369    `file_table'.  This is the *total* and includes both used and unused
 370    slots.  */
 371 static unsigned file_table_allocated;
 372
 373 /* Number of entries in the file_table which are actually in use.  */
 374 static unsigned file_table_in_use;
 375
 376 /* Size (in elements) of increments by which we may expand the filename
 377    table.  */
 378 #define FILE_TABLE_INCREMENT 64
 379
 380 /* Local pointer to the name of the main input file.  Initialized in
 381    dwarf2out_init.  */
 382 static char *primary_filename;
 383
 384 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
 385    which their beginnings are encountered. We output Dwarf debugging info
 386    that refers to the beginnings and ends of the ranges of code for each
 387    lexical block.  The labels themselves are generated in final.c, which
 388    assigns numbers to the blocks in the same way.  */
 389 static unsigned next_block_number = 2;
 390
 391 /* A pointer to the base of a table of references to DIE's that describe
 392    declarations.  The table is indexed by DECL_UID() which is a unique
 393    number, indentifying each decl.  */
 394 static dw_die_ref *decl_die_table;
 395
 396 /* Number of elements currently allocated for the decl_die_table.  */
 397 static unsigned decl_die_table_allocated;
 398
 399 /* Number of elements in decl_die_table currently in use.  */
 400 static unsigned decl_die_table_in_use;
 401
 402 /* Size (in elements) of increments by which we may expand the
 403    decl_die_table.  */
 404 #define DECL_DIE_TABLE_INCREMENT 256
 405
 406 /* A pointer to the base of a table of references to declaration
 407    scopes.  This table is a display which tracks the nesting
 408    of declaration scopes at the current scope and containing
 409    scopes.  This table is used to find the proper place to
 410    define type declaration DIE's.  */
 411 static tree *decl_scope_table;
 412
 413 /* Number of elements currently allocated for the decl_scope_table.  */
 414 static unsigned decl_scope_table_allocated;
 415
 416 /* Current level of nesting of declataion scopes.  */
 417 static unsigned decl_scope_depth;
 418
 419 /* Size (in elements) of increments by which we may expand the
 420    decl_scope_table.  */
 421 #define DECL_SCOPE_TABLE_INCREMENT 64
 422
 423 /* A pointer to the base of a list of references to DIE's that
 424    are uniquely identified by their tag, presence/absence of
 425    children DIE's, and list of attribute/value pairs.  */
 426 static dw_die_ref *abbrev_die_table;
 427
 428 /* Number of elements currently allocated for abbrev_die_table.  */
 429 static unsigned abbrev_die_table_allocated;
 430
 431 /* Number of elements in type_die_table currently in use.  */
 432 static unsigned abbrev_die_table_in_use;
 433
 434 /* Size (in elements) of increments by which we may expand the
 435    abbrev_die_table.  */
 436 #define ABBREV_DIE_TABLE_INCREMENT 256
 437
 438 /* A pointer to the base of a table that contains line information
 439    for each source code line in .text in the compilation unit.  */
 440 static dw_line_info_ref line_info_table;
 441
 442 /* Number of elements currently allocated for line_info_table.  */
 443 static unsigned line_info_table_allocated;
 444
 445 /* Number of elements in separate_line_info_table currently in use.  */
 446 static unsigned separate_line_info_table_in_use;
 447
 448 /* A pointer to the base of a table that contains line information
 449    for each source code line outside of .text in the compilation unit.  */
 450 static dw_separate_line_info_ref separate_line_info_table;
 451
 452 /* Number of elements currently allocated for separate_line_info_table.  */
 453 static unsigned separate_line_info_table_allocated;
 454
 455 /* Number of elements in line_info_table currently in use.  */
 456 static unsigned line_info_table_in_use;
 457
 458 /* Size (in elements) of increments by which we may expand the
 459    line_info_table.  */
 460 #define LINE_INFO_TABLE_INCREMENT 1024
 461
 462 /* A pointer to the base of a table that contains frame description
 463    information for each routine.  */
 464 static dw_fde_ref fde_table;
 465
 466 /* Number of elements currently allocated for fde_table.  */
 467 static unsigned fde_table_allocated;
 468
 469 /* Number of elements in fde_table currently in use.  */
 470 static unsigned fde_table_in_use;
 471
 472 /* Size (in elements) of increments by which we may expand the
 473    fde_table.  */
 474 #define FDE_TABLE_INCREMENT 256
 475
 476 /* A list of call frame insns for the CIE.  */
 477 static dw_cfi_ref cie_cfi_head;
 478
 479 /* A pointer to the base of a table that contains a list of publicly
 480    accessible names.  */
 481 static pubname_ref pubname_table;
 482
 483 /* Number of elements currently allocated for pubname_table.  */
 484 static unsigned pubname_table_allocated;
 485
 486 /* Number of elements in pubname_table currently in use.  */
 487 static unsigned pubname_table_in_use;
 488
 489 /* Size (in elements) of increments by which we may expand the
 490    pubname_table.  */
 491 #define PUBNAME_TABLE_INCREMENT 64
 492
 493 /* A pointer to the base of a table that contains a list of publicly
 494    accessible names.  */
 495 static arange_ref arange_table;
 496
 497 /* Number of elements currently allocated for arange_table.  */
 498 static unsigned arange_table_allocated;
 499
 500 /* Number of elements in arange_table currently in use.  */
 501 static unsigned arange_table_in_use;
 502
 503 /* Size (in elements) of increments by which we may expand the
 504    arange_table.  */
 505 #define ARANGE_TABLE_INCREMENT 64
 506
 507 /* A pointer to the base of a list of pending types which we haven't
 508    generated DIEs for yet, but which we will have to come back to
 509    later on.  */
 510
 511 static tree *pending_types_list;
 512
 513 /* Number of elements currently allocated for the pending_types_list.  */
 514
 515 static unsigned pending_types_allocated;
 516
 517 /* Number of elements of pending_types_list currently in use.  */
 518
 519 static unsigned pending_types;
 520
 521 /* Size (in elements) of increments by which we may expand the pending
 522    types list.  Actually, a single hunk of space of this size should
 523    be enough for most typical programs.  */
 524
 525 #define PENDING_TYPES_INCREMENT 64
 526
 527 /* The number of the current function definition for which debugging
 528    information is being generated.  These numbers range from 1 up to the
 529    maximum number of function definitions contained within the current
 530    compilation unit.  These numbers are used to create unique label id's
 531    unique to each function definition.  */
 532 static unsigned current_funcdef_number = 1;
 533
 534 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 535    attribute that accelerates the lookup of the FDE associated
 536    with the subprogram.  This variable holds the table index of the FDE
 537    associated with the current function (body) definition.  */
 538 static unsigned current_funcdef_fde;
 539
 540 /* Record whether the function being analyzed contains inlined functions.  */
 541 static int current_function_has_inlines;
 542 static int comp_unit_has_inlines;
 543
 544 /* A pointer to the ..._DECL node which we have most recently been working
 545    on.  We keep this around just in case something about it looks screwy and
 546    we want to tell the user what the source coordinates for the actual
 547    declaration are.  */
 548 static tree dwarf_last_decl;
 549
 550 /* Forward declarations for functions defined in this file.  */
 551 static void gen_type_die ();
 552 static void add_type_attribute ();
 553 static void decls_for_scope ();
 554 static void gen_decl_die ();
 555 static unsigned lookup_filename ();
 556 static int constant_size PROTO((long unsigned));
 557 static enum dwarf_form value_format PROTO((dw_val_ref));
 558 static unsigned reg_number ();
 559
 560 /* Definitions of defaults for assembler-dependent names of various
 561    pseudo-ops and section names.
 562    Theses may be overridden in the tm.h file (if necessary) for a particular
 563    assembler.  */
 564 #ifndef UNALIGNED_SHORT_ASM_OP
 565 #define UNALIGNED_SHORT_ASM_OP  ".2byte"
 566 #endif
 567 #ifndef UNALIGNED_INT_ASM_OP
 568 #define UNALIGNED_INT_ASM_OP    ".4byte"
 569 #endif
 570 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
 571 #define UNALIGNED_DOUBLE_INT_ASM_OP     ".8byte"
 572 #endif
 573 #ifndef ASM_BYTE_OP
 574 #define ASM_BYTE_OP             ".byte"
 575 #endif
 576
 577 #ifndef UNALIGNED_OFFSET_ASM_OP
 578 #define UNALIGNED_OFFSET_ASM_OP \
 579   (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
 580 #endif
 581
 582 #ifndef UNALIGNED_WORD_ASM_OP
 583 #define UNALIGNED_WORD_ASM_OP \
 584   (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
 585 #endif
 586
 587 /* Data and reference forms for relocatable data.  */
 588 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 589 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 590
 591 /* Pseudo-op for defining a new section.  */
 592 #ifndef SECTION_ASM_OP
 593 #define SECTION_ASM_OP  ".section"
 594 #endif
 595
 596 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
 597    print the SECTION_ASM_OP and the section name.  The default here works for
 598    almost all svr4 assemblers, except for the sparc, where the section name
 599    must be enclosed in double quotes.  (See sparcv4.h).  */
 600 #ifndef SECTION_FORMAT
 601 #define SECTION_FORMAT  "\t%s\t%s\n"
 602 #endif
 603
 604 /* Section names used to hold DWARF debugging information.  */
 605 #ifndef DEBUG_SECTION
 606 #define DEBUG_SECTION           ".debug_info"
 607 #endif
 608 #ifndef ABBREV_SECTION
 609 #define ABBREV_SECTION          ".debug_abbrev"
 610 #endif
 611 #ifndef ARANGES_SECTION
 612 #define ARANGES_SECTION         ".debug_aranges"
 613 #endif
 614 #ifndef DW_MACINFO_SECTION
 615 #define DW_MACINFO_SECTION      ".debug_macinfo"
 616 #endif
 617 #ifndef FRAME_SECTION
 618 #define FRAME_SECTION           ".debug_frame"
 619 #endif
 620 #ifndef LINE_SECTION
 621 #define LINE_SECTION            ".debug_line"
 622 #endif
 623 #ifndef LOC_SECTION
 624 #define LOC_SECTION             ".debug_loc"
 625 #endif
 626 #ifndef PUBNAMES_SECTION
 627 #define PUBNAMES_SECTION        ".debug_pubnames"
 628 #endif
 629 #ifndef STR_SECTION
 630 #define STR_SECTION             ".debug_str"
 631 #endif
 632
 633 /* Standerd ELF section names for compiled code and data.  */
 634 #ifndef TEXT_SECTION
 635 #define TEXT_SECTION            ".text"
 636 #endif
 637 #ifndef DATA_SECTION
 638 #define DATA_SECTION            ".data"
 639 #endif
 640 #ifndef BSS_SECTION
 641 #define BSS_SECTION             ".bss"
 642 #endif
 643
 644
 645 /* Definitions of defaults for formats and names of various special
 646    (artificial) labels which may be generated within this file (when the -g
 647    options is used and DWARF_DEBUGGING_INFO is in effect.
 648    If necessary, these may be overridden from within the tm.h file, but
 649    typically, overriding these defaults is unnecessary.  */
 650
 651 char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
 652
 653 #ifndef TEXT_END_LABEL
 654 #define TEXT_END_LABEL          "Letext"
 655 #endif
 656 #ifndef DATA_END_LABEL
 657 #define DATA_END_LABEL          "Ledata"
 658 #endif
 659 #ifndef BSS_END_LABEL
 660 #define BSS_END_LABEL           "Lebss"
 661 #endif
 662 #ifndef INSN_LABEL_FMT
 663 #define INSN_LABEL_FMT          "LI%u_"
 664 #endif
 665 #ifndef BLOCK_BEGIN_LABEL
 666 #define BLOCK_BEGIN_LABEL       "LBB"
 667 #endif
 668 #ifndef BLOCK_END_LABEL
 669 #define BLOCK_END_LABEL         "LBE"
 670 #endif
 671 #ifndef BODY_BEGIN_LABEL
 672 #define BODY_BEGIN_LABEL        "Lbb"
 673 #endif
 674 #ifndef BODY_END_LABEL
 675 #define BODY_END_LABEL          "Lbe"
 676 #endif
 677 #ifndef FUNC_BEGIN_LABEL
 678 #define FUNC_BEGIN_LABEL        "LFB"
 679 #endif
 680 #ifndef FUNC_END_LABEL
 681 #define FUNC_END_LABEL          "LFE"
 682 #endif
 683 #ifndef LINE_CODE_LABEL
 684 #define LINE_CODE_LABEL         "LM"
 685 #endif
 686 #ifndef SEPARATE_LINE_CODE_LABEL
 687 #define SEPARATE_LINE_CODE_LABEL        "LSM"
 688 #endif
 689
 690 /* Definitions of defaults for various types of primitive assembly language
 691    output operations.  These may be overridden from within the tm.h file,
 692    but typically, that is unecessary.  */
 693 #ifndef ASM_OUTPUT_SECTION
 694 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
 695   fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
 696 #endif
 697
 698 #ifndef ASM_OUTPUT_DWARF_DELTA2
 699 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2)                     \
 700  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP);             \
 701         assemble_name (FILE, LABEL1);                                   \
 702         fprintf (FILE, "-");                                            \
 703         assemble_name (FILE, LABEL2);                                   \
 704   } while (0)
 705 #endif
 706
 707 #ifndef ASM_OUTPUT_DWARF_DELTA4
 708 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2)                     \
 709  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP);               \
 710         assemble_name (FILE, LABEL1);                                   \
 711         fprintf (FILE, "-");                                            \
 712         assemble_name (FILE, LABEL2);                                   \
 713   } while (0)
 714 #endif
 715
 716 #ifndef ASM_OUTPUT_DWARF_DELTA
 717 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2)                      \
 718  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP);            \
 719         assemble_name (FILE, LABEL1);                                   \
 720         fprintf (FILE, "-");                                            \
 721         assemble_name (FILE, LABEL2);                                   \
 722   } while (0)
 723 #endif
 724
 725 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
 726 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2)                 \
 727  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP);              \
 728         assemble_name (FILE, LABEL1);                                   \
 729         fprintf (FILE, "-");                                            \
 730         assemble_name (FILE, LABEL2);                                   \
 731   } while (0)
 732 #endif
 733
 734 #ifndef ASM_OUTPUT_DWARF_ADDR
 735 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL)                               \
 736  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP);              \
 737         assemble_name (FILE, LABEL);                                    \
 738   } while (0)
 739 #endif
 740
 741 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
 742 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR)                          \
 743   fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
 744 #endif
 745
 746 #ifndef ASM_OUTPUT_DWARF_OFFSET
 747 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL)                             \
 748  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP);            \
 749         assemble_name (FILE, LABEL);                                    \
 750   } while (0)
 751 #endif
 752
 753 #ifndef ASM_OUTPUT_DWARF_DATA1
 754 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
 755   fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, VALUE)
 756 #endif
 757
 758 #ifndef ASM_OUTPUT_DWARF_DATA2
 759 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
 760   fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE)
 761 #endif
 762
 763 #ifndef ASM_OUTPUT_DWARF_DATA4
 764 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
 765   fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) VALUE)
 766 #endif
 767
 768 #ifndef ASM_OUTPUT_DWARF_DATA
 769 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
 770   fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
 771            (unsigned long) VALUE)
 772 #endif
 773
 774 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
 775 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
 776   fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
 777            (unsigned long) VALUE)
 778 #endif
 779
 780 #ifndef ASM_OUTPUT_DWARF_DATA8
 781 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE)               \
 782   do {                                                                  \
 783     if (WORDS_BIG_ENDIAN)                                               \
 784       {                                                                 \
 785         fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
 786         fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
 787       }                                                                 \
 788     else                                                                \
 789       {                                                                 \
 790         fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
 791         fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
 792       }                                                                 \
 793   } while (0)
 794 #endif
 795
 796 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
 797    newline is produced.  When flag_verbose_asm is asserted, we add commnetary
 798    at the end of the line, so we must avoid output of a newline here.  */
 799 #ifndef ASM_OUTPUT_DWARF_STRING
 800 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
 801   do {                                                                        \
 802     register int slen = strlen(P);                                            \
 803     register char *p = (P);                                                   \
 804     register int i;                                                           \
 805     fprintf (FILE, "\t.ascii \"");                                            \
 806     for (i = 0; i < slen; i++)                                                \
 807       {                                                                       \
 808           register int c = p[i];                                              \
 809           if (c == '\"' || c == '\\')                                         \
 810             putc ('\\', FILE);                                                \
 811           if (c >= ' ' && c < 0177)                                           \
 812             putc (c, FILE);                                                   \
 813           else                                                                \
 814             {                                                                 \
 815               fprintf (FILE, "\\%o", c);                                      \
 816             }                                                                 \
 817       }                                                                       \
 818     fprintf (FILE, "\\0\"");                                                  \
 819   }                                                                           \
 820   while (0)
 821 #endif
 822
 823 /* Convert a reference to the assembler name of a C-level name.  This
 824    macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
 825    a string rather than writing to a file.  */
 826 #ifndef ASM_NAME_TO_STRING
 827 #define ASM_NAME_TO_STRING(STR, NAME) \
 828   do {                                                                        \
 829       if ((NAME)[0] == '*')                                                   \
 830         strcpy (STR, NAME+1);                                                 \
 831       else                                                                    \
 832         strcpy (STR, NAME);                                                   \
 833   }                                                                           \
 834   while (0)
 835 #endif
 836
 837 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 838    is the column for PC, or the first column after all of the hard
 839    registers.  */
 840 #ifndef DWARF_FRAME_RETURN_COLUMN
 841 #ifdef PC_REGNUM
 842 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 843 #else
 844 #define DWARF_FRAME_RETURN_COLUMN       FIRST_PSEUDO_REGISTER + 1
 845 #endif
 846 #endif
 847
 848 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 849    default, we just provide columns for all registers.  */
 850 #ifndef DWARF_FRAME_REGNUM
 851 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 852 #endif
 853 \f
 854 /************************ general utility functions **************************/
 855
 856 /* Return a pointer to a copy of the section string name 's' with all
 857    attributes stripped off.  */
 858 inline char *
 859 stripattributes (s)
 860      register char *s;
 861 {
 862   register char *stripped, *p;
 863   stripped = xstrdup (s);
 864   p = stripped;
 865   while (*p && *p != ',')
 866     p++;
 867   *p = '\0';
 868   return stripped;
 869 }
 870
 871 /* Convert an integer constant expression into assembler syntax.
 872    Addition and subtraction are the only arithmetic
 873    that may appear in these expressions.   This is an adaptation
 874    of output_addr_const() in final.c.   Here, the target of the
 875    conversion is a string buffer.  We can't use output_addr_const
 876    directly, because it writes to a file.  */
 877 static void
 878 addr_const_to_string (str, x)
 879      char *str;
 880      rtx x;
 881 {
 882   char buf1[256];
 883   char buf2[256];
 884
 885 restart:
 886   str[0] = '\0';
 887   switch (GET_CODE (x))
 888     {
 889     case PC:
 890       if (flag_pic)
 891         strcat (str, ",");
 892       else
 893         abort ();
 894       break;
 895
 896     case SYMBOL_REF:
 897       ASM_NAME_TO_STRING (buf1, XSTR (x, 0));
 898       strcat (str, buf1);
 899       break;
 900
 901     case LABEL_REF:
 902       ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
 903       ASM_NAME_TO_STRING (buf2, buf1);
 904       strcat (str, buf2);
 905       break;
 906
 907     case CODE_LABEL:
 908       ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
 909       ASM_NAME_TO_STRING (buf2, buf1);
 910       strcat (str, buf2);
 911       break;
 912
 913     case CONST_INT:
 914       sprintf (buf1,
 915 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
 916                "%d",
 917 #else
 918                "%ld",
 919 #endif
 920                INTVAL (x));
 921       strcat (str, buf1);
 922       break;
 923
 924     case CONST:
 925       /* This used to output parentheses around the expression, but that does
 926          not work on the 386 (either ATT or BSD assembler).  */
 927       addr_const_to_string (buf1, XEXP (x, 0));
 928       strcat (str, buf1);
 929       break;
 930
 931     case CONST_DOUBLE:
 932       if (GET_MODE (x) == VOIDmode)
 933         {
 934           /* We can use %d if the number is one word and positive.  */
 935           if (CONST_DOUBLE_HIGH (x))
 936             sprintf (buf1,
 937 #if HOST_BITS_PER_WIDE_INT == 64
 938 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
 939                      "0x%lx%016lx",
 940 #else
 941                      "0x%x%016x",
 942 #endif
 943 #else
 944 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
 945                      "0x%lx%08lx",
 946 #else
 947                      "0x%x%08x",
 948 #endif
 949 #endif
 950                      CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
 951           else if (CONST_DOUBLE_LOW (x) < 0)
 952             sprintf (buf1,
 953 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
 954                      "0x%x",
 955 #else
 956                      "0x%lx",
 957 #endif
 958                      CONST_DOUBLE_LOW (x));
 959           else
 960             sprintf (buf1,
 961 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
 962                      "%d",
 963 #else
 964                      "%ld",
 965 #endif
 966                      CONST_DOUBLE_LOW (x));
 967           strcat (str, buf1);
 968         }
 969       else
 970         /* We can't handle floating point constants; PRINT_OPERAND must
 971            handle them.  */
 972         output_operand_lossage ("floating constant misused");
 973       break;
 974
 975     case PLUS:
 976       /* Some assemblers need integer constants to appear last (eg masm).  */
 977       if (GET_CODE (XEXP (x, 0)) == CONST_INT)
 978         {
 979           addr_const_to_string (buf1, XEXP (x, 1));
 980           strcat (str, buf1);
 981           if (INTVAL (XEXP (x, 0)) >= 0)
 982             strcat (str, "+");
 983           addr_const_to_string (buf1, XEXP (x, 0));
 984           strcat (str, buf1);
 985         }
 986       else
 987         {
 988           addr_const_to_string (buf1, XEXP (x, 0));
 989           strcat (str, buf1);
 990           if (INTVAL (XEXP (x, 1)) >= 0)
 991             strcat (str, "+");
 992           addr_const_to_string (buf1, XEXP (x, 1));
 993           strcat (str, buf1);
 994         }
 995       break;
 996
 997     case MINUS:
 998       /* Avoid outputting things like x-x or x+5-x, since some assemblers
 999          can't handle that.  */
1000       x = simplify_subtraction (x);
1001       if (GET_CODE (x) != MINUS)
1002         goto restart;
1003
1004       addr_const_to_string (buf1, XEXP (x, 0));
1005       strcat (str, buf1);
1006       strcat (str, "-");
1007       if (GET_CODE (XEXP (x, 1)) == CONST_INT
1008           && INTVAL (XEXP (x, 1)) < 0)
1009         {
1010           strcat (str, ASM_OPEN_PAREN);
1011           addr_const_to_string (buf1, XEXP (x, 1));
1012           strcat (str, buf1);
1013           strcat (str, ASM_CLOSE_PAREN);
1014         }
1015       else
1016         {
1017           addr_const_to_string (buf1, XEXP (x, 1));
1018           strcat (str, buf1);
1019         }
1020       break;
1021
1022     case ZERO_EXTEND:
1023     case SIGN_EXTEND:
1024       addr_const_to_string (buf1, XEXP (x, 0));
1025       strcat (str, buf1);
1026       break;
1027
1028     default:
1029       output_operand_lossage ("invalid expression as operand");
1030     }
1031 }
1032
1033 /* Convert an address constant to a string, and return a pointer to
1034    a copy of the result, located on the heap.  */
1035 static char *
1036 addr_to_string (x)
1037      rtx x;
1038 {
1039   char buf[1024];
1040   addr_const_to_string (buf, x);
1041   return xstrdup (buf);
1042 }
1043
1044 /* Test if rtl node points to a psuedo register.  */
1045 inline int
1046 is_pseudo_reg (rtl)
1047      register rtx rtl;
1048 {
1049   return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
1050           || ((GET_CODE (rtl) == SUBREG)
1051               && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
1052 }
1053
1054
1055 /* Return a reference to a type, with its const and volatile qualifiers
1056    removed.  */
1057 inline tree
1058 type_main_variant (type)
1059      register tree type;
1060 {
1061   type = TYPE_MAIN_VARIANT (type);
1062
1063   /* There really should be only one main variant among any group of variants
1064      of a given type (and all of the MAIN_VARIANT values for all members of
1065      the group should point to that one type) but sometimes the C front-end
1066      messes this up for array types, so we work around that bug here.  */
1067   if (TREE_CODE (type) == ARRAY_TYPE)
1068     {
1069       while (type != TYPE_MAIN_VARIANT (type))
1070         type = TYPE_MAIN_VARIANT (type);
1071     }
1072   return type;
1073 }
1074
1075 /* Return non-zero if the given type node represents a tagged type.  */
1076 inline int
1077 is_tagged_type (type)
1078      register tree type;
1079 {
1080   register enum tree_code code = TREE_CODE (type);
1081
1082   return (code == RECORD_TYPE || code == UNION_TYPE
1083           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
1084 }
1085
1086 /* Convert a DIE tag into its string name.  */
1087 static char *
1088 dwarf_tag_name (tag)
1089      register unsigned tag;
1090 {
1091   switch (tag)
1092     {
1093     case DW_TAG_padding:
1094       return "DW_TAG_padding";
1095     case DW_TAG_array_type:
1096       return "DW_TAG_array_type";
1097     case DW_TAG_class_type:
1098       return "DW_TAG_class_type";
1099     case DW_TAG_entry_point:
1100       return "DW_TAG_entry_point";
1101     case DW_TAG_enumeration_type:
1102       return "DW_TAG_enumeration_type";
1103     case DW_TAG_formal_parameter:
1104       return "DW_TAG_formal_parameter";
1105     case DW_TAG_imported_declaration:
1106       return "DW_TAG_imported_declaration";
1107     case DW_TAG_label:
1108       return "DW_TAG_label";
1109     case DW_TAG_lexical_block:
1110       return "DW_TAG_lexical_block";
1111     case DW_TAG_member:
1112       return "DW_TAG_member";
1113     case DW_TAG_pointer_type:
1114       return "DW_TAG_pointer_type";
1115     case DW_TAG_reference_type:
1116       return "DW_TAG_reference_type";
1117     case DW_TAG_compile_unit:
1118       return "DW_TAG_compile_unit";
1119     case DW_TAG_string_type:
1120       return "DW_TAG_string_type";
1121     case DW_TAG_structure_type:
1122       return "DW_TAG_structure_type";
1123     case DW_TAG_subroutine_type:
1124       return "DW_TAG_subroutine_type";
1125     case DW_TAG_typedef:
1126       return "DW_TAG_typedef";
1127     case DW_TAG_union_type:
1128       return "DW_TAG_union_type";
1129     case DW_TAG_unspecified_parameters:
1130       return "DW_TAG_unspecified_parameters";
1131     case DW_TAG_variant:
1132       return "DW_TAG_variant";
1133     case DW_TAG_common_block:
1134       return "DW_TAG_common_block";
1135     case DW_TAG_common_inclusion:
1136       return "DW_TAG_common_inclusion";
1137     case DW_TAG_inheritance:
1138       return "DW_TAG_inheritance";
1139     case DW_TAG_inlined_subroutine:
1140       return "DW_TAG_inlined_subroutine";
1141     case DW_TAG_module:
1142       return "DW_TAG_module";
1143     case DW_TAG_ptr_to_member_type:
1144       return "DW_TAG_ptr_to_member_type";
1145     case DW_TAG_set_type:
1146       return "DW_TAG_set_type";
1147     case DW_TAG_subrange_type:
1148       return "DW_TAG_subrange_type";
1149     case DW_TAG_with_stmt:
1150       return "DW_TAG_with_stmt";
1151     case DW_TAG_access_declaration:
1152       return "DW_TAG_access_declaration";
1153     case DW_TAG_base_type:
1154       return "DW_TAG_base_type";
1155     case DW_TAG_catch_block:
1156       return "DW_TAG_catch_block";
1157     case DW_TAG_const_type:
1158       return "DW_TAG_const_type";
1159     case DW_TAG_constant:
1160       return "DW_TAG_constant";
1161     case DW_TAG_enumerator:
1162       return "DW_TAG_enumerator";
1163     case DW_TAG_file_type:
1164       return "DW_TAG_file_type";
1165     case DW_TAG_friend:
1166       return "DW_TAG_friend";
1167     case DW_TAG_namelist:
1168       return "DW_TAG_namelist";
1169     case DW_TAG_namelist_item:
1170       return "DW_TAG_namelist_item";
1171     case DW_TAG_packed_type:
1172       return "DW_TAG_packed_type";
1173     case DW_TAG_subprogram:
1174       return "DW_TAG_subprogram";
1175     case DW_TAG_template_type_param:
1176       return "DW_TAG_template_type_param";
1177     case DW_TAG_template_value_param:
1178       return "DW_TAG_template_value_param";
1179     case DW_TAG_thrown_type:
1180       return "DW_TAG_thrown_type";
1181     case DW_TAG_try_block:
1182       return "DW_TAG_try_block";
1183     case DW_TAG_variant_part:
1184       return "DW_TAG_variant_part";
1185     case DW_TAG_variable:
1186       return "DW_TAG_variable";
1187     case DW_TAG_volatile_type:
1188       return "DW_TAG_volatile_type";
1189     case DW_TAG_MIPS_loop:
1190       return "DW_TAG_MIPS_loop";
1191     case DW_TAG_format_label:
1192       return "DW_TAG_format_label";
1193     case DW_TAG_function_template:
1194       return "DW_TAG_function_template";
1195     case DW_TAG_class_template:
1196       return "DW_TAG_class_template";
1197     default:
1198       return "DW_TAG_<unknown>";
1199     }
1200 }
1201
1202 /* Convert a DWARF attribute code into its string name.  */
1203 static char *
1204 dwarf_attr_name (attr)
1205      register unsigned attr;
1206 {
1207   switch (attr)
1208     {
1209     case DW_AT_sibling:
1210       return "DW_AT_sibling";
1211     case DW_AT_location:
1212       return "DW_AT_location";
1213     case DW_AT_name:
1214       return "DW_AT_name";
1215     case DW_AT_ordering:
1216       return "DW_AT_ordering";
1217     case DW_AT_subscr_data:
1218       return "DW_AT_subscr_data";
1219     case DW_AT_byte_size:
1220       return "DW_AT_byte_size";
1221     case DW_AT_bit_offset:
1222       return "DW_AT_bit_offset";
1223     case DW_AT_bit_size:
1224       return "DW_AT_bit_size";
1225     case DW_AT_element_list:
1226       return "DW_AT_element_list";
1227     case DW_AT_stmt_list:
1228       return "DW_AT_stmt_list";
1229     case DW_AT_low_pc:
1230       return "DW_AT_low_pc";
1231     case DW_AT_high_pc:
1232       return "DW_AT_high_pc";
1233     case DW_AT_language:
1234       return "DW_AT_language";
1235     case DW_AT_member:
1236       return "DW_AT_member";
1237     case DW_AT_discr:
1238       return "DW_AT_discr";
1239     case DW_AT_discr_value:
1240       return "DW_AT_discr_value";
1241     case DW_AT_visibility:
1242       return "DW_AT_visibility";
1243     case DW_AT_import:
1244       return "DW_AT_import";
1245     case DW_AT_string_length:
1246       return "DW_AT_string_length";
1247     case DW_AT_common_reference:
1248       return "DW_AT_common_reference";
1249     case DW_AT_comp_dir:
1250       return "DW_AT_comp_dir";
1251     case DW_AT_const_value:
1252       return "DW_AT_const_value";
1253     case DW_AT_containing_type:
1254       return "DW_AT_containing_type";
1255     case DW_AT_default_value:
1256       return "DW_AT_default_value";
1257     case DW_AT_inline:
1258       return "DW_AT_inline";
1259     case DW_AT_is_optional:
1260       return "DW_AT_is_optional";
1261     case DW_AT_lower_bound:
1262       return "DW_AT_lower_bound";
1263     case DW_AT_producer:
1264       return "DW_AT_producer";
1265     case DW_AT_prototyped:
1266       return "DW_AT_prototyped";
1267     case DW_AT_return_addr:
1268       return "DW_AT_return_addr";
1269     case DW_AT_start_scope:
1270       return "DW_AT_start_scope";
1271     case DW_AT_stride_size:
1272       return "DW_AT_stride_size";
1273     case DW_AT_upper_bound:
1274       return "DW_AT_upper_bound";
1275     case DW_AT_abstract_origin:
1276       return "DW_AT_abstract_origin";
1277     case DW_AT_accessibility:
1278       return "DW_AT_accessibility";
1279     case DW_AT_address_class:
1280       return "DW_AT_address_class";
1281     case DW_AT_artificial:
1282       return "DW_AT_artificial";
1283     case DW_AT_base_types:
1284       return "DW_AT_base_types";
1285     case DW_AT_calling_convention:
1286       return "DW_AT_calling_convention";
1287     case DW_AT_count:
1288       return "DW_AT_count";
1289     case DW_AT_data_member_location:
1290       return "DW_AT_data_member_location";
1291     case DW_AT_decl_column:
1292       return "DW_AT_decl_column";
1293     case DW_AT_decl_file:
1294       return "DW_AT_decl_file";
1295     case DW_AT_decl_line:
1296       return "DW_AT_decl_line";
1297     case DW_AT_declaration:
1298       return "DW_AT_declaration";
1299     case DW_AT_discr_list:
1300       return "DW_AT_discr_list";
1301     case DW_AT_encoding:
1302       return "DW_AT_encoding";
1303     case DW_AT_external:
1304       return "DW_AT_external";
1305     case DW_AT_frame_base:
1306       return "DW_AT_frame_base";
1307     case DW_AT_friend:
1308       return "DW_AT_friend";
1309     case DW_AT_identifier_case:
1310       return "DW_AT_identifier_case";
1311     case DW_AT_macro_info:
1312       return "DW_AT_macro_info";
1313     case DW_AT_namelist_items:
1314       return "DW_AT_namelist_items";
1315     case DW_AT_priority:
1316       return "DW_AT_priority";
1317     case DW_AT_segment:
1318       return "DW_AT_segment";
1319     case DW_AT_specification:
1320       return "DW_AT_specification";
1321     case DW_AT_static_link:
1322       return "DW_AT_static_link";
1323     case DW_AT_type:
1324       return "DW_AT_type";
1325     case DW_AT_use_location:
1326       return "DW_AT_use_location";
1327     case DW_AT_variable_parameter:
1328       return "DW_AT_variable_parameter";
1329     case DW_AT_virtuality:
1330       return "DW_AT_virtuality";
1331     case DW_AT_vtable_elem_location:
1332       return "DW_AT_vtable_elem_location";
1333
1334     case DW_AT_MIPS_fde:
1335       return "DW_AT_MIPS_fde";
1336     case DW_AT_MIPS_loop_begin:
1337       return "DW_AT_MIPS_loop_begin";
1338     case DW_AT_MIPS_tail_loop_begin:
1339       return "DW_AT_MIPS_tail_loop_begin";
1340     case DW_AT_MIPS_epilog_begin:
1341       return "DW_AT_MIPS_epilog_begin";
1342     case DW_AT_MIPS_loop_unroll_factor:
1343       return "DW_AT_MIPS_loop_unroll_factor";
1344     case DW_AT_MIPS_software_pipeline_depth:
1345       return "DW_AT_MIPS_software_pipeline_depth";
1346     case DW_AT_MIPS_linkage_name:
1347       return "DW_AT_MIPS_linkage_name";
1348     case DW_AT_MIPS_stride:
1349       return "DW_AT_MIPS_stride";
1350     case DW_AT_MIPS_abstract_name:
1351       return "DW_AT_MIPS_abstract_name";
1352     case DW_AT_MIPS_clone_origin:
1353       return "DW_AT_MIPS_clone_origin";
1354     case DW_AT_MIPS_has_inlines:
1355       return "DW_AT_MIPS_has_inlines";
1356
1357     case DW_AT_sf_names:
1358       return "DW_AT_sf_names";
1359     case DW_AT_src_info:
1360       return "DW_AT_src_info";
1361     case DW_AT_mac_info:
1362       return "DW_AT_mac_info";
1363     case DW_AT_src_coords:
1364       return "DW_AT_src_coords";
1365     case DW_AT_body_begin:
1366       return "DW_AT_body_begin";
1367     case DW_AT_body_end:
1368       return "DW_AT_body_end";
1369     default:
1370       return "DW_AT_<unknown>";
1371     }
1372 }
1373
1374 /* Convert a DWARF value form code into its string name.  */
1375 static char *
1376 dwarf_form_name (form)
1377      register unsigned form;
1378 {
1379   switch (form)
1380     {
1381     case DW_FORM_addr:
1382       return "DW_FORM_addr";
1383     case DW_FORM_block2:
1384       return "DW_FORM_block2";
1385     case DW_FORM_block4:
1386       return "DW_FORM_block4";
1387     case DW_FORM_data2:
1388       return "DW_FORM_data2";
1389     case DW_FORM_data4:
1390       return "DW_FORM_data4";
1391     case DW_FORM_data8:
1392       return "DW_FORM_data8";
1393     case DW_FORM_string:
1394       return "DW_FORM_string";
1395     case DW_FORM_block:
1396       return "DW_FORM_block";
1397     case DW_FORM_block1:
1398       return "DW_FORM_block1";
1399     case DW_FORM_data1:
1400       return "DW_FORM_data1";
1401     case DW_FORM_flag:
1402       return "DW_FORM_flag";
1403     case DW_FORM_sdata:
1404       return "DW_FORM_sdata";
1405     case DW_FORM_strp:
1406       return "DW_FORM_strp";
1407     case DW_FORM_udata:
1408       return "DW_FORM_udata";
1409     case DW_FORM_ref_addr:
1410       return "DW_FORM_ref_addr";
1411     case DW_FORM_ref1:
1412       return "DW_FORM_ref1";
1413     case DW_FORM_ref2:
1414       return "DW_FORM_ref2";
1415     case DW_FORM_ref4:
1416       return "DW_FORM_ref4";
1417     case DW_FORM_ref8:
1418       return "DW_FORM_ref8";
1419     case DW_FORM_ref_udata:
1420       return "DW_FORM_ref_udata";
1421     case DW_FORM_indirect:
1422       return "DW_FORM_indirect";
1423     default:
1424       return "DW_FORM_<unknown>";
1425     }
1426 }
1427
1428 /* Convert a DWARF stack opcode into its string name.  */
1429 static char *
1430 dwarf_stack_op_name (op)
1431      register unsigned op;
1432 {
1433   switch (op)
1434     {
1435     case DW_OP_addr:
1436       return "DW_OP_addr";
1437     case DW_OP_deref:
1438       return "DW_OP_deref";
1439     case DW_OP_const1u:
1440       return "DW_OP_const1u";
1441     case DW_OP_const1s:
1442       return "DW_OP_const1s";
1443     case DW_OP_const2u:
1444       return "DW_OP_const2u";
1445     case DW_OP_const2s:
1446       return "DW_OP_const2s";
1447     case DW_OP_const4u:
1448       return "DW_OP_const4u";
1449     case DW_OP_const4s:
1450       return "DW_OP_const4s";
1451     case DW_OP_const8u:
1452       return "DW_OP_const8u";
1453     case DW_OP_const8s:
1454       return "DW_OP_const8s";
1455     case DW_OP_constu:
1456       return "DW_OP_constu";
1457     case DW_OP_consts:
1458       return "DW_OP_consts";
1459     case DW_OP_dup:
1460       return "DW_OP_dup";
1461     case DW_OP_drop:
1462       return "DW_OP_drop";
1463     case DW_OP_over:
1464       return "DW_OP_over";
1465     case DW_OP_pick:
1466       return "DW_OP_pick";
1467     case DW_OP_swap:
1468       return "DW_OP_swap";
1469     case DW_OP_rot:
1470       return "DW_OP_rot";
1471     case DW_OP_xderef:
1472       return "DW_OP_xderef";
1473     case DW_OP_abs:
1474       return "DW_OP_abs";
1475     case DW_OP_and:
1476       return "DW_OP_and";
1477     case DW_OP_div:
1478       return "DW_OP_div";
1479     case DW_OP_minus:
1480       return "DW_OP_minus";
1481     case DW_OP_mod:
1482       return "DW_OP_mod";
1483     case DW_OP_mul:
1484       return "DW_OP_mul";
1485     case DW_OP_neg:
1486       return "DW_OP_neg";
1487     case DW_OP_not:
1488       return "DW_OP_not";
1489     case DW_OP_or:
1490       return "DW_OP_or";
1491     case DW_OP_plus:
1492       return "DW_OP_plus";
1493     case DW_OP_plus_uconst:
1494       return "DW_OP_plus_uconst";
1495     case DW_OP_shl:
1496       return "DW_OP_shl";
1497     case DW_OP_shr:
1498       return "DW_OP_shr";
1499     case DW_OP_shra:
1500       return "DW_OP_shra";
1501     case DW_OP_xor:
1502       return "DW_OP_xor";
1503     case DW_OP_bra:
1504       return "DW_OP_bra";
1505     case DW_OP_eq:
1506       return "DW_OP_eq";
1507     case DW_OP_ge:
1508       return "DW_OP_ge";
1509     case DW_OP_gt:
1510       return "DW_OP_gt";
1511     case DW_OP_le:
1512       return "DW_OP_le";
1513     case DW_OP_lt:
1514       return "DW_OP_lt";
1515     case DW_OP_ne:
1516       return "DW_OP_ne";
1517     case DW_OP_skip:
1518       return "DW_OP_skip";
1519     case DW_OP_lit0:
1520       return "DW_OP_lit0";
1521     case DW_OP_lit1:
1522       return "DW_OP_lit1";
1523     case DW_OP_lit2:
1524       return "DW_OP_lit2";
1525     case DW_OP_lit3:
1526       return "DW_OP_lit3";
1527     case DW_OP_lit4:
1528       return "DW_OP_lit4";
1529     case DW_OP_lit5:
1530       return "DW_OP_lit5";
1531     case DW_OP_lit6:
1532       return "DW_OP_lit6";
1533     case DW_OP_lit7:
1534       return "DW_OP_lit7";
1535     case DW_OP_lit8:
1536       return "DW_OP_lit8";
1537     case DW_OP_lit9:
1538       return "DW_OP_lit9";
1539     case DW_OP_lit10:
1540       return "DW_OP_lit10";
1541     case DW_OP_lit11:
1542       return "DW_OP_lit11";
1543     case DW_OP_lit12:
1544       return "DW_OP_lit12";
1545     case DW_OP_lit13:
1546       return "DW_OP_lit13";
1547     case DW_OP_lit14:
1548       return "DW_OP_lit14";
1549     case DW_OP_lit15:
1550       return "DW_OP_lit15";
1551     case DW_OP_lit16:
1552       return "DW_OP_lit16";
1553     case DW_OP_lit17:
1554       return "DW_OP_lit17";
1555     case DW_OP_lit18:
1556       return "DW_OP_lit18";
1557     case DW_OP_lit19:
1558       return "DW_OP_lit19";
1559     case DW_OP_lit20:
1560       return "DW_OP_lit20";
1561     case DW_OP_lit21:
1562       return "DW_OP_lit21";
1563     case DW_OP_lit22:
1564       return "DW_OP_lit22";
1565     case DW_OP_lit23:
1566       return "DW_OP_lit23";
1567     case DW_OP_lit24:
1568       return "DW_OP_lit24";
1569     case DW_OP_lit25:
1570       return "DW_OP_lit25";
1571     case DW_OP_lit26:
1572       return "DW_OP_lit26";
1573     case DW_OP_lit27:
1574       return "DW_OP_lit27";
1575     case DW_OP_lit28:
1576       return "DW_OP_lit28";
1577     case DW_OP_lit29:
1578       return "DW_OP_lit29";
1579     case DW_OP_lit30:
1580       return "DW_OP_lit30";
1581     case DW_OP_lit31:
1582       return "DW_OP_lit31";
1583     case DW_OP_reg0:
1584       return "DW_OP_reg0";
1585     case DW_OP_reg1:
1586       return "DW_OP_reg1";
1587     case DW_OP_reg2:
1588       return "DW_OP_reg2";
1589     case DW_OP_reg3:
1590       return "DW_OP_reg3";
1591     case DW_OP_reg4:
1592       return "DW_OP_reg4";
1593     case DW_OP_reg5:
1594       return "DW_OP_reg5";
1595     case DW_OP_reg6:
1596       return "DW_OP_reg6";
1597     case DW_OP_reg7:
1598       return "DW_OP_reg7";
1599     case DW_OP_reg8:
1600       return "DW_OP_reg8";
1601     case DW_OP_reg9:
1602       return "DW_OP_reg9";
1603     case DW_OP_reg10:
1604       return "DW_OP_reg10";
1605     case DW_OP_reg11:
1606       return "DW_OP_reg11";
1607     case DW_OP_reg12:
1608       return "DW_OP_reg12";
1609     case DW_OP_reg13:
1610       return "DW_OP_reg13";
1611     case DW_OP_reg14:
1612       return "DW_OP_reg14";
1613     case DW_OP_reg15:
1614       return "DW_OP_reg15";
1615     case DW_OP_reg16:
1616       return "DW_OP_reg16";
1617     case DW_OP_reg17:
1618       return "DW_OP_reg17";
1619     case DW_OP_reg18:
1620       return "DW_OP_reg18";
1621     case DW_OP_reg19:
1622       return "DW_OP_reg19";
1623     case DW_OP_reg20:
1624       return "DW_OP_reg20";
1625     case DW_OP_reg21:
1626       return "DW_OP_reg21";
1627     case DW_OP_reg22:
1628       return "DW_OP_reg22";
1629     case DW_OP_reg23:
1630       return "DW_OP_reg23";
1631     case DW_OP_reg24:
1632       return "DW_OP_reg24";
1633     case DW_OP_reg25:
1634       return "DW_OP_reg25";
1635     case DW_OP_reg26:
1636       return "DW_OP_reg26";
1637     case DW_OP_reg27:
1638       return "DW_OP_reg27";
1639     case DW_OP_reg28:
1640       return "DW_OP_reg28";
1641     case DW_OP_reg29:
1642       return "DW_OP_reg29";
1643     case DW_OP_reg30:
1644       return "DW_OP_reg30";
1645     case DW_OP_reg31:
1646       return "DW_OP_reg31";
1647     case DW_OP_breg0:
1648       return "DW_OP_breg0";
1649     case DW_OP_breg1:
1650       return "DW_OP_breg1";
1651     case DW_OP_breg2:
1652       return "DW_OP_breg2";
1653     case DW_OP_breg3:
1654       return "DW_OP_breg3";
1655     case DW_OP_breg4:
1656       return "DW_OP_breg4";
1657     case DW_OP_breg5:
1658       return "DW_OP_breg5";
1659     case DW_OP_breg6:
1660       return "DW_OP_breg6";
1661     case DW_OP_breg7:
1662       return "DW_OP_breg7";
1663     case DW_OP_breg8:
1664       return "DW_OP_breg8";
1665     case DW_OP_breg9:
1666       return "DW_OP_breg9";
1667     case DW_OP_breg10:
1668       return "DW_OP_breg10";
1669     case DW_OP_breg11:
1670       return "DW_OP_breg11";
1671     case DW_OP_breg12:
1672       return "DW_OP_breg12";
1673     case DW_OP_breg13:
1674       return "DW_OP_breg13";
1675     case DW_OP_breg14:
1676       return "DW_OP_breg14";
1677     case DW_OP_breg15:
1678       return "DW_OP_breg15";
1679     case DW_OP_breg16:
1680       return "DW_OP_breg16";
1681     case DW_OP_breg17:
1682       return "DW_OP_breg17";
1683     case DW_OP_breg18:
1684       return "DW_OP_breg18";
1685     case DW_OP_breg19:
1686       return "DW_OP_breg19";
1687     case DW_OP_breg20:
1688       return "DW_OP_breg20";
1689     case DW_OP_breg21:
1690       return "DW_OP_breg21";
1691     case DW_OP_breg22:
1692       return "DW_OP_breg22";
1693     case DW_OP_breg23:
1694       return "DW_OP_breg23";
1695     case DW_OP_breg24:
1696       return "DW_OP_breg24";
1697     case DW_OP_breg25:
1698       return "DW_OP_breg25";
1699     case DW_OP_breg26:
1700       return "DW_OP_breg26";
1701     case DW_OP_breg27:
1702       return "DW_OP_breg27";
1703     case DW_OP_breg28:
1704       return "DW_OP_breg28";
1705     case DW_OP_breg29:
1706       return "DW_OP_breg29";
1707     case DW_OP_breg30:
1708       return "DW_OP_breg30";
1709     case DW_OP_breg31:
1710       return "DW_OP_breg31";
1711     case DW_OP_regx:
1712       return "DW_OP_regx";
1713     case DW_OP_fbreg:
1714       return "DW_OP_fbreg";
1715     case DW_OP_bregx:
1716       return "DW_OP_bregx";
1717     case DW_OP_piece:
1718       return "DW_OP_piece";
1719     case DW_OP_deref_size:
1720       return "DW_OP_deref_size";
1721     case DW_OP_xderef_size:
1722       return "DW_OP_xderef_size";
1723     case DW_OP_nop:
1724       return "DW_OP_nop";
1725     default:
1726       return "OP_<unknown>";
1727     }
1728 }
1729
1730 /* Convert a DWARF type code into its string name.  */
1731 static char *
1732 dwarf_type_encoding_name (enc)
1733      register unsigned enc;
1734 {
1735   switch (enc)
1736     {
1737     case DW_ATE_address:
1738       return "DW_ATE_address";
1739     case DW_ATE_boolean:
1740       return "DW_ATE_boolean";
1741     case DW_ATE_complex_float:
1742       return "DW_ATE_complex_float";
1743     case DW_ATE_float:
1744       return "DW_ATE_float";
1745     case DW_ATE_signed:
1746       return "DW_ATE_signed";
1747     case DW_ATE_signed_char:
1748       return "DW_ATE_signed_char";
1749     case DW_ATE_unsigned:
1750       return "DW_ATE_unsigned";
1751     case DW_ATE_unsigned_char:
1752       return "DW_ATE_unsigned_char";
1753     default:
1754       return "DW_ATE_<unknown>";
1755     }
1756 }
1757
1758 /* Convert a DWARF call frame info. operation to its string name */
1759 static char *
1760 dwarf_cfi_name (cfi_opc)
1761      register unsigned cfi_opc;
1762 {
1763   switch (cfi_opc)
1764     {
1765     case DW_CFA_advance_loc:
1766       return "DW_CFA_advance_loc";
1767     case DW_CFA_offset:
1768       return "DW_CFA_offset";
1769     case DW_CFA_restore:
1770       return "DW_CFA_restore";
1771     case DW_CFA_nop:
1772       return "DW_CFA_nop";
1773     case DW_CFA_set_loc:
1774       return "DW_CFA_set_loc";
1775     case DW_CFA_advance_loc1:
1776       return "DW_CFA_advance_loc1";
1777     case DW_CFA_advance_loc2:
1778       return "DW_CFA_advance_loc2";
1779     case DW_CFA_advance_loc4:
1780       return "DW_CFA_advance_loc4";
1781     case DW_CFA_offset_extended:
1782       return "DW_CFA_offset_extended";
1783     case DW_CFA_restore_extended:
1784       return "DW_CFA_restore_extended";
1785     case DW_CFA_undefined:
1786       return "DW_CFA_undefined";
1787     case DW_CFA_same_value:
1788       return "DW_CFA_same_value";
1789     case DW_CFA_register:
1790       return "DW_CFA_register";
1791     case DW_CFA_remember_state:
1792       return "DW_CFA_remember_state";
1793     case DW_CFA_restore_state:
1794       return "DW_CFA_restore_state";
1795     case DW_CFA_def_cfa:
1796       return "DW_CFA_def_cfa";
1797     case DW_CFA_def_cfa_register:
1798       return "DW_CFA_def_cfa_register";
1799     case DW_CFA_def_cfa_offset:
1800       return "DW_CFA_def_cfa_offset";
1801     /* SGI/MIPS specific */
1802     case DW_CFA_MIPS_advance_loc8:
1803       return "DW_CFA_MIPS_advance_loc8";
1804     default:
1805       return "DW_CFA_<unknown>";
1806     }
1807 }
1808 \f
1809 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
1810    instance of an inlined instance of a decl which is local to an inline
1811    function, so we have to trace all of the way back through the origin chain
1812    to find out what sort of node actually served as the original seed for the
1813    given block.  */
1814 static tree
1815 decl_ultimate_origin (decl)
1816      register tree decl;
1817 {
1818   register tree immediate_origin = DECL_ABSTRACT_ORIGIN (decl);
1819
1820   if (immediate_origin == NULL)
1821     return NULL;
1822   else
1823     {
1824       register tree ret_val;
1825       register tree lookahead = immediate_origin;
1826
1827       do
1828         {
1829           ret_val = lookahead;
1830           lookahead = DECL_ABSTRACT_ORIGIN (ret_val);
1831         }
1832       while (lookahead != NULL && lookahead != ret_val);
1833       return ret_val;
1834     }
1835 }
1836
1837 /* Determine the "ultimate origin" of a block.  The block may be an inlined
1838    instance of an inlined instance of a block which is local to an inline
1839    function, so we have to trace all of the way back through the origin chain
1840    to find out what sort of node actually served as the original seed for the
1841    given block.  */
1842 static tree
1843 block_ultimate_origin (block)
1844      register tree block;
1845 {
1846   register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
1847
1848   if (immediate_origin == NULL)
1849     return NULL;
1850   else
1851     {
1852       register tree ret_val;
1853       register tree lookahead = immediate_origin;
1854
1855       do
1856         {
1857           ret_val = lookahead;
1858           lookahead = (TREE_CODE (ret_val) == BLOCK)
1859             ? BLOCK_ABSTRACT_ORIGIN (ret_val)
1860             : NULL;
1861         }
1862       while (lookahead != NULL && lookahead != ret_val);
1863       return ret_val;
1864     }
1865 }
1866
1867 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
1868    of a virtual function may refer to a base class, so we check the 'this'
1869    parameter.  */
1870
1871 static tree
1872 decl_class_context (decl)
1873      tree decl;
1874 {
1875   tree context = NULL_TREE;
1876   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
1877     context = DECL_CONTEXT (decl);
1878   else
1879     context = TYPE_MAIN_VARIANT
1880       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
1881
1882   if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
1883     context = NULL_TREE;
1884
1885   return context;
1886 }
1887 \f
1888 /**************** DIE internal representation constturction *******************/
1889
1890 /* Add an attribute/value pair to a DIE */
1891 inline void
1892 add_dwarf_attr (die, attr)
1893      register dw_die_ref die;
1894      register dw_attr_ref attr;
1895 {
1896   if (die != NULL && attr != NULL)
1897     {
1898       if (die->die_attr == NULL)
1899         {
1900           die->die_attr = attr;
1901           die->die_attr_last = attr;
1902         }
1903       else
1904         {
1905           die->die_attr_last->dw_attr_next = attr;
1906           die->die_attr_last = attr;
1907         }
1908     }
1909 }
1910
1911 /* Add a flag value attribute to a DIE.  */
1912 inline void
1913 add_AT_flag (die, attr_kind, flag)
1914      register dw_die_ref die;
1915      register enum dwarf_attribute attr_kind;
1916      register unsigned flag;
1917 {
1918   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1919   if (attr != NULL)
1920     {
1921       attr->dw_attr_next = NULL;
1922       attr->dw_attr = attr_kind;
1923       attr->dw_attr_val.val_class = dw_val_class_flag;
1924       attr->dw_attr_val.v.val_flag = flag;
1925       add_dwarf_attr (die, attr);
1926     }
1927 }
1928
1929 /* Add a signed integer attribute value to a DIE.  */
1930 inline void
1931 add_AT_int (die, attr_kind, int_val)
1932      register dw_die_ref die;
1933      register enum dwarf_attribute attr_kind;
1934      register long int int_val;
1935 {
1936   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1937   if (attr != NULL)
1938     {
1939       attr->dw_attr_next = NULL;
1940       attr->dw_attr = attr_kind;
1941       attr->dw_attr_val.val_class = dw_val_class_const;
1942       attr->dw_attr_val.v.val_int = int_val;
1943       add_dwarf_attr (die, attr);
1944     }
1945 }
1946
1947 /* Add an unsigned integer attribute value to a DIE.  */
1948 inline void
1949 add_AT_unsigned (die, attr_kind, unsigned_val)
1950      register dw_die_ref die;
1951      register enum dwarf_attribute attr_kind;
1952      register unsigned long unsigned_val;
1953 {
1954   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1955   if (attr != NULL)
1956     {
1957       attr->dw_attr_next = NULL;
1958       attr->dw_attr = attr_kind;
1959       attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
1960       attr->dw_attr_val.v.val_unsigned = unsigned_val;
1961       add_dwarf_attr (die, attr);
1962     }
1963 }
1964
1965 /* Add an unsigned double integer attribute value to a DIE.  */
1966 inline void
1967 add_AT_long_long (die, attr_kind, val_hi, val_low)
1968      register dw_die_ref die;
1969      register enum dwarf_attribute attr_kind;
1970      register unsigned long val_hi;
1971      register unsigned long val_low;
1972 {
1973   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1974   if (attr != NULL)
1975     {
1976       attr->dw_attr_next = NULL;
1977       attr->dw_attr = attr_kind;
1978       attr->dw_attr_val.val_class = dw_val_class_long_long;
1979       attr->dw_attr_val.v.val_long_long.hi = val_hi;
1980       attr->dw_attr_val.v.val_long_long.low = val_low;
1981       add_dwarf_attr (die, attr);
1982     }
1983 }
1984
1985 /* Add a floating point attribute value to a DIE and return it.  */
1986 inline void
1987 add_AT_float (die, attr_kind, length, array)
1988      register dw_die_ref die;
1989      register enum dwarf_attribute attr_kind;
1990      register unsigned length;
1991      register long *array;
1992 {
1993   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
1994   if (attr != NULL)
1995     {
1996       attr->dw_attr_next = NULL;
1997       attr->dw_attr = attr_kind;
1998       attr->dw_attr_val.val_class = dw_val_class_float;
1999       attr->dw_attr_val.v.val_float.length = length;
2000       attr->dw_attr_val.v.val_float.array = array;
2001       add_dwarf_attr (die, attr);
2002     }
2003 }
2004
2005 /* Add a string attribute value to a DIE.  */
2006 inline void
2007 add_AT_string (die, attr_kind, str)
2008      register dw_die_ref die;
2009      register enum dwarf_attribute attr_kind;
2010      register char *str;
2011 {
2012   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2013   if (attr != NULL)
2014     {
2015       attr->dw_attr_next = NULL;
2016       attr->dw_attr = attr_kind;
2017       attr->dw_attr_val.val_class = dw_val_class_str;
2018       attr->dw_attr_val.v.val_str = xstrdup (str);
2019       add_dwarf_attr (die, attr);
2020     }
2021 }
2022
2023 /* Add a DIE reference attribute value to a DIE.  */
2024 inline void
2025 add_AT_die_ref (die, attr_kind, targ_die)
2026      register dw_die_ref die;
2027      register enum dwarf_attribute attr_kind;
2028      register dw_die_ref targ_die;
2029 {
2030   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2031   if (attr != NULL)
2032     {
2033       attr->dw_attr_next = NULL;
2034       attr->dw_attr = attr_kind;
2035       attr->dw_attr_val.val_class = dw_val_class_die_ref;
2036       attr->dw_attr_val.v.val_die_ref = targ_die;
2037       add_dwarf_attr (die, attr);
2038     }
2039 }
2040
2041 /* Add an FDE reference attribute value to a DIE.  */
2042 inline void
2043 add_AT_fde_ref (die, attr_kind, targ_fde)
2044      register dw_die_ref die;
2045      register enum dwarf_attribute attr_kind;
2046      register unsigned targ_fde;
2047 {
2048   register dw_attr_ref attr;
2049
2050   attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2051   if (attr != NULL)
2052     {
2053       attr->dw_attr_next = NULL;
2054       attr->dw_attr = attr_kind;
2055       attr->dw_attr_val.val_class = dw_val_class_fde_ref;
2056       attr->dw_attr_val.v.val_fde_index = targ_fde;
2057       add_dwarf_attr (die, attr);
2058     }
2059 }
2060
2061 /* Add a location description attribute value to a DIE.  */
2062 inline void
2063 add_AT_loc (die, attr_kind, loc)
2064      register dw_die_ref die;
2065      register enum dwarf_attribute attr_kind;
2066      register dw_loc_descr_ref loc;
2067 {
2068   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2069   if (attr != NULL)
2070     {
2071       attr->dw_attr_next = NULL;
2072       attr->dw_attr = attr_kind;
2073       attr->dw_attr_val.val_class = dw_val_class_loc;
2074       attr->dw_attr_val.v.val_loc = loc;
2075       add_dwarf_attr (die, attr);
2076     }
2077 }
2078
2079 /* Add an address constant attribute value to a DIE.  */
2080 inline void
2081 add_AT_addr (die, attr_kind, addr)
2082      register dw_die_ref die;
2083      register enum dwarf_attribute attr_kind;
2084      char *addr;
2085 {
2086   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2087   if (attr != NULL)
2088     {
2089       attr->dw_attr_next = NULL;
2090       attr->dw_attr = attr_kind;
2091       attr->dw_attr_val.val_class = dw_val_class_addr;
2092       attr->dw_attr_val.v.val_addr = addr;
2093       add_dwarf_attr (die, attr);
2094     }
2095 }
2096
2097 /* Add a label identifier attribute value to a DIE.  */
2098 inline void
2099 add_AT_lbl_id (die, attr_kind, lbl_id)
2100      register dw_die_ref die;
2101      register enum dwarf_attribute attr_kind;
2102      register char *lbl_id;
2103 {
2104   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2105   if (attr != NULL)
2106     {
2107       attr->dw_attr_next = NULL;
2108       attr->dw_attr = attr_kind;
2109       attr->dw_attr_val.val_class = dw_val_class_lbl_id;
2110       attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
2111       add_dwarf_attr (die, attr);
2112     }
2113 }
2114
2115 /* Add a section offset attribute value to a DIE.  */
2116 inline void
2117 add_AT_section_offset (die, attr_kind, section)
2118      register dw_die_ref die;
2119      register enum dwarf_attribute attr_kind;
2120      register char *section;
2121 {
2122   register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2123   if (attr != NULL)
2124     {
2125       attr->dw_attr_next = NULL;
2126       attr->dw_attr = attr_kind;
2127       attr->dw_attr_val.val_class = dw_val_class_section_offset;
2128       attr->dw_attr_val.v.val_section = section;
2129       add_dwarf_attr (die, attr);
2130     }
2131 }
2132
2133 /* Test if die refers to an external subroutine.  */
2134 inline int
2135 is_extern_subr_die (die)
2136      register dw_die_ref die;
2137 {
2138   register dw_attr_ref a;
2139   register int is_subr = FALSE;
2140   register int is_extern = FALSE;
2141   if (die != NULL && die->die_tag == DW_TAG_subprogram)
2142     {
2143       is_subr = TRUE;
2144       for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
2145         {
2146           if (a->dw_attr == DW_AT_external
2147               && a->dw_attr_val.val_class == dw_val_class_flag
2148               && a->dw_attr_val.v.val_flag != 0)
2149             {
2150               is_extern = TRUE;
2151               break;
2152             }
2153         }
2154     }
2155   return is_subr && is_extern;
2156 }
2157
2158 /* Get the attribute of type attr_kind.  */
2159 inline dw_attr_ref
2160 get_AT (die, attr_kind)
2161      register dw_die_ref die;
2162      register enum dwarf_attribute attr_kind;
2163 {
2164   register dw_attr_ref a;
2165   register dw_die_ref spec = NULL;
2166
2167   if (die != NULL)
2168     {
2169       for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
2170         {
2171           if (a->dw_attr == attr_kind)
2172             return a;
2173           if (a->dw_attr == DW_AT_specification
2174               || a->dw_attr == DW_AT_abstract_origin)
2175             spec = a->dw_attr_val.v.val_die_ref;
2176         }
2177       if (spec)
2178         return get_AT (spec, attr_kind);
2179     }
2180   return NULL;
2181 }
2182
2183 /* Return the "low pc" attribute value, typically associated with
2184    a subprogram DIE.  Return null if the "low pc" attribute is
2185    either not prsent, or if it cannot be represented as an
2186    assembler label identifier.  */
2187 inline char *
2188 get_AT_low_pc (die)
2189      register dw_die_ref die;
2190 {
2191   register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
2192   if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
2193     return a->dw_attr_val.v.val_lbl_id;
2194   return NULL;
2195 }
2196
2197 /* Return the "high pc" attribute value, typically associated with
2198    a subprogram DIE.  Return null if the "high pc" attribute is
2199    either not prsent, or if it cannot be represented as an
2200    assembler label identifier.  */
2201 inline char *
2202 get_AT_hi_pc (die)
2203      register dw_die_ref die;
2204 {
2205   register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
2206   if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
2207     return a->dw_attr_val.v.val_lbl_id;
2208   return NULL;
2209 }
2210
2211 /* Return the value of the string attribute designated by ATTR_KIND, or
2212    NULL if it is not present.  */
2213 inline char *
2214 get_AT_string (die, attr_kind)
2215      register dw_die_ref die;
2216      register enum dwarf_attribute attr_kind;
2217 {
2218   register dw_attr_ref a = get_AT (die, attr_kind);
2219   if (a && a->dw_attr_val.val_class == dw_val_class_str)
2220     return a->dw_attr_val.v.val_str;
2221   return NULL;
2222 }
2223
2224 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
2225    if it is not present.  */
2226 inline int
2227 get_AT_flag (die, attr_kind)
2228      register dw_die_ref die;
2229      register enum dwarf_attribute attr_kind;
2230 {
2231   register dw_attr_ref a = get_AT (die, attr_kind);
2232   if (a && a->dw_attr_val.val_class == dw_val_class_flag)
2233     return a->dw_attr_val.v.val_flag;
2234   return -1;
2235 }
2236
2237 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
2238    if it is not present.  */
2239 inline unsigned
2240 get_AT_unsigned (die, attr_kind)
2241      register dw_die_ref die;
2242      register enum dwarf_attribute attr_kind;
2243 {
2244   register dw_attr_ref a = get_AT (die, attr_kind);
2245   if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const)
2246     return a->dw_attr_val.v.val_unsigned;
2247   return 0;
2248 }
2249
2250 inline int
2251 is_c_family ()
2252 {
2253   register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
2254   return (lang == DW_LANG_C || lang == DW_LANG_C89
2255           || lang == DW_LANG_C_plus_plus);
2256 }
2257
2258 inline int
2259 is_fortran ()
2260 {
2261   register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
2262   return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
2263 }
2264
2265 /* Remove the specified attribute if present.  */
2266 inline void
2267 remove_AT (die, attr_kind)
2268      register dw_die_ref die;
2269      register enum dwarf_attribute attr_kind;
2270 {
2271   register dw_attr_ref a;
2272   register dw_attr_ref removed = NULL;;
2273   if (die != NULL)
2274     {
2275       if (die->die_attr->dw_attr == attr_kind)
2276         {
2277           removed = die->die_attr;
2278           if (die->die_attr_last == die->die_attr)
2279             die->die_attr_last = NULL;
2280           die->die_attr = die->die_attr->dw_attr_next;
2281         }
2282       else for (a = die->die_attr; a->dw_attr_next != NULL;
2283                 a = a->dw_attr_next)
2284         if (a->dw_attr_next->dw_attr == attr_kind)
2285           {
2286             removed = a->dw_attr_next;
2287             if (die->die_attr_last == a->dw_attr_next)
2288               die->die_attr_last = a;
2289             a->dw_attr_next = a->dw_attr_next->dw_attr_next;
2290             break;
2291           }
2292       if (removed)
2293         free (removed);
2294     }
2295 }
2296
2297 /* Discard the children of this DIE.  */
2298 inline void
2299 remove_children (die)
2300      register dw_die_ref die;
2301 {
2302   register dw_die_ref child_die = die->die_child;
2303   die->die_child = NULL;
2304   die->die_child_last = NULL;
2305   while (child_die != NULL)
2306     {
2307       register dw_die_ref tmp_die = child_die;
2308       register dw_attr_ref a;
2309       child_die = child_die->die_sib;
2310
2311       for (a = tmp_die->die_attr; a != NULL; )
2312         {
2313           register dw_attr_ref tmp_a = a;
2314           a = a->dw_attr_next;
2315           free (tmp_a);
2316         }
2317       free (tmp_die);
2318     }
2319 }
2320
2321 /* Add a child DIE below its parent.  */
2322 inline void
2323 add_child_die (die, child_die)
2324      register dw_die_ref die;
2325      register dw_die_ref child_die;
2326 {
2327   if (die != NULL && child_die != NULL)
2328     {
2329       assert (die != child_die);
2330       child_die->die_parent = die;
2331       child_die->die_sib = NULL;
2332       if (die->die_child == NULL)
2333         {
2334           die->die_child = child_die;
2335           die->die_child_last = child_die;
2336         }
2337       else
2338         {
2339           die->die_child_last->die_sib = child_die;
2340           die->die_child_last = child_die;
2341         }
2342     }
2343 }
2344
2345 /* Return a pointer to a newly created DIE node.  */
2346 inline dw_die_ref
2347 new_die (tag_value, parent_die)
2348      register enum dwarf_tag tag_value;
2349      register dw_die_ref parent_die;
2350 {
2351   register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
2352   if (die != NULL)
2353     {
2354       die->die_tag = tag_value;
2355       die->die_abbrev = 0;
2356       die->die_offset = 0;
2357       die->die_child = NULL;
2358       die->die_parent = NULL;
2359       die->die_sib = NULL;
2360       die->die_child_last = NULL;
2361       die->die_attr = NULL;
2362       die->die_attr_last = NULL;
2363       if (parent_die != NULL)
2364         add_child_die (parent_die, die);
2365       else
2366         ++limbo_die_count;
2367     }
2368   return die;
2369 }
2370
2371 /* Return the DIE associated with the given type specifier.  */
2372 inline dw_die_ref
2373 lookup_type_die (type)
2374      register tree type;
2375 {
2376   return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
2377 }
2378
2379 /* Equate a DIE to a given type specifier.  */
2380 static void
2381 equate_type_number_to_die (type, type_die)
2382      register tree type;
2383      register dw_die_ref type_die;
2384 {
2385   TYPE_SYMTAB_POINTER (type) = (char *) type_die;
2386 }
2387
2388 /* Return the DIE associated with a given declaration.  */
2389 inline dw_die_ref
2390 lookup_decl_die (decl)
2391      register tree decl;
2392 {
2393   register unsigned decl_id = DECL_UID (decl);
2394   return (decl_id < decl_die_table_in_use)
2395     ? decl_die_table[decl_id] : NULL;
2396 }
2397
2398 /* Equate a DIE to a particular declaration.  */
2399 static void
2400 equate_decl_number_to_die (decl, decl_die)
2401      register tree decl;
2402      register dw_die_ref decl_die;
2403 {
2404   register unsigned decl_id = DECL_UID (decl);
2405   register unsigned i;
2406   register unsigned num_allocated;
2407   if (decl_id >= decl_die_table_allocated)
2408     {
2409       num_allocated = (((decl_id + 1)
2410                         + DECL_DIE_TABLE_INCREMENT - 1)
2411                        / DECL_DIE_TABLE_INCREMENT)
2412         * DECL_DIE_TABLE_INCREMENT;
2413       decl_die_table = (dw_die_ref *) xrealloc (decl_die_table,
2414                                        sizeof (dw_die_ref) * num_allocated);
2415       bzero (&decl_die_table[decl_die_table_allocated],
2416           (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
2417       decl_die_table_allocated = num_allocated;
2418     }
2419   if (decl_id >= decl_die_table_in_use)
2420     {
2421       decl_die_table_in_use = (decl_id + 1);
2422     }
2423   decl_die_table[decl_id] = decl_die;
2424 }
2425
2426 /* Return a pointer to a newly allocated location description.  Location
2427    descriptions are simple expression terms that can be strung
2428    together to form more complicated location (address) descriptions.  */
2429 inline dw_loc_descr_ref
2430 new_loc_descr (op, oprnd1, oprnd2)
2431      register enum dwarf_location_atom op;
2432      register unsigned long oprnd1;
2433      register unsigned long oprnd2;
2434 {
2435   register dw_loc_descr_ref descr =
2436   (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
2437   if (descr != NULL)
2438     {
2439       descr->dw_loc_next = NULL;
2440       descr->dw_loc_opc = op;
2441       descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
2442       descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
2443       descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
2444       descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
2445     }
2446   return descr;
2447 }
2448
2449 /* Add a location description term to a location description expression.  */
2450 inline void
2451 add_loc_descr (list_head, descr)
2452      register dw_loc_descr_ref *list_head;
2453      register dw_loc_descr_ref descr;
2454 {
2455   register dw_loc_descr_ref *d;
2456   /* find the end of the chain.  */
2457   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
2458     {
2459       /* nothing */ ;
2460     }
2461   *d = descr;
2462 }
2463
2464 /* Return a pointer to a newly allocated Call Frame Instruction.  */
2465 inline dw_cfi_ref
2466 new_cfi ()
2467 {
2468   register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
2469   if (cfi != NULL)
2470     {
2471       cfi->dw_cfi_next = NULL;
2472       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
2473       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
2474     }
2475   return cfi;
2476 }
2477
2478 /* Add a Call Frame Instruction to list of instructions.  */
2479 inline void
2480 add_cfi (list_head, cfi)
2481      register dw_cfi_ref *list_head;
2482      register dw_cfi_ref cfi;
2483 {
2484   register dw_cfi_ref *p;
2485   /* find the end of the chain.  */
2486   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
2487     {
2488       /* nothing */ ;
2489     }
2490   *p = cfi;
2491 }
2492 \f
2493 /********* Print DWARF Internal Representation (debugging aids) ***************/
2494
2495 /* Keep track of the number of spaces used to indent the
2496    output of the debugging routines that print the structure of
2497    the DIE internal representation.  */
2498 static int print_indent;
2499
2500 /* Indent the line the number of spaces given by print_indent.  */
2501 inline void
2502 print_spaces (outfile)
2503      FILE *outfile;
2504 {
2505   fprintf (outfile, "%*s", print_indent, "");
2506 }
2507
2508 /* Print the information assoaciated with a given DIE, and its children.
2509    This routine is a debugging aid only.  */
2510 static void
2511 print_die (die, outfile)
2512      dw_die_ref die;
2513      FILE *outfile;
2514 {
2515   register dw_attr_ref a;
2516   register dw_die_ref c;
2517   print_spaces (outfile);
2518   fprintf (outfile, "DIE %4u: %s\n",
2519            die->die_offset, dwarf_tag_name (die->die_tag));
2520   print_spaces (outfile);
2521   fprintf (outfile, "  abbrev id: %u", die->die_abbrev);
2522   fprintf (outfile, " offset: %u\n", die->die_offset);
2523   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
2524     {
2525       print_spaces (outfile);
2526       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
2527       switch (a->dw_attr_val.val_class)
2528         {
2529         case dw_val_class_addr:
2530           fprintf (outfile, "address");
2531           break;
2532         case dw_val_class_loc:
2533           fprintf (outfile, "location descriptor");
2534           break;
2535         case dw_val_class_const:
2536           fprintf (outfile, "%d", a->dw_attr_val.v.val_int);
2537           break;
2538         case dw_val_class_unsigned_const:
2539           fprintf (outfile, "%u", a->dw_attr_val.v.val_unsigned);
2540           break;
2541         case dw_val_class_long_long:
2542           fprintf (outfile, "constant (%u,%u)",
2543                   a->dw_attr_val.v.val_long_long.hi,
2544                   a->dw_attr_val.v.val_long_long.low);
2545           break;
2546         case dw_val_class_float:
2547           fprintf (outfile, "floating-point constant");
2548           break;
2549         case dw_val_class_flag:
2550           fprintf (outfile, "%u", a->dw_attr_val.v.val_flag);
2551           break;
2552         case dw_val_class_die_ref:
2553           if (a->dw_attr_val.v.val_die_ref != NULL)
2554             {
2555               fprintf (outfile, "die -> %u",
2556                        a->dw_attr_val.v.val_die_ref->die_offset);
2557             }
2558           else
2559             {
2560               fprintf (outfile, "die -> <null>");
2561             }
2562           break;
2563         case dw_val_class_lbl_id:
2564           fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id);
2565           break;
2566         case dw_val_class_section_offset:
2567           fprintf (outfile, "section: %s", a->dw_attr_val.v.val_section);
2568           break;
2569         case dw_val_class_str:
2570           if (a->dw_attr_val.v.val_str != NULL)
2571             {
2572               fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str);
2573             }
2574           else
2575             {
2576               fprintf (outfile, "<null>");
2577             }
2578           break;
2579         }
2580       fprintf (outfile, "\n");
2581     }
2582   if (die->die_child != NULL)
2583     {
2584       print_indent += 4;
2585       for (c = die->die_child; c != NULL; c = c->die_sib)
2586         {
2587           print_die (c, outfile);
2588         }
2589       print_indent -= 4;
2590     }
2591 }
2592
2593 /* Print the contents of the source code line number correspondence table.
2594    This routine is a debugging aid only.  */
2595 static void
2596 print_dwarf_line_table (outfile)
2597      FILE *outfile;
2598 {
2599   register unsigned i;
2600   register dw_line_info_ref line_info;
2601   fprintf (outfile, "\n\nDWARF source line information\n");
2602   for (i = 1; i < line_info_table_in_use; ++i)
2603     {
2604       line_info = &line_info_table[i];
2605       fprintf (outfile, "%5d: ", i);
2606       fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
2607       fprintf (outfile, "%6d", line_info->dw_line_num);
2608       fprintf (outfile, "\n");
2609     }
2610   fprintf (outfile, "\n\n");
2611 }
2612
2613 /* Print the information collected for a given DIE.  */
2614 void
2615 debug_dwarf_die (die)
2616      dw_die_ref die;
2617 {
2618   print_die (die, stderr);
2619 }
2620
2621 /* Print all DWARF informaiton collected for the compilation unit.
2622    This routine is a debugging aid only.  */
2623 void
2624 debug_dwarf ()
2625 {
2626   print_indent = 0;
2627   print_die (comp_unit_die, stderr);
2628   print_dwarf_line_table (stderr);
2629 }
2630
2631 \f
2632 /***************** DWARF Information Construction Support *********************/
2633
2634 /* Traverse the DIE, and add a sibling attribute if it may have the
2635    effect of speeding up access to siblings.  To save some space,
2636    avoid generating sibling attributes for DIE's without children.  */
2637 static void
2638 add_sibling_attributes(die)
2639      register dw_die_ref die;
2640 {
2641   register dw_die_ref c;
2642   register dw_attr_ref attr;
2643   if (die != comp_unit_die && die->die_child != NULL)
2644     {
2645       attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
2646       if (attr != NULL)
2647         {
2648           attr->dw_attr_next = NULL;
2649           attr->dw_attr = DW_AT_sibling;
2650           attr->dw_attr_val.val_class = dw_val_class_die_ref;
2651           attr->dw_attr_val.v.val_die_ref = die->die_sib;
2652         }
2653       /* add the sibling link to the front of the attribute list.  */
2654       attr->dw_attr_next = die->die_attr;
2655       if (die->die_attr == NULL)
2656         {
2657           die->die_attr_last = attr;
2658         }
2659       die->die_attr = attr;
2660     }
2661   for (c = die->die_child; c != NULL; c = c->die_sib)
2662     {
2663       add_sibling_attributes (c);
2664     }
2665 }
2666
2667 /* The format of each DIE (and its attribute value pairs)
2668    is encoded in an abbreviation table.  This routine builds the
2669    abbreviation table and assigns a unique abbreviation id for
2670    each abbreviation entry.  The children of each die are visited
2671    recursively.  */
2672 static void
2673 build_abbrev_table (die)
2674      register dw_die_ref die;
2675 {
2676   register unsigned long abbrev_id;
2677   register unsigned long n_alloc;
2678   register dw_die_ref c;
2679   register dw_attr_ref d_attr, a_attr;
2680   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
2681     {
2682       register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
2683       if (abbrev->die_tag == die->die_tag)
2684         {
2685           if ((abbrev->die_child != NULL) == (die->die_child != NULL))
2686             {
2687               a_attr = abbrev->die_attr;
2688               d_attr = die->die_attr;
2689               while (a_attr != NULL && d_attr != NULL)
2690                 {
2691                   if ((a_attr->dw_attr != d_attr->dw_attr)
2692                       || (value_format (&a_attr->dw_attr_val)
2693                           != value_format (&d_attr->dw_attr_val)))
2694                     {
2695                       break;
2696                     }
2697                   a_attr = a_attr->dw_attr_next;
2698                   d_attr = d_attr->dw_attr_next;
2699                 }
2700               if (a_attr == NULL && d_attr == NULL)
2701                 {
2702                   break;
2703                 }
2704             }
2705         }
2706     }
2707   if (abbrev_id >= abbrev_die_table_in_use)
2708     {
2709       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
2710         {
2711           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
2712           abbrev_die_table = (dw_die_ref *)
2713             xmalloc (abbrev_die_table,
2714                      sizeof (dw_die_ref) * n_alloc);
2715           bzero (&abbrev_die_table[abbrev_die_table_allocated],
2716               (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
2717           abbrev_die_table_allocated = n_alloc;
2718         }
2719       ++abbrev_die_table_in_use;
2720       abbrev_die_table[abbrev_id] = die;
2721     }
2722   die->die_abbrev = abbrev_id;
2723   for (c = die->die_child; c != NULL; c = c->die_sib)
2724     {
2725       build_abbrev_table (c);
2726     }
2727 }
2728
2729 \f
2730 /**********************  DWARF Information Sizing *****************************/
2731
2732 /* Return the size of an unsigned LEB128 quantity.  */
2733 inline unsigned long
2734 size_of_uleb128 (value)
2735      register unsigned long value;
2736 {
2737   register unsigned long size = 0;
2738   register unsigned byte;
2739   do
2740     {
2741       byte = (value & 0x7f);
2742       value >>= 7;
2743       size += 1;
2744     }
2745   while (value != 0);
2746   return size;
2747 }
2748
2749 /* Return the size of a signed LEB128 quantity.  */
2750 inline unsigned long
2751 size_of_sleb128 (value)
2752      register long value;
2753 {
2754   register unsigned long size = 0;
2755   register unsigned byte;
2756   do
2757     {
2758       byte = (value & 0x7f);
2759       value >>= 7;
2760       size += 1;
2761     }
2762   while (!(((value == 0) && ((byte & 0x40) == 0))
2763            || ((value == -1) && ((byte & 0x40) != 0))));
2764   return size;
2765 }
2766
2767 /* Return the size of a string, including the null byte.  */
2768 static unsigned long
2769 size_of_string (str)
2770      register char *str;
2771 {
2772   register unsigned long size = 0;
2773   register unsigned long slen = strlen (str);
2774   register unsigned long i;
2775   register unsigned c;
2776   for (i = 0; i < slen; ++i)
2777     {
2778       c = str[i];
2779       if (c == '\\')
2780         {
2781           ++i;
2782         }
2783       size += 1;
2784     }
2785   /* Null terminator.  */
2786   size += 1;
2787   return size;
2788 }
2789
2790 /* Return the size of a location descriptor.  */
2791 static unsigned long
2792 size_of_loc_descr (loc)
2793      register dw_loc_descr_ref loc;
2794 {
2795   register unsigned long size = 1;
2796   switch (loc->dw_loc_opc)
2797     {
2798     case DW_OP_addr:
2799       size += PTR_SIZE;
2800       break;
2801     case DW_OP_const1u:
2802     case DW_OP_const1s:
2803       size += 1;
2804       break;
2805     case DW_OP_const2u:
2806     case DW_OP_const2s:
2807       size += 2;
2808       break;
2809     case DW_OP_const4u:
2810     case DW_OP_const4s:
2811       size += 4;
2812       break;
2813     case DW_OP_const8u:
2814     case DW_OP_const8s:
2815       size += 8;
2816       break;
2817     case DW_OP_constu:
2818       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2819       break;
2820     case DW_OP_consts:
2821       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2822       break;
2823     case DW_OP_pick:
2824       size += 1;
2825       break;
2826     case DW_OP_plus_uconst:
2827       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2828       break;
2829     case DW_OP_skip:
2830     case DW_OP_bra:
2831       size += 2;
2832       break;
2833     case DW_OP_breg0:
2834     case DW_OP_breg1:
2835     case DW_OP_breg2:
2836     case DW_OP_breg3:
2837     case DW_OP_breg4:
2838     case DW_OP_breg5:
2839     case DW_OP_breg6:
2840     case DW_OP_breg7:
2841     case DW_OP_breg8:
2842     case DW_OP_breg9:
2843     case DW_OP_breg10:
2844     case DW_OP_breg11:
2845     case DW_OP_breg12:
2846     case DW_OP_breg13:
2847     case DW_OP_breg14:
2848     case DW_OP_breg15:
2849     case DW_OP_breg16:
2850     case DW_OP_breg17:
2851     case DW_OP_breg18:
2852     case DW_OP_breg19:
2853     case DW_OP_breg20:
2854     case DW_OP_breg21:
2855     case DW_OP_breg22:
2856     case DW_OP_breg23:
2857     case DW_OP_breg24:
2858     case DW_OP_breg25:
2859     case DW_OP_breg26:
2860     case DW_OP_breg27:
2861     case DW_OP_breg28:
2862     case DW_OP_breg29:
2863     case DW_OP_breg30:
2864     case DW_OP_breg31:
2865       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2866       break;
2867     case DW_OP_regx:
2868       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2869       break;
2870     case DW_OP_fbreg:
2871       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2872       break;
2873     case DW_OP_bregx:
2874       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2875       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
2876       break;
2877     case DW_OP_piece:
2878       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2879       break;
2880     case DW_OP_deref_size:
2881     case DW_OP_xderef_size:
2882       size += 1;
2883       break;
2884     default:
2885       break;
2886     }
2887   return size;
2888 }
2889
2890 /* Return the size of a series of location descriptors.  */
2891 static unsigned long
2892 size_of_locs (loc)
2893      register dw_loc_descr_ref loc;
2894 {
2895   register unsigned long size = 0;
2896   for (; loc != NULL; loc = loc->dw_loc_next)
2897     size += size_of_loc_descr (loc);
2898   return size;
2899 }
2900
2901 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
2902 static int
2903 constant_size (value)
2904      long unsigned value;
2905 {
2906   int log;
2907
2908   if (value == 0)
2909     log = 0;
2910   else
2911     log = floor_log2 (value);
2912
2913   log = log / 8;
2914   log = 1 << (floor_log2 (log) + 1);
2915
2916   return log;
2917 }
2918
2919 /* Return the size of a DIE, as it is represented in the
2920    .debug_info section.  */
2921 static unsigned long
2922 size_of_die (die)
2923      register dw_die_ref die;
2924 {
2925   register unsigned long size = 0;
2926   register dw_attr_ref a;
2927   size += size_of_uleb128 (die->die_abbrev);
2928   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
2929     {
2930       switch (a->dw_attr_val.val_class)
2931         {
2932         case dw_val_class_addr:
2933           size += PTR_SIZE;
2934           break;
2935         case dw_val_class_loc:
2936           {
2937             register unsigned long lsize
2938               = size_of_locs (a->dw_attr_val.v.val_loc);
2939
2940             /* Block length.  */
2941             size += constant_size (lsize);
2942             size += lsize;
2943           }
2944           break;
2945         case dw_val_class_const:
2946           size += 4;
2947           break;
2948         case dw_val_class_unsigned_const:
2949           size += constant_size (a->dw_attr_val.v.val_unsigned);
2950           break;
2951         case dw_val_class_long_long:
2952           size += 1 + 8; /* block */
2953           break;
2954         case dw_val_class_float:
2955           size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
2956           break;
2957         case dw_val_class_flag:
2958           size += 1;
2959           break;
2960         case dw_val_class_die_ref:
2961           size += DWARF_OFFSET_SIZE;
2962           break;
2963         case dw_val_class_fde_ref:
2964           size += DWARF_OFFSET_SIZE;
2965           break;
2966         case dw_val_class_lbl_id:
2967           size += PTR_SIZE;
2968           break;
2969         case dw_val_class_section_offset:
2970           size += DWARF_OFFSET_SIZE;
2971           break;
2972         case dw_val_class_str:
2973           size += size_of_string (a->dw_attr_val.v.val_str);
2974           break;
2975         default:
2976           abort ();
2977         }
2978     }
2979   return size;
2980 }
2981
2982 /* Size the debgging information associted with a given DIE.
2983    Visits the DIE's children recursively.  Updates the global
2984    variable next_die_offset, on each time through.  Uses the
2985    current value of next_die_offset to updete the die_offset
2986    field in each DIE.  */
2987 static void
2988 calc_die_sizes (die)
2989      dw_die_ref die;
2990 {
2991   register dw_die_ref c;
2992   die->die_offset = next_die_offset;
2993   next_die_offset += size_of_die (die);
2994   for (c = die->die_child; c != NULL; c = c->die_sib)
2995     {
2996       calc_die_sizes (c);
2997     }
2998   if (die->die_child != NULL)
2999     {
3000       /* Count the null byte used to terminate sibling lists.  */
3001       next_die_offset += 1;
3002     }
3003 }
3004
3005 /* Return the size of the line information prolog generated for the
3006    compilation unit.  */
3007 static unsigned long
3008 size_of_line_prolog ()
3009 {
3010   register unsigned long size;
3011   register unsigned long ft_index;
3012   size = DWARF_LINE_PROLOG_HEADER_SIZE;
3013   /* Count the size of the table giving number of args for each
3014      standard opcode.  */
3015   size += DWARF_LINE_OPCODE_BASE - 1;
3016   /* Include directory table is empty (at present).  Count only the
3017      the null byte used to terminate the table.  */
3018   size += 1;
3019   for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
3020     {
3021       /* File name entry.  */
3022       size += size_of_string (file_table[ft_index]);
3023       /* Include directory index.  */
3024       size += size_of_uleb128 (0);
3025       /* Modification time.  */
3026       size += size_of_uleb128 (0);
3027       /* File length in bytes.  */
3028       size += size_of_uleb128 (0);
3029     }
3030   /* Count the file table terminator.  */
3031   size += 1;
3032   return size;
3033 }
3034
3035 /* Return the size of the line information generated for this
3036    compilation unit.  */
3037 static unsigned long
3038 size_of_line_info ()
3039 {
3040   register unsigned long size;
3041   register unsigned long lt_index;
3042   register unsigned long current_line;
3043   register long line_offset;
3044   register long line_delta;
3045   register unsigned long current_file;
3046   register unsigned long function;
3047   /* Version number.  */
3048   size = 2;
3049   /* Prolog length specifier.  */
3050   size += DWARF_OFFSET_SIZE;
3051   /* Prolog.  */
3052   size += size_of_line_prolog ();
3053   /* Set address register instruction.  */
3054   size += 1 + size_of_uleb128 (1 + PTR_SIZE)
3055     + 1 + PTR_SIZE;
3056   current_file = 1;
3057   current_line = 1;
3058   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
3059     {
3060       register dw_line_info_ref line_info;
3061       /* Advance pc instruction.  */
3062       size += 1 + 2;
3063       line_info = &line_info_table[lt_index];
3064       if (line_info->dw_file_num != current_file)
3065         {
3066           /* Set file number instruction.  */
3067           size += 1;
3068           current_file = line_info->dw_file_num;
3069           size += size_of_uleb128 (current_file);
3070         }
3071       if (line_info->dw_line_num != current_line)
3072         {
3073           line_offset = line_info->dw_line_num - current_line;
3074           line_delta = line_offset - DWARF_LINE_BASE;
3075           current_line = line_info->dw_line_num;
3076           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
3077             {
3078               /* 1-byte special line number instruction.  */
3079               size += 1;
3080             }
3081           else
3082             {
3083               /* Advance line instruction.  */
3084               size += 1;
3085               size += size_of_sleb128 (line_offset);
3086               /* Generate line entry instruction.  */
3087               size += 1;
3088             }
3089         }
3090     }
3091   /* Advance pc instruction.  */
3092   size += 1 + 2;
3093   /* End of line number info. marker.  */
3094   size += 1 + size_of_uleb128 (1) + 1;
3095   function = 0;
3096   current_file = 1;
3097   current_line = 1;
3098   for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
3099     {
3100       register dw_separate_line_info_ref line_info
3101         = &separate_line_info_table[lt_index];
3102       if (function != line_info->function)
3103         {
3104           function = line_info->function;
3105           /* Set address register instruction.  */
3106           size += 1 + size_of_uleb128 (1 + PTR_SIZE)
3107             + 1 + PTR_SIZE;
3108         }
3109       else
3110         {
3111           /* Advance pc instruction.  */
3112           size += 1 + 2;
3113         }
3114       if (line_info->dw_file_num != current_file)
3115         {
3116           /* Set file number instruction.  */
3117           size += 1;
3118           current_file = line_info->dw_file_num;
3119           size += size_of_uleb128 (current_file);
3120         }
3121       if (line_info->dw_line_num != current_line)
3122         {
3123           line_offset = line_info->dw_line_num - current_line;
3124           line_delta = line_offset - DWARF_LINE_BASE;
3125           current_line = line_info->dw_line_num;
3126           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
3127             {
3128               /* 1-byte special line number instruction.  */
3129               size += 1;
3130             }
3131           else
3132             {
3133               /* Advance line instruction.  */
3134               size += 1;
3135               size += size_of_sleb128 (line_offset);
3136               /* Generate line entry instruction.  */
3137               size += 1;
3138             }
3139         }
3140       ++lt_index;
3141
3142       /* If we're done with a function, end its sequence.  */
3143       if (lt_index == separate_line_info_table_in_use
3144           || separate_line_info_table[lt_index].function != function)
3145         {
3146           current_file = 1;
3147           current_line = 1;
3148           /* Advance pc instruction.  */
3149           size += 1 + 2;
3150           /* End of line number info. marker.  */
3151           size += 1 + size_of_uleb128 (1) + 1;
3152         }
3153     }
3154   return size;
3155 }
3156
3157 /* Return the size of the .debug_pubnames table  generated for the
3158    compilation unit.  */
3159 static unsigned long
3160 size_of_pubnames ()
3161 {
3162   register unsigned long size;
3163   register unsigned i;
3164
3165   size = DWARF_PUBNAMES_HEADER_SIZE;
3166   for (i = 0; i < pubname_table_in_use; ++i)
3167     {
3168       register pubname_ref p = &pubname_table[i];
3169       size += DWARF_OFFSET_SIZE + size_of_string (p->name);
3170     }
3171   size += DWARF_OFFSET_SIZE;
3172   return size;
3173 }
3174
3175 /* Return the size of the information in the .debug_aranges seciton.  */
3176 static unsigned long
3177 size_of_aranges ()
3178 {
3179   register unsigned long size;
3180   size = DWARF_ARANGES_HEADER_SIZE;
3181   /* Count the address/length pair for this compilation unit.  */
3182   size += 2 * PTR_SIZE;
3183   size += 2 * PTR_SIZE * arange_table_in_use;
3184   /* Count the two zero words used to terminated the address range table.  */
3185   size += 2 * PTR_SIZE;
3186   return size;
3187 }
3188 \f
3189 /**************** DWARF Debug Information Output *****************************/
3190
3191 /* Output an unsigned LEB128 quantity.  */
3192 static void
3193 output_uleb128 (value)
3194      register unsigned long value;
3195 {
3196   unsigned long save_value = value;
3197   fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
3198   do
3199     {
3200       register unsigned byte = (value & 0x7f);
3201       value >>= 7;
3202       if (value != 0)
3203         {
3204           /* More bytes to follow.  */
3205           byte |= 0x80;
3206         }
3207       fprintf (asm_out_file, "0x%x", byte);
3208       if (value != 0)
3209         {
3210           fprintf (asm_out_file, ",");
3211         }
3212     }
3213   while (value != 0);
3214   if (flag_verbose_asm)
3215     fprintf (asm_out_file, "\t%s ULEB128 0x%x", ASM_COMMENT_START, save_value);
3216 }
3217
3218 /* Output an signed LEB128 quantity.  */
3219 static void
3220 output_sleb128 (value)
3221      register long value;
3222 {
3223   register int more;
3224   register unsigned byte;
3225   long save_value = value;
3226   fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
3227   do
3228     {
3229       byte = (value & 0x7f);
3230       /* arithmetic shift */
3231       value >>= 7;
3232       more = !((((value == 0) && ((byte & 0x40) == 0))
3233                 || ((value == -1) && ((byte & 0x40) != 0))));
3234       if (more)
3235         {
3236           byte |= 0x80;
3237         }
3238       fprintf (asm_out_file, "0x%x", byte);
3239       if (more)
3240         {
3241           fprintf (asm_out_file, ",");
3242         }
3243     }
3244   while (more);
3245   if (flag_verbose_asm)
3246     fprintf (asm_out_file, "\t%s SLEB128 %d", ASM_COMMENT_START, save_value);
3247 }
3248
3249 /* Select the encoding of an attribute value.  */
3250 static enum dwarf_form
3251 value_format (v)
3252      dw_val_ref v;
3253 {
3254   switch (v->val_class)
3255     {
3256     case dw_val_class_addr:
3257       return DW_FORM_addr;
3258     case dw_val_class_loc:
3259       switch (constant_size (size_of_locs (v->v.val_loc)))
3260         {
3261         case 1:
3262           return DW_FORM_block1;
3263         case 2:
3264           return DW_FORM_block2;
3265         default:
3266           abort ();
3267         }
3268     case dw_val_class_const:
3269       return DW_FORM_data4;
3270     case dw_val_class_unsigned_const:
3271       switch (constant_size (v->v.val_unsigned))
3272         {
3273         case 1:
3274           return DW_FORM_data1;
3275         case 2:
3276           return DW_FORM_data2;
3277         case 4:
3278           return DW_FORM_data4;
3279         default:
3280           abort ();
3281         }
3282     case dw_val_class_long_long:
3283       return DW_FORM_block1;
3284     case dw_val_class_float:
3285       return DW_FORM_block1;
3286     case dw_val_class_flag:
3287       return DW_FORM_flag;
3288     case dw_val_class_die_ref:
3289       return DW_FORM_ref;
3290     case dw_val_class_fde_ref:
3291       return DW_FORM_data;
3292     case dw_val_class_lbl_id:
3293       return DW_FORM_addr;
3294     case dw_val_class_section_offset:
3295       return DW_FORM_data;
3296     case dw_val_class_str:
3297       return DW_FORM_string;
3298     default:
3299       abort ();
3300     }
3301 }
3302
3303 /* Output the encoding of an attribute value.  */
3304 static void
3305 output_value_format (v)
3306      dw_val_ref v;
3307 {
3308   enum dwarf_form form = value_format (v);
3309   output_uleb128 (form);
3310   if (flag_verbose_asm)
3311     fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
3312   fputc ('\n', asm_out_file);
3313 }
3314
3315 /* Output the .debug_abbrev section which defines the DIE abbreviation
3316    table.  */
3317 static void
3318 output_abbrev_section ()
3319 {
3320   unsigned long abbrev_id;
3321   dw_attr_ref a_attr;
3322   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
3323     {
3324       register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
3325       output_uleb128 (abbrev_id);
3326       if (flag_verbose_asm)
3327         fprintf (asm_out_file, " (abbrev code)");
3328       fputc ('\n', asm_out_file);
3329       output_uleb128 (abbrev->die_tag);
3330       if (flag_verbose_asm)
3331         fprintf (asm_out_file, " (TAG: %s)",
3332                  dwarf_tag_name (abbrev->die_tag));
3333       fputc ('\n', asm_out_file);
3334       fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
3335                (abbrev->die_child != NULL)
3336                ? DW_children_yes : DW_children_no);
3337       if (flag_verbose_asm)
3338         {
3339           fprintf (asm_out_file, "\t%s %s",
3340                    ASM_COMMENT_START,
3341                    (abbrev->die_child != NULL)
3342                    ? "DW_children_yes" : "DW_children_no");
3343         }
3344       fputc ('\n', asm_out_file);
3345       for (a_attr = abbrev->die_attr; a_attr != NULL;
3346            a_attr = a_attr->dw_attr_next)
3347         {
3348           output_uleb128 (a_attr->dw_attr);
3349           if (flag_verbose_asm)
3350             fprintf (asm_out_file, " (%s)",
3351                      dwarf_attr_name (a_attr->dw_attr));
3352           fputc ('\n', asm_out_file);
3353           output_value_format (&a_attr->dw_attr_val);
3354         }
3355       fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
3356     }
3357 }
3358
3359 /* Output location description stack opcode's operands (if any).  */
3360 static void
3361 output_loc_operands (loc)
3362      register dw_loc_descr_ref loc;
3363 {
3364   register dw_val_ref val1 = &loc->dw_loc_oprnd1;
3365   register dw_val_ref val2 = &loc->dw_loc_oprnd2;
3366   switch (loc->dw_loc_opc)
3367     {
3368     case DW_OP_addr:
3369       ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
3370       fputc ('\n', asm_out_file);
3371       break;
3372     case DW_OP_const1u:
3373     case DW_OP_const1s:
3374       ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
3375       fputc ('\n', asm_out_file);
3376       break;
3377     case DW_OP_const2u:
3378     case DW_OP_const2s:
3379       ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
3380       fputc ('\n', asm_out_file);
3381       break;
3382     case DW_OP_const4u:
3383     case DW_OP_const4s:
3384       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
3385       fputc ('\n', asm_out_file);
3386       break;
3387     case DW_OP_const8u:
3388     case DW_OP_const8s:
3389       abort ();
3390       fputc ('\n', asm_out_file);
3391       break;
3392     case DW_OP_constu:
3393       output_uleb128 (val1->v.val_unsigned);
3394       fputc ('\n', asm_out_file);
3395       break;
3396     case DW_OP_consts:
3397       output_sleb128 (val1->v.val_int);
3398       fputc ('\n', asm_out_file);
3399       break;
3400     case DW_OP_pick:
3401       ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
3402       fputc ('\n', asm_out_file);
3403       break;
3404     case DW_OP_plus_uconst:
3405       output_uleb128 (val1->v.val_unsigned);
3406       fputc ('\n', asm_out_file);
3407       break;
3408     case DW_OP_skip:
3409     case DW_OP_bra:
3410       ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
3411       fputc ('\n', asm_out_file);
3412       break;
3413     case DW_OP_breg0:
3414     case DW_OP_breg1:
3415     case DW_OP_breg2:
3416     case DW_OP_breg3:
3417     case DW_OP_breg4:
3418     case DW_OP_breg5:
3419     case DW_OP_breg6:
3420     case DW_OP_breg7:
3421     case DW_OP_breg8:
3422     case DW_OP_breg9:
3423     case DW_OP_breg10:
3424     case DW_OP_breg11:
3425     case DW_OP_breg12:
3426     case DW_OP_breg13:
3427     case DW_OP_breg14:
3428     case DW_OP_breg15:
3429     case DW_OP_breg16:
3430     case DW_OP_breg17:
3431     case DW_OP_breg18:
3432     case DW_OP_breg19:
3433     case DW_OP_breg20:
3434     case DW_OP_breg21:
3435     case DW_OP_breg22:
3436     case DW_OP_breg23:
3437     case DW_OP_breg24:
3438     case DW_OP_breg25:
3439     case DW_OP_breg26:
3440     case DW_OP_breg27:
3441     case DW_OP_breg28:
3442     case DW_OP_breg29:
3443     case DW_OP_breg30:
3444     case DW_OP_breg31:
3445       output_sleb128 (val1->v.val_int);
3446       fputc ('\n', asm_out_file);
3447       break;
3448     case DW_OP_regx:
3449       output_uleb128 (val1->v.val_unsigned);
3450       fputc ('\n', asm_out_file);
3451       break;
3452     case DW_OP_fbreg:
3453       output_sleb128 (val1->v.val_int);
3454       fputc ('\n', asm_out_file);
3455       break;
3456     case DW_OP_bregx:
3457       output_uleb128 (val1->v.val_unsigned);
3458       fputc ('\n', asm_out_file);
3459       output_sleb128 (val2->v.val_int);
3460       fputc ('\n', asm_out_file);
3461       break;
3462     case DW_OP_piece:
3463       output_uleb128 (val1->v.val_unsigned);
3464       fputc ('\n', asm_out_file);
3465       break;
3466     case DW_OP_deref_size:
3467     case DW_OP_xderef_size:
3468       ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
3469       fputc ('\n', asm_out_file);
3470       break;
3471     default:
3472       break;
3473     }
3474 }
3475
3476 /* Compute the offset of a sibling.  */
3477 static unsigned long
3478 sibling_offset (die)
3479      dw_die_ref die;
3480 {
3481   unsigned long offset;
3482   if (die->die_child_last == NULL)
3483     {
3484       offset = die->die_offset + size_of_die (die);
3485     }
3486   else
3487     {
3488       offset = sibling_offset (die->die_child_last) + 1;
3489     }
3490   return offset;
3491 }
3492
3493 /* Output the DIE and its attributes.  Called recursively to generate
3494    the definitions of each child DIE.  */
3495 static void
3496 output_die (die)
3497      register dw_die_ref die;
3498 {
3499   register dw_attr_ref a;
3500   register dw_die_ref c;
3501   register unsigned long ref_offset;
3502   register unsigned long size;
3503   register dw_loc_descr_ref loc;
3504   register int i;
3505
3506   output_uleb128 (die->die_abbrev);
3507   if (flag_verbose_asm)
3508     fprintf (asm_out_file, " (DIE (0x%x) %s)",
3509              die->die_offset, dwarf_tag_name (die->die_tag));
3510   fputc ('\n', asm_out_file);
3511   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3512     {
3513       switch (a->dw_attr_val.val_class)
3514         {
3515         case dw_val_class_addr:
3516           ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file,
3517                                        a->dw_attr_val.v.val_addr);
3518           break;
3519         case dw_val_class_loc:
3520           size = size_of_locs (a->dw_attr_val.v.val_loc);
3521           /* Output the block length for this list of location operations.  */
3522           switch (constant_size (size))
3523             {
3524             case 1:
3525               ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
3526               break;
3527             case 2:
3528               ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
3529               break;
3530             default:
3531               abort ();
3532             }
3533           if (flag_verbose_asm)
3534             {
3535               fprintf (asm_out_file, "\t%s %s",
3536                        ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
3537             }
3538           fputc ('\n', asm_out_file);
3539           for (loc = a->dw_attr_val.v.val_loc; loc != NULL;
3540                loc = loc->dw_loc_next)
3541             {
3542               /* Output the opcode.  */
3543               ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
3544               if (flag_verbose_asm)
3545                 {
3546                   fprintf (asm_out_file, "\t%s %s",
3547                            ASM_COMMENT_START,
3548                            dwarf_stack_op_name (loc->dw_loc_opc));
3549                 }
3550               fputc ('\n', asm_out_file);
3551               /* Output the operand(s) (if any).  */
3552               output_loc_operands (loc);
3553             }
3554           break;
3555         case dw_val_class_const:
3556           ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int);
3557           break;
3558         case dw_val_class_unsigned_const:
3559           switch (constant_size (a->dw_attr_val.v.val_unsigned))
3560             {
3561             case 1:
3562               ASM_OUTPUT_DWARF_DATA1
3563                 (asm_out_file, a->dw_attr_val.v.val_unsigned);
3564               break;
3565             case 2:
3566               ASM_OUTPUT_DWARF_DATA2
3567                 (asm_out_file, a->dw_attr_val.v.val_unsigned);
3568               break;
3569             case 4:
3570               ASM_OUTPUT_DWARF_DATA4
3571                 (asm_out_file, a->dw_attr_val.v.val_unsigned);
3572               break;
3573             default:
3574               abort ();
3575             }
3576           break;
3577         case dw_val_class_long_long:
3578           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
3579           if (flag_verbose_asm)
3580             fprintf (asm_out_file, "\t%s %s",
3581                      ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
3582           fputc ('\n', asm_out_file);
3583           ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
3584                                   a->dw_attr_val.v.val_long_long.hi,
3585                                   a->dw_attr_val.v.val_long_long.low);
3586           if (flag_verbose_asm)
3587             fprintf (asm_out_file, "\t%s long long constant",
3588                      ASM_COMMENT_START);
3589           fputc ('\n', asm_out_file);
3590           break;
3591         case dw_val_class_float:
3592           ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
3593                                   a->dw_attr_val.v.val_float.length * 4);
3594           if (flag_verbose_asm)
3595             fprintf (asm_out_file, "\t%s %s",
3596                      ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
3597           fputc ('\n', asm_out_file);
3598           for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
3599             {
3600               ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
3601                                       a->dw_attr_val.v.val_float.array[i]);
3602               if (flag_verbose_asm)
3603                 fprintf (asm_out_file, "\t%s fp constant word %d",
3604                          ASM_COMMENT_START, i);
3605               fputc ('\n', asm_out_file);
3606             }
3607           break;
3608         case dw_val_class_flag:
3609           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag);
3610           break;
3611         case dw_val_class_die_ref:
3612           if (a->dw_attr_val.v.val_die_ref != NULL)
3613             {
3614               ref_offset = a->dw_attr_val.v.val_die_ref->die_offset;
3615             }
3616           else if (a->dw_attr == DW_AT_sibling)
3617             {
3618               ref_offset = sibling_offset(die);
3619             }
3620           else
3621             {
3622               abort ();
3623             }
3624           ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset);
3625           break;
3626         case dw_val_class_fde_ref:
3627           ref_offset = fde_table[a->dw_attr_val.v.val_fde_index].dw_fde_offset;
3628           fprintf (asm_out_file, "\t%s\t%s+0x%x", UNALIGNED_OFFSET_ASM_OP,
3629                    stripattributes (FRAME_SECTION), ref_offset);
3630           break;
3631         case dw_val_class_lbl_id:
3632           ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id);
3633           break;
3634         case dw_val_class_section_offset:
3635           ASM_OUTPUT_DWARF_OFFSET
3636             (asm_out_file, stripattributes (a->dw_attr_val.v.val_section));
3637           break;
3638         case dw_val_class_str:
3639           ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str);
3640           break;
3641         default:
3642           abort ();
3643         }
3644       if (a->dw_attr_val.val_class != dw_val_class_loc
3645           && a->dw_attr_val.val_class != dw_val_class_long_long
3646           && a->dw_attr_val.val_class != dw_val_class_float)
3647         {
3648           if (flag_verbose_asm)
3649             {
3650               fprintf (asm_out_file, "\t%s %s",
3651                        ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
3652             }
3653           fputc ('\n', asm_out_file);
3654         }
3655     }
3656   for (c = die->die_child; c != NULL; c = c->die_sib)
3657     {
3658       output_die (c);
3659     }
3660   if (die->die_child != NULL)
3661     {
3662       /* Add null byte to terminate sibling list. */
3663       ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
3664       if (flag_verbose_asm)
3665         fprintf (asm_out_file, "\t%s end of children of DIE 0x%x",
3666                  ASM_COMMENT_START, die->die_offset);
3667       fputc ('\n', asm_out_file);
3668     }
3669 }
3670
3671 /* Output the compilation unit that appears at the beginning of the
3672    .debug_info section, and precedes the DIE descriptions.  */
3673 static void
3674 output_compilation_unit_header ()
3675 {
3676   ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
3677   if (flag_verbose_asm)
3678     {
3679       fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
3680                ASM_COMMENT_START);
3681     }
3682   fputc ('\n', asm_out_file);
3683   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
3684   if (flag_verbose_asm)
3685     {
3686       fprintf (asm_out_file, "\t%s DWARF version number",
3687                ASM_COMMENT_START);
3688     }
3689   fputc ('\n', asm_out_file);
3690   ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (ABBREV_SECTION));
3691   if (flag_verbose_asm)
3692     {
3693       fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
3694                ASM_COMMENT_START);
3695     }
3696   fputc ('\n', asm_out_file);
3697   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
3698   if (flag_verbose_asm)
3699     {
3700       fprintf (asm_out_file, "\t%s Pointer Size (in bytes)",
3701                ASM_COMMENT_START);
3702     }
3703   fputc ('\n', asm_out_file);
3704 }
3705
3706 /* Generate a new label for the CFI info to refer to.  */
3707
3708 char *
3709 dwarf2out_cfi_label ()
3710 {
3711   static char label[20];
3712   static unsigned long label_num = 0;
3713
3714   ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
3715   ASM_OUTPUT_LABEL (asm_out_file, label);
3716
3717   return label;
3718 }
3719
3720 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
3721    or to the CIE if LABEL is NULL.  */
3722
3723 static void
3724 add_fde_cfi (label, cfi)
3725      register char * label;
3726      register dw_cfi_ref cfi;
3727 {
3728   if (label)
3729     {
3730       register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
3731       if (*label == 0)
3732         label = dwarf2out_cfi_label ();
3733       if (fde->dw_fde_current_label == NULL
3734           || strcmp (label, fde->dw_fde_current_label) != 0)
3735         {
3736           register dw_cfi_ref xcfi;
3737
3738           fde->dw_fde_current_label = label = xstrdup (label);
3739
3740           /* Set the location counter to the new label.  */
3741           xcfi = new_cfi ();
3742           xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
3743           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
3744           add_cfi (&fde->dw_fde_cfi, xcfi);
3745         }
3746       add_cfi (&fde->dw_fde_cfi, cfi);
3747     }
3748   else
3749     add_cfi (&cie_cfi_head, cfi);
3750 }
3751
3752 /* Subroutine of lookup_cfa.  */
3753 inline void
3754 lookup_cfa_1 (cfi, regp, offsetp)
3755      register dw_cfi_ref cfi;
3756      register unsigned long *regp;
3757      register long *offsetp;
3758 {
3759   switch (cfi->dw_cfi_opc)
3760     {
3761     case DW_CFA_def_cfa_offset:
3762       *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
3763       break;
3764     case DW_CFA_def_cfa_register:
3765       *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
3766       break;
3767     case DW_CFA_def_cfa:
3768       *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
3769       *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
3770       break;
3771     }
3772 }
3773
3774 /* Find the previous value for the CFA.  */
3775 static void
3776 lookup_cfa (regp, offsetp)
3777      register unsigned long *regp;
3778      register long *offsetp;
3779 {
3780   register dw_cfi_ref cfi;
3781   *regp = (unsigned long) -1;
3782   *offsetp = 0;
3783
3784   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
3785     lookup_cfa_1 (cfi, regp, offsetp);
3786   if (fde_table_in_use)
3787     {
3788       register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
3789       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
3790         lookup_cfa_1 (cfi, regp, offsetp);
3791     }
3792 }
3793
3794 /* Entry point to update the canonical frame address (CFA).
3795    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
3796    calculated from REG+OFFSET.  */
3797
3798 void
3799 dwarf2out_def_cfa (label, reg, offset)
3800      register char * label;
3801      register unsigned reg;
3802      register long offset;
3803 {
3804   register dw_cfi_ref cfi;
3805   unsigned old_reg;
3806   long old_offset;
3807
3808   reg = DWARF_FRAME_REGNUM (reg);
3809   lookup_cfa (&old_reg, &old_offset);
3810
3811   if (reg == old_reg && offset == old_offset)
3812     return;
3813
3814   cfi = new_cfi ();
3815
3816   if (reg == old_reg)
3817     {
3818       cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
3819       cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
3820     }
3821 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
3822   else if (offset == old_offset && old_reg != (unsigned long) -1)
3823     {
3824       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
3825       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
3826     }
3827 #endif
3828   else
3829     {
3830       cfi->dw_cfi_opc = DW_CFA_def_cfa;
3831       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
3832       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
3833     }
3834
3835   add_fde_cfi (label, cfi);
3836 }
3837
3838 /* Add the CFI for saving a register.  REG is the CFA column number.
3839    LABEL is passed to add_fde_cfi.
3840    If SREG is -1, the register is saved at OFFSET from the CFA;
3841    otherwise it is saved in SREG.  */
3842
3843 static void
3844 reg_save (label, reg, sreg, offset)
3845      register char * label;
3846      register unsigned reg;
3847      register unsigned sreg;
3848      register long offset;
3849 {
3850   register dw_cfi_ref cfi = new_cfi ();
3851
3852   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
3853
3854   if (sreg == -1)
3855     {
3856       if (reg & ~0x3f)
3857         /* The register number won't fit in 6 bits, so we have to use
3858            the long form.  */
3859         cfi->dw_cfi_opc = DW_CFA_offset_extended;
3860       else
3861         cfi->dw_cfi_opc = DW_CFA_offset;
3862
3863       offset /= DWARF_CIE_DATA_ALIGNMENT;
3864       assert (offset >= 0);
3865       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
3866     }
3867   else
3868     {
3869       cfi->dw_cfi_opc = DW_CFA_register;
3870       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
3871     }
3872
3873   add_fde_cfi (label, cfi);
3874 }
3875
3876 /* Entry point for saving a register.  REG is the GCC register number.
3877    LABEL and OFFSET are passed to reg_save.  */
3878
3879 void
3880 dwarf2out_reg_save (label, reg, offset)
3881      register char * label;
3882      register unsigned reg;
3883      register long offset;
3884 {
3885   reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
3886 }
3887
3888 /* Record the initial position of the return address.  RTL is
3889    INCOMING_RETURN_ADDR_RTX.  */
3890
3891 static void
3892 initial_return_save (rtl)
3893      register rtx rtl;
3894 {
3895   unsigned reg = -1;
3896   long offset = 0;
3897
3898   switch (GET_CODE (rtl))
3899     {
3900     case REG:
3901       /* RA is in a register.  */
3902       reg = reg_number (rtl);
3903       break;
3904     case MEM:
3905       /* RA is on the stack.  */
3906       rtl = XEXP (rtl, 0);
3907       switch (GET_CODE (rtl))
3908         {
3909         case REG:
3910           assert (REGNO (rtl) == STACK_POINTER_REGNUM);
3911           offset = 0;
3912           break;
3913         case PLUS:
3914           assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
3915           offset = INTVAL (XEXP (rtl, 1));
3916           break;
3917         case MINUS:
3918           assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
3919           offset = -INTVAL (XEXP (rtl, 1));
3920           break;
3921         default:
3922           abort ();
3923         }
3924       break;
3925     default:
3926       abort ();
3927     }
3928
3929   reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset);
3930 }
3931
3932 /* Record call frame debugging information for INSN, which either
3933    sets SP or FP (adjusting how we calculate the frame address) or saves a
3934    register to the stack.  If INSN is NULL_RTX, initialize our state.  */
3935
3936 void
3937 dwarf2out_frame_debug (insn)
3938      rtx insn;
3939 {
3940   char *label;
3941   rtx src, dest;
3942   long offset;
3943
3944   /* The current rule for calculating the DWARF2 canonical frame address.  */
3945   static unsigned cfa_reg;
3946   static long cfa_offset;
3947
3948   /* The register used for saving registers to the stack, and its offset
3949      from the CFA.  */
3950   static unsigned cfa_store_reg;
3951   static long cfa_store_offset;
3952
3953   /* A temporary register used in adjusting SP or setting up the store_reg.  */
3954   static unsigned cfa_temp_reg;
3955   static long cfa_temp_value;
3956
3957   if (insn == NULL_RTX)
3958     {
3959       /* Set up state for generating call frame debug info.  */
3960       cfa_reg = STACK_POINTER_REGNUM;
3961       cfa_offset = 0;
3962       cfa_store_reg = STACK_POINTER_REGNUM;
3963       cfa_store_offset = 0;
3964       cfa_temp_reg = -1;
3965       cfa_temp_value = 0;
3966       return;
3967     }
3968
3969   label = dwarf2out_cfi_label ();
3970
3971   insn = PATTERN (insn);
3972   assert (GET_CODE (insn) == SET);
3973
3974   src = SET_SRC (insn);
3975   dest = SET_DEST (insn);
3976
3977   switch (GET_CODE (dest))
3978     {
3979     case REG:
3980       /* Update the CFA rule wrt SP or FP.  Make sure src is
3981          relative to the current CFA register.  */
3982       switch (GET_CODE (src))
3983         {
3984           /* Setting FP from SP.  */
3985         case REG:
3986           assert (cfa_reg == REGNO (src));
3987           assert (REGNO (dest) == STACK_POINTER_REGNUM
3988                   || frame_pointer_needed && REGNO (dest) == FRAME_POINTER_REGNUM);
3989           cfa_reg = REGNO (dest);
3990           break;
3991
3992         case PLUS:
3993         case MINUS:
3994           if (dest == stack_pointer_rtx)
3995             {
3996               /* Adjusting SP.  */
3997               switch (GET_CODE (XEXP (src, 1)))
3998                 {
3999                 case CONST_INT:
4000                   offset = INTVAL (XEXP (src, 1));
4001                   break;
4002                 case REG:
4003                   assert (REGNO (XEXP (src, 1)) == cfa_temp_reg);
4004                   offset = cfa_temp_value;
4005                   break;
4006                 default:
4007                   abort ();
4008                 }
4009               if (GET_CODE (src) == PLUS)
4010                 offset = -offset;
4011               if (cfa_reg == STACK_POINTER_REGNUM)
4012                 cfa_offset += offset;
4013               if (cfa_store_reg == STACK_POINTER_REGNUM)
4014                 cfa_store_offset += offset;
4015               assert (XEXP (src, 0) == stack_pointer_rtx);
4016             }
4017           else
4018             {
4019               /* Initializing the store base register.  */
4020               assert (GET_CODE (src) == PLUS);
4021               assert (XEXP (src, 1) == stack_pointer_rtx);
4022               assert (GET_CODE (XEXP (src, 0)) == REG
4023                       && REGNO (XEXP (src, 0)) == cfa_temp_reg);
4024               assert (cfa_store_reg == STACK_POINTER_REGNUM);
4025               cfa_store_reg = REGNO (dest);
4026               cfa_store_offset -= cfa_temp_value;
4027             }
4028           break;
4029
4030         case CONST_INT:
4031           cfa_temp_reg = REGNO (dest);
4032           cfa_temp_value = INTVAL (src);
4033           break;
4034
4035         default:
4036           abort ();
4037         }
4038       dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
4039       break;
4040
4041     case MEM:
4042       /* Saving a register to the stack.  Make sure dest is relative to the
4043          CFA register.  */
4044       assert (GET_CODE (src) == REG);
4045       switch (GET_CODE (XEXP (dest, 0)))
4046         {
4047           /* With a push.  */
4048         case PRE_INC:
4049         case PRE_DEC:
4050           offset = GET_MODE_SIZE (GET_MODE (dest));
4051           if (GET_CODE (src) == PRE_INC)
4052             offset = -offset;
4053           assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM);
4054           assert (cfa_store_reg == STACK_POINTER_REGNUM);
4055           cfa_store_offset += offset;
4056           if (cfa_reg == STACK_POINTER_REGNUM)
4057             cfa_offset = cfa_store_offset;
4058           offset = -cfa_store_offset;
4059           break;
4060
4061           /* With an offset.  */
4062         case PLUS:
4063         case MINUS:
4064           offset = INTVAL (XEXP (XEXP (dest, 0), 1));
4065           if (GET_CODE (src) == MINUS)
4066             offset = -offset;
4067           assert (cfa_store_reg == REGNO (XEXP (XEXP (dest, 0), 0)));
4068           offset -= cfa_store_offset;
4069           break;
4070
4071         default:
4072           abort ();
4073         }
4074       dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
4075       dwarf2out_reg_save (label, REGNO (src), offset);
4076       break;
4077
4078     default:
4079       abort ();
4080     }
4081 }
4082
4083 /* Return the size of a Call Frame Instruction.  */
4084 static unsigned long
4085 size_of_cfi (cfi)
4086      dw_cfi_ref cfi;
4087 {
4088   register unsigned long size;
4089   /* count the 1-byte opcode */
4090   size = 1;
4091   switch (cfi->dw_cfi_opc)
4092     {
4093     case DW_CFA_offset:
4094       size += size_of_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_offset);
4095       break;
4096     case DW_CFA_set_loc:
4097       size += PTR_SIZE;
4098       break;
4099     case DW_CFA_advance_loc1:
4100       size += 1;
4101       break;
4102     case DW_CFA_advance_loc2:
4103       size += 2;
4104       break;
4105     case DW_CFA_advance_loc4:
4106       size += 4;
4107       break;
4108 #ifdef MIPS_DEBUGGING_INFO
4109     case DW_CFA_MIPS_advance_loc8:
4110       size += 8;
4111       break;
4112 #endif
4113     case DW_CFA_offset_extended:
4114     case DW_CFA_def_cfa:
4115       size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4116       size += size_of_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_offset);
4117       break;
4118     case DW_CFA_restore_extended:
4119     case DW_CFA_undefined:
4120       size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4121       break;
4122     case DW_CFA_same_value:
4123     case DW_CFA_def_cfa_register:
4124       size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4125       break;
4126     case DW_CFA_register:
4127       size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4128       size += size_of_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
4129       break;
4130     case DW_CFA_def_cfa_offset:
4131       size += size_of_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_offset);
4132       break;
4133     default:
4134       break;
4135     }
4136     return size;
4137 }
4138
4139 /* Return the size of an FDE sans the length word.  */
4140 inline unsigned long
4141 size_of_fde (fde, npad)
4142     dw_fde_ref fde;
4143     unsigned long *npad;
4144 {
4145   register dw_cfi_ref cfi;
4146   register unsigned long aligned_size;
4147   register unsigned long size;
4148   size = DWARF_FDE_HEADER_SIZE;
4149   for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
4150     {
4151         size += size_of_cfi(cfi);
4152     }
4153   /* Round the size up to a word boundary.  */
4154   aligned_size = DWARF_ROUND (size, PTR_SIZE);
4155   *npad = aligned_size - size;
4156   return aligned_size;
4157 }
4158
4159 /* Calculate the size of the FDE table, and establish the offset
4160    of each FDE in the .debug_frame section.  */
4161 static void
4162 calc_fde_sizes ()
4163 {
4164   register unsigned long i;
4165   register dw_fde_ref fde;
4166   register unsigned long fde_size;
4167   register dw_cfi_ref cfi;
4168   unsigned long fde_pad;
4169
4170   cie_size = DWARF_CIE_HEADER_SIZE;
4171   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
4172     cie_size += size_of_cfi (cfi);
4173
4174   /* Initialize the beginning FDE offset.  */
4175   next_fde_offset = DWARF_ROUND (cie_size, PTR_SIZE);
4176
4177   for (i = 0; i < fde_table_in_use; ++i)
4178     {
4179       fde = &fde_table[i];
4180       fde->dw_fde_offset = next_fde_offset;
4181       fde_size = size_of_fde (fde, &fde_pad);
4182       next_fde_offset += fde_size;
4183     }
4184 }
4185
4186 /* Output a Call Frame Information opcode and its operand(s).  */
4187 static void
4188 output_cfi (cfi, fde)
4189      register dw_cfi_ref cfi;
4190      register dw_fde_ref fde;
4191 {
4192   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
4193     {
4194       ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4195                               cfi->dw_cfi_opc
4196                               | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
4197       if (flag_verbose_asm)
4198         fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%x",
4199                  ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
4200       fputc ('\n', asm_out_file);
4201     }
4202   else if (cfi->dw_cfi_opc == DW_CFA_offset)
4203     {
4204       ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4205                               cfi->dw_cfi_opc
4206                               | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
4207       if (flag_verbose_asm)
4208         fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%x",
4209                  ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4210       fputc ('\n', asm_out_file);
4211       output_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_offset);
4212       fputc ('\n', asm_out_file);
4213     }
4214   else if (cfi->dw_cfi_opc == DW_CFA_restore)
4215     {
4216       ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4217                               cfi->dw_cfi_opc
4218                               | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
4219       if (flag_verbose_asm)
4220         fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%x",
4221                  ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4222       fputc ('\n', asm_out_file);
4223     }
4224   else
4225     {
4226       ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
4227       if (flag_verbose_asm)
4228         {
4229           fprintf (asm_out_file, "\t%s %s",
4230                    ASM_COMMENT_START,
4231                    dwarf_cfi_name (cfi->dw_cfi_opc));
4232         }
4233       fputc ('\n', asm_out_file);
4234       switch (cfi->dw_cfi_opc)
4235         {
4236         case DW_CFA_set_loc:
4237           ASM_OUTPUT_DWARF_ADDR (asm_out_file,
4238                                  cfi->dw_cfi_oprnd1.dw_cfi_addr);
4239           fputc ('\n', asm_out_file);
4240           break;
4241         case DW_CFA_advance_loc1:
4242           /* TODO: not currently implemented.  */
4243           abort ();
4244           break;
4245         case DW_CFA_advance_loc2:
4246           ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
4247                                  cfi->dw_cfi_oprnd1.dw_cfi_addr,
4248                                  fde->dw_fde_current_label);
4249           fputc ('\n', asm_out_file);
4250           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
4251           break;
4252         case DW_CFA_advance_loc4:
4253           ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
4254                                  cfi->dw_cfi_oprnd1.dw_cfi_addr,
4255                                  fde->dw_fde_current_label);
4256           fputc ('\n', asm_out_file);
4257           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
4258           break;
4259 #ifdef MIPS_DEBUGGING_INFO
4260         case DW_CFA_MIPS_advance_loc8:
4261           /* TODO: not currently implemented.  */
4262           abort ();
4263           break;
4264 #endif
4265         case DW_CFA_offset_extended:
4266         case DW_CFA_def_cfa:
4267           output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4268           fputc ('\n', asm_out_file);
4269           output_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_offset);
4270           fputc ('\n', asm_out_file);
4271           break;
4272         case DW_CFA_restore_extended:
4273         case DW_CFA_undefined:
4274           output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4275           fputc ('\n', asm_out_file);
4276           break;
4277         case DW_CFA_same_value:
4278         case DW_CFA_def_cfa_register:
4279           output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4280           fputc ('\n', asm_out_file);
4281           break;
4282         case DW_CFA_register:
4283           output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
4284           fputc ('\n', asm_out_file);
4285           output_uleb128(cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
4286           fputc ('\n', asm_out_file);
4287           break;
4288         case DW_CFA_def_cfa_offset:
4289           output_uleb128(cfi->dw_cfi_oprnd1.dw_cfi_offset);
4290           fputc ('\n', asm_out_file);
4291           break;
4292         default:
4293           break;
4294         }
4295      }
4296 }
4297
4298 /* Output the call frame information used to used to record information
4299    that relates to calculating the frame pointer, and records the
4300    location of saved registers.  */
4301 static void
4302 output_call_frame_info ()
4303 {
4304   register unsigned long i, j;
4305   register dw_fde_ref fde;
4306   register unsigned long fde_size;
4307   register dw_cfi_ref cfi;
4308   unsigned long fde_pad;
4309
4310   /* Only output the info if it will be interesting.  */
4311   for (i = 0; i < fde_table_in_use; ++i)
4312     if (fde_table[i].dw_fde_cfi != NULL)
4313       break;
4314   if (i == fde_table_in_use)
4315     return;
4316
4317   /* (re-)initialize the beginning FDE offset.  */
4318   next_fde_offset = DWARF_ROUND (cie_size, PTR_SIZE);
4319
4320   fputc ('\n', asm_out_file);
4321   ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
4322
4323   /* Output the CIE. */
4324   ASM_OUTPUT_DWARF_DATA (asm_out_file, next_fde_offset - DWARF_OFFSET_SIZE);
4325   if (flag_verbose_asm)
4326     {
4327       fprintf (asm_out_file, "\t%s Length of Common Information Entry",
4328                ASM_COMMENT_START);
4329     }
4330   fputc ('\n', asm_out_file);
4331   ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
4332   if (flag_verbose_asm)
4333     {
4334       fprintf (asm_out_file, "\t%s CIE Identifier Tag",
4335                ASM_COMMENT_START);
4336     }
4337   fputc ('\n', asm_out_file);
4338   if (DWARF_OFFSET_SIZE == 8)
4339     {
4340       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
4341       fputc ('\n', asm_out_file);
4342     }
4343   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
4344   if (flag_verbose_asm)
4345     {
4346       fprintf (asm_out_file, "\t%s CIE Version",
4347                ASM_COMMENT_START);
4348     }
4349   fputc ('\n', asm_out_file);
4350   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4351   if (flag_verbose_asm)
4352     {
4353       fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
4354                ASM_COMMENT_START);
4355     }
4356   fputc ('\n', asm_out_file);
4357   output_uleb128 (1);
4358   if (flag_verbose_asm)
4359     fprintf (asm_out_file, " (CIE Code Alignment Factor)");
4360   fputc ('\n', asm_out_file);
4361   output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
4362   if (flag_verbose_asm)
4363     fprintf (asm_out_file, " (CIE Data Alignment Factor)");
4364   fputc ('\n', asm_out_file);
4365   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
4366   if (flag_verbose_asm)
4367     {
4368       fprintf (asm_out_file, "\t%s CIE RA Column",
4369                ASM_COMMENT_START);
4370     }
4371   fputc ('\n', asm_out_file);
4372
4373   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
4374     output_cfi (cfi);
4375
4376   /* Pad the CIE out to an address sized boundary.  */
4377   for (i = next_fde_offset - cie_size; i; --i)
4378     {
4379       /* Pad out to a pointer size boundary */
4380       ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CFA_nop);
4381       if (flag_verbose_asm)
4382         {
4383           fprintf (asm_out_file, "\t%s CIE DW_CFA_nop (pad)",
4384                    ASM_COMMENT_START);
4385         }
4386       fputc ('\n', asm_out_file);
4387     }
4388
4389   /* Loop through all of the FDE's.  */
4390   for (i = 0; i < fde_table_in_use; ++i)
4391     {
4392       fde = &fde_table[i];
4393       if (fde->dw_fde_cfi == NULL)
4394         continue;
4395       fde_size = size_of_fde (fde, &fde_pad);
4396       ASM_OUTPUT_DWARF_DATA (asm_out_file, fde_size - DWARF_OFFSET_SIZE);
4397       if (flag_verbose_asm)
4398         {
4399           fprintf (asm_out_file, "\t%s FDE Length",
4400                    ASM_COMMENT_START);
4401         }
4402       fputc ('\n', asm_out_file);
4403       ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
4404       if (flag_verbose_asm)
4405         {
4406           fprintf (asm_out_file, "\t%s FDE CIE offset",
4407                    ASM_COMMENT_START);
4408         }
4409       fputc ('\n', asm_out_file);
4410       ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
4411       if (flag_verbose_asm)
4412         {
4413           fprintf (asm_out_file, "\t%s FDE initial location",
4414                    ASM_COMMENT_START);
4415         }
4416       fputc ('\n', asm_out_file);
4417       ASM_OUTPUT_DWARF_ADDR_DELTA
4418         (asm_out_file, fde->dw_fde_end, fde->dw_fde_begin);
4419       if (flag_verbose_asm)
4420         {
4421           fprintf (asm_out_file, "\t%s FDE address range",
4422                    ASM_COMMENT_START);
4423         }
4424       fputc ('\n', asm_out_file);
4425
4426       /* Loop through the Call Frame Instructions associated with
4427          this FDE.  */
4428       fde->dw_fde_current_label = fde->dw_fde_begin;
4429       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
4430         output_cfi (cfi, fde);
4431
4432       /* Pad to a double word boundary.  */
4433       for (j = 0; j < fde_pad; ++j)
4434         {
4435           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CFA_nop);
4436           if (flag_verbose_asm)
4437             {
4438               fprintf (asm_out_file, "\t%s CIE DW_CFA_nop (pad)",
4439                        ASM_COMMENT_START);
4440             }
4441           fputc ('\n', asm_out_file);
4442         }
4443     }
4444 }
4445
4446 /* The DWARF2 pubname for a nested thingy looks like "A::f".  The output
4447    of decl_printable_name for C++ looks like "A::f(int)".  Let's drop the
4448    argument list, and maybe the scope.  */
4449
4450 static char*
4451 dwarf2_name (decl, scope)
4452      tree decl;
4453      int scope;
4454 {
4455   return (*decl_printable_name) (decl, scope ? 1 : 0);
4456 }
4457
4458 /* Add a new entry to .debug_pubnames if appropriate.  */
4459 static void
4460 add_pubname (decl, die)
4461      tree decl;
4462      dw_die_ref die;
4463 {
4464   pubname_ref p;
4465
4466   if (! TREE_PUBLIC (decl))
4467     return;
4468
4469   if (pubname_table_in_use == pubname_table_allocated)
4470     {
4471       pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
4472       pubname_table = (pubname_ref) xrealloc
4473         (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
4474     }
4475   p = &pubname_table[pubname_table_in_use++];
4476   p->die = die;
4477
4478   p->name = xstrdup (dwarf2_name (decl, 1));
4479 }
4480
4481 /* Output the public names table used to speed up access to externally
4482    visible names.  For now, only generate entries for externally
4483    visible procedures.  */
4484 static void
4485 output_pubnames ()
4486 {
4487   register unsigned i;
4488   {
4489     register unsigned long pubnames_length = size_of_pubnames ();
4490     ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
4491   }
4492   if (flag_verbose_asm)
4493     {
4494       fprintf (asm_out_file, "\t%s Length of Public Names Info.",
4495                ASM_COMMENT_START);
4496     }
4497   fputc ('\n', asm_out_file);
4498   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
4499   if (flag_verbose_asm)
4500     {
4501       fprintf (asm_out_file, "\t%s DWARF Version",
4502                ASM_COMMENT_START);
4503     }
4504   fputc ('\n', asm_out_file);
4505   ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_SECTION));
4506   if (flag_verbose_asm)
4507     {
4508       fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
4509                ASM_COMMENT_START);
4510     }
4511   fputc ('\n', asm_out_file);
4512   ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
4513   if (flag_verbose_asm)
4514     {
4515       fprintf (asm_out_file, "\t%s Compilation Unit Length",
4516                ASM_COMMENT_START);
4517     }
4518   fputc ('\n', asm_out_file);
4519   for (i = 0; i < pubname_table_in_use; ++i)
4520     {
4521       register pubname_ref pub = &pubname_table[i];
4522       ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
4523       if (flag_verbose_asm)
4524         {
4525           fprintf (asm_out_file, "\t%s DIE offset",
4526                    ASM_COMMENT_START);
4527         }
4528       fputc ('\n', asm_out_file);
4529
4530       ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
4531       if (flag_verbose_asm)
4532         {
4533           fprintf (asm_out_file, "%s external name",
4534                    ASM_COMMENT_START);
4535         }
4536       fputc ('\n', asm_out_file);
4537     }
4538   ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
4539   fputc ('\n', asm_out_file);
4540 }
4541
4542 /* Add a new entry to .debug_aranges if appropriate.  */
4543 static void
4544 add_arange (decl, die)
4545      tree decl;
4546      dw_die_ref die;
4547 {
4548   if (! DECL_SECTION_NAME (decl))
4549     return;
4550
4551   if (arange_table_in_use == arange_table_allocated)
4552     {
4553       arange_table_allocated += ARANGE_TABLE_INCREMENT;
4554       arange_table = (arange_ref) xrealloc
4555         (arange_table, arange_table_allocated * sizeof (dw_die_ref));
4556     }
4557   arange_table[arange_table_in_use++] = die;
4558 }
4559
4560 /* Output the information that goes into the .debug_aranges table.
4561    Namely, define the beginning and ending address range of the
4562    text section generated for this compilation unit.  */
4563 static void
4564 output_aranges ()
4565 {
4566   register unsigned i;
4567   {
4568     register unsigned long aranges_length = size_of_aranges ();
4569     ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
4570   }
4571   if (flag_verbose_asm)
4572     {
4573       fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
4574                ASM_COMMENT_START);
4575     }
4576   fputc ('\n', asm_out_file);
4577   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
4578   if (flag_verbose_asm)
4579     {
4580       fprintf (asm_out_file, "\t%s DWARF Version",
4581                ASM_COMMENT_START);
4582     }
4583   fputc ('\n', asm_out_file);
4584   ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_SECTION));
4585   if (flag_verbose_asm)
4586     {
4587       fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
4588                ASM_COMMENT_START);
4589     }
4590   fputc ('\n', asm_out_file);
4591   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
4592   if (flag_verbose_asm)
4593     {
4594       fprintf (asm_out_file, "\t%s Size of Address",
4595                ASM_COMMENT_START);
4596     }
4597   fputc ('\n', asm_out_file);
4598   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4599   if (flag_verbose_asm)
4600     {
4601       fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
4602                ASM_COMMENT_START);
4603     }
4604   fputc ('\n', asm_out_file);
4605   ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
4606   if (PTR_SIZE == 8)
4607     fprintf (asm_out_file, ",0,0");
4608   if (flag_verbose_asm)
4609     {
4610       fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
4611                ASM_COMMENT_START, 2 * PTR_SIZE);
4612     }
4613   fputc ('\n', asm_out_file);
4614   ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
4615   if (flag_verbose_asm)
4616     {
4617       fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
4618     }
4619   fputc ('\n', asm_out_file);
4620   ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label, TEXT_SECTION);
4621   if (flag_verbose_asm)
4622     {
4623       fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
4624     }
4625   fputc ('\n', asm_out_file);
4626   for (i = 0; i < arange_table_in_use; ++i)
4627     {
4628       dw_die_ref a = arange_table[i];
4629       if (a->die_tag == DW_TAG_subprogram)
4630         ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a));
4631       else
4632         {
4633           char *name = get_AT_string (a, DW_AT_MIPS_linkage_name);
4634           if (! name)
4635             name = get_AT_string (a, DW_AT_name);
4636           ASM_OUTPUT_DWARF_ADDR (asm_out_file, name);
4637         }
4638       if (flag_verbose_asm)
4639         {
4640           fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
4641         }
4642       fputc ('\n', asm_out_file);
4643       if (a->die_tag == DW_TAG_subprogram)
4644         ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a),
4645                                      get_AT_low_pc (a));
4646       else
4647         ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
4648                                     get_AT_unsigned (a, DW_AT_byte_size));
4649       if (flag_verbose_asm)
4650         {
4651           fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
4652         }
4653       fputc ('\n', asm_out_file);
4654     }
4655   /* Output the terminator words.  */
4656   ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
4657   fputc ('\n', asm_out_file);
4658   ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
4659   fputc ('\n', asm_out_file);
4660 }
4661
4662 /* Output the source line number correspondence information.  This
4663    information goes into the .debug_line section.  */
4664 static void
4665 output_line_info ()
4666 {
4667   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
4668   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
4669   register unsigned opc;
4670   register unsigned n_op_args;
4671   register unsigned long ft_index;
4672   register unsigned long lt_index;
4673   register unsigned long current_line;
4674   register long line_offset;
4675   register long line_delta;
4676   register unsigned long current_file;
4677   register unsigned long function;
4678   ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ());
4679   if (flag_verbose_asm)
4680     {
4681       fprintf (asm_out_file, "\t%s Length of Source Line Info.",
4682                ASM_COMMENT_START);
4683     }
4684   fputc ('\n', asm_out_file);
4685   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
4686   if (flag_verbose_asm)
4687     {
4688       fprintf (asm_out_file, "\t%s DWARF Version",
4689                ASM_COMMENT_START);
4690     }
4691   fputc ('\n', asm_out_file);
4692   ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
4693   if (flag_verbose_asm)
4694     {
4695       fprintf (asm_out_file, "\t%s Prolog Length",
4696                ASM_COMMENT_START);
4697     }
4698   fputc ('\n', asm_out_file);
4699   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
4700   if (flag_verbose_asm)
4701     {
4702       fprintf (asm_out_file, "\t%s Minimum Instruction Length",
4703                ASM_COMMENT_START);
4704     }
4705   fputc ('\n', asm_out_file);
4706   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
4707   if (flag_verbose_asm)
4708     {
4709       fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
4710                ASM_COMMENT_START);
4711     }
4712   fputc ('\n', asm_out_file);
4713   fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
4714   if (flag_verbose_asm)
4715     {
4716       fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
4717                ASM_COMMENT_START);
4718     }
4719   fputc ('\n', asm_out_file);
4720   fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
4721   if (flag_verbose_asm)
4722     {
4723       fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
4724                ASM_COMMENT_START);
4725     }
4726   fputc ('\n', asm_out_file);
4727   fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
4728   if (flag_verbose_asm)
4729     {
4730       fprintf (asm_out_file, "\t%s Special Opcode Base",
4731                ASM_COMMENT_START);
4732     }
4733   fputc ('\n', asm_out_file);
4734   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
4735     {
4736       switch (opc)
4737         {
4738         case DW_LNS_advance_pc:
4739         case DW_LNS_advance_line:
4740         case DW_LNS_set_file:
4741         case DW_LNS_set_column:
4742         case DW_LNS_fixed_advance_pc:
4743           n_op_args = 1;
4744           break;
4745         default:
4746           n_op_args = 0;
4747           break;
4748         }
4749       ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
4750       if (flag_verbose_asm)
4751         {
4752           fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
4753                    ASM_COMMENT_START, opc, n_op_args);
4754         }
4755       fputc ('\n', asm_out_file);
4756     }
4757   if (flag_verbose_asm)
4758     {
4759       fprintf (asm_out_file, "%s Include Directory Table\n",
4760                ASM_COMMENT_START);
4761     }
4762   /* Include directory table is empty, at present */
4763   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4764   fputc ('\n', asm_out_file);
4765   if (flag_verbose_asm)
4766     {
4767       fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
4768     }
4769   for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4770     {
4771       ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
4772       if (flag_verbose_asm)
4773         {
4774           fprintf (asm_out_file, "%s File Entry: 0x%x",
4775                    ASM_COMMENT_START, ft_index);
4776         }
4777       fputc ('\n', asm_out_file);
4778       /* Include directory index */
4779       output_uleb128 (0);
4780       fputc ('\n', asm_out_file);
4781       /* Modification time */
4782       output_uleb128 (0);
4783       fputc ('\n', asm_out_file);
4784       /* File length in bytes */
4785       output_uleb128 (0);
4786       fputc ('\n', asm_out_file);
4787     }
4788   /* Terminate the file name table */
4789   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4790   fputc ('\n', asm_out_file);
4791
4792   /* Set the address register to the first location in the text section */
4793   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4794   if (flag_verbose_asm)
4795     {
4796       fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
4797     }
4798   fputc ('\n', asm_out_file);
4799   output_uleb128 (1 + PTR_SIZE);
4800   fputc ('\n', asm_out_file);
4801   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
4802   fputc ('\n', asm_out_file);
4803   ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
4804   fputc ('\n', asm_out_file);
4805
4806   /* Generate the line number to PC correspondence table, encoded as
4807      a series of state machine operations.  */
4808   current_file = 1;
4809   current_line = 1;
4810   strcpy (prev_line_label, TEXT_SECTION);
4811   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
4812     {
4813       register dw_line_info_ref line_info;
4814       ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
4815       if (flag_verbose_asm)
4816         {
4817           fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
4818                    ASM_COMMENT_START);
4819         }
4820       fputc ('\n', asm_out_file);
4821       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
4822       ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
4823       fputc ('\n', asm_out_file);
4824       line_info = &line_info_table[lt_index];
4825       if (line_info->dw_file_num != current_file)
4826         {
4827           current_file = line_info->dw_file_num;
4828           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
4829           if (flag_verbose_asm)
4830             {
4831               fprintf (asm_out_file,
4832                        "\t%s DW_LNS_set_file", ASM_COMMENT_START);
4833             }
4834           fputc ('\n', asm_out_file);
4835           output_uleb128 (current_file);
4836           if (flag_verbose_asm)
4837             fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
4838           fputc ('\n', asm_out_file);
4839         }
4840       line_offset = line_info->dw_line_num - current_line;
4841       line_delta = line_offset - DWARF_LINE_BASE;
4842       current_line = line_info->dw_line_num;
4843       if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4844         {
4845           ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4846                                   DWARF_LINE_OPCODE_BASE + line_delta);
4847           if (flag_verbose_asm)
4848             {
4849               fprintf (asm_out_file,
4850                        "\t%s line %d", ASM_COMMENT_START, current_line);
4851             }
4852           fputc ('\n', asm_out_file);
4853         }
4854       else
4855         {
4856           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
4857           if (flag_verbose_asm)
4858             {
4859               fprintf (asm_out_file,
4860                        "\t%s advance to line %d",
4861                        ASM_COMMENT_START, current_line);
4862             }
4863           fputc ('\n', asm_out_file);
4864           output_sleb128 (line_offset);
4865           fputc ('\n', asm_out_file);
4866           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
4867           fputc ('\n', asm_out_file);
4868         }
4869       strcpy (prev_line_label, line_label);
4870     }
4871
4872   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
4873   if (flag_verbose_asm)
4874     {
4875       fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
4876                ASM_COMMENT_START);
4877     }
4878   fputc ('\n', asm_out_file);
4879   ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
4880   fputc ('\n', asm_out_file);
4881
4882   /* Output the marker for the end of the line number info.  */
4883   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4884   if (flag_verbose_asm)
4885     {
4886       fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
4887     }
4888   fputc ('\n', asm_out_file);
4889   output_uleb128 (1);
4890   fputc ('\n', asm_out_file);
4891   ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
4892   fputc ('\n', asm_out_file);
4893
4894   function = 0;
4895   current_file = 1;
4896   current_line = 1;
4897   for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
4898     {
4899       register dw_separate_line_info_ref line_info
4900         = &separate_line_info_table[lt_index];
4901       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
4902                                    lt_index);
4903       if (function != line_info->function)
4904         {
4905           function = line_info->function;
4906           /* Set the address register to the first line in the function */
4907           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4908           if (flag_verbose_asm)
4909             fprintf (asm_out_file, "\t%s DW_LNE_set_address",
4910                      ASM_COMMENT_START);
4911           fputc ('\n', asm_out_file);
4912           output_uleb128 (1 + PTR_SIZE);
4913           fputc ('\n', asm_out_file);
4914           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
4915           fputc ('\n', asm_out_file);
4916           ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
4917           fputc ('\n', asm_out_file);
4918         }
4919       else
4920         {
4921           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
4922           if (flag_verbose_asm)
4923             fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
4924                      ASM_COMMENT_START);
4925           fputc ('\n', asm_out_file);
4926           ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
4927           fputc ('\n', asm_out_file);
4928         }
4929       if (line_info->dw_file_num != current_file)
4930         {
4931           current_file = line_info->dw_file_num;
4932           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
4933           if (flag_verbose_asm)
4934             {
4935               fprintf (asm_out_file,
4936                        "\t%s DW_LNS_set_file", ASM_COMMENT_START);
4937             }
4938           fputc ('\n', asm_out_file);
4939           output_uleb128 (current_file);
4940           if (flag_verbose_asm)
4941             fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
4942           fputc ('\n', asm_out_file);
4943         }
4944       if (line_info->dw_line_num != current_line)
4945         {
4946           line_offset = line_info->dw_line_num - current_line;
4947           line_delta = line_offset - DWARF_LINE_BASE;
4948           current_line = line_info->dw_line_num;
4949           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4950             {
4951               ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
4952                                       DWARF_LINE_OPCODE_BASE + line_delta);
4953               if (flag_verbose_asm)
4954                 {
4955                   fprintf (asm_out_file,
4956                            "\t%s line %d", ASM_COMMENT_START, current_line);
4957                 }
4958               fputc ('\n', asm_out_file);
4959             }
4960           else
4961             {
4962               ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
4963               if (flag_verbose_asm)
4964                 {
4965                   fprintf (asm_out_file,
4966                            "\t%s advance to line %d",
4967                            ASM_COMMENT_START, current_line);
4968                 }
4969               fputc ('\n', asm_out_file);
4970               output_sleb128 (line_offset);
4971               fputc ('\n', asm_out_file);
4972               ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
4973               fputc ('\n', asm_out_file);
4974             }
4975         }
4976       ++lt_index;
4977       strcpy (prev_line_label, line_label);
4978
4979       /* If we're done with a function, end its sequence.  */
4980       if (lt_index == separate_line_info_table_in_use
4981           || separate_line_info_table[lt_index].function != function)
4982         {
4983           current_file = 1;
4984           current_line = 1;
4985           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
4986           if (flag_verbose_asm)
4987             fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
4988                      ASM_COMMENT_START);
4989           fputc ('\n', asm_out_file);
4990           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
4991           ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
4992           fputc ('\n', asm_out_file);
4993
4994           /* Output the marker for the end of this sequence.  */
4995           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
4996           if (flag_verbose_asm)
4997             fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
4998                      ASM_COMMENT_START);
4999           fputc ('\n', asm_out_file);
5000           output_uleb128 (1);
5001           fputc ('\n', asm_out_file);
5002           ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
5003           fputc ('\n', asm_out_file);
5004         }
5005     }
5006 }
5007 \f
5008 /**************** attribute support utilities ********************************/
5009
5010 /*
5011  * Given a pointer to a BLOCK node return non-zero if (and only if) the node
5012  * in question represents the outermost pair of curly braces (i.e. the "body
5013  * block") of a function or method.
5014  *
5015  * For any BLOCK node representing a "body block" of a function or method, the
5016  * BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
5017  * represents the outermost (function) scope for the function or method (i.e.
5018  * the one which includes the formal parameters).  The BLOCK_SUPERCONTEXT of
5019  * *that* node in turn will point to the relevant FUNCTION_DECL node.
5020  */
5021 inline int
5022 is_body_block (stmt)
5023      register tree stmt;
5024 {
5025   if (TREE_CODE (stmt) == BLOCK)
5026     {
5027       register tree parent = BLOCK_SUPERCONTEXT (stmt);
5028
5029       if (TREE_CODE (parent) == BLOCK)
5030         {
5031           register tree grandparent = BLOCK_SUPERCONTEXT (parent);
5032
5033           if (TREE_CODE (grandparent) == FUNCTION_DECL)
5034             return 1;
5035         }
5036     }
5037   return 0;
5038 }
5039
5040 /* Given a pointer to a tree node for some base type, return a pointer to
5041    a DIE that describes the given type.
5042
5043    This routine must only be called for GCC type nodes that correspond to
5044    Dwarf base (fundamental) types.  */
5045 static dw_die_ref
5046 base_type_die (type)
5047      register tree type;
5048 {
5049   register dw_die_ref base_type_result;
5050   register char *type_name;
5051   register enum dwarf_type encoding;
5052
5053   if (TREE_CODE (type) == ERROR_MARK
5054       || TREE_CODE (type) == VOID_TYPE)
5055     return 0;
5056
5057   {
5058     register tree name = TYPE_NAME (type);
5059     if (TREE_CODE (name) == TYPE_DECL)
5060       name = DECL_NAME (name);
5061     type_name = IDENTIFIER_POINTER (name);
5062   }
5063
5064   switch (TREE_CODE (type))
5065     {
5066     case INTEGER_TYPE:
5067       /* Carefully distinguish the C character types, without messing
5068          up if the language is not C. Note that we check only for the names
5069          that contain spaces; other names might occur by coincidence in other
5070          languages.  */
5071       if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
5072              && (type == char_type_node
5073                  || ! strcmp (type_name, "signed char")
5074                  || ! strcmp (type_name, "unsigned char"))))
5075         {
5076           if (TREE_UNSIGNED (type))
5077             encoding = DW_ATE_unsigned;
5078           else
5079             encoding = DW_ATE_signed;
5080           break;
5081         }
5082       /* else fall through */
5083
5084     case CHAR_TYPE:
5085       /* GNU Pascal/Ada CHAR type.  Not used in C.  */
5086       if (TREE_UNSIGNED (type))
5087         encoding = DW_ATE_unsigned_char;
5088       else
5089         encoding = DW_ATE_signed_char;
5090       break;
5091
5092     case REAL_TYPE:
5093       encoding = DW_ATE_float;
5094       break;
5095
5096     case COMPLEX_TYPE:
5097       encoding = DW_ATE_complex_float;
5098       break;
5099
5100     case BOOLEAN_TYPE:
5101       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
5102       encoding = DW_ATE_boolean;
5103       break;
5104
5105     default:
5106       abort (); /* No other TREE_CODEs are Dwarf fundamental types.  */
5107     }
5108
5109   base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
5110   add_AT_string (base_type_result, DW_AT_name, type_name);
5111   add_AT_unsigned (base_type_result, DW_AT_byte_size,
5112                    TYPE_PRECISION (type) / BITS_PER_UNIT);
5113   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
5114
5115   return base_type_result;
5116 }
5117
5118 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
5119    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
5120    a given type is generally the same as the given type, except that if the
5121    given type is a pointer or reference type, then the root type of the given
5122    type is the root type of the "basis" type for the pointer or reference
5123    type.  (This definition of the "root" type is recursive.) Also, the root
5124    type of a `const' qualified type or a `volatile' qualified type is the
5125    root type of the given type without the qualifiers.  */
5126 static tree
5127 root_type (type)
5128      register tree type;
5129 {
5130   if (TREE_CODE (type) == ERROR_MARK)
5131     return error_mark_node;
5132
5133   switch (TREE_CODE (type))
5134     {
5135     case ERROR_MARK:
5136       return error_mark_node;
5137
5138     case POINTER_TYPE:
5139     case REFERENCE_TYPE:
5140       return type_main_variant (root_type (TREE_TYPE (type)));
5141
5142     default:
5143       return type_main_variant (type);
5144     }
5145 }
5146
5147 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
5148    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
5149 inline int
5150 is_base_type (type)
5151      register tree type;
5152 {
5153   switch (TREE_CODE (type))
5154     {
5155     case ERROR_MARK:
5156     case VOID_TYPE:
5157     case INTEGER_TYPE:
5158     case REAL_TYPE:
5159     case COMPLEX_TYPE:
5160     case BOOLEAN_TYPE:
5161     case CHAR_TYPE:
5162       return 1;
5163
5164     case SET_TYPE:
5165     case ARRAY_TYPE:
5166     case RECORD_TYPE:
5167     case UNION_TYPE:
5168     case QUAL_UNION_TYPE:
5169     case ENUMERAL_TYPE:
5170     case FUNCTION_TYPE:
5171     case METHOD_TYPE:
5172     case POINTER_TYPE:
5173     case REFERENCE_TYPE:
5174     case FILE_TYPE:
5175     case OFFSET_TYPE:
5176     case LANG_TYPE:
5177       return 0;
5178
5179     default:
5180       abort ();
5181     }
5182   return 0;
5183 }
5184
5185 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
5186    entry that chains various modifiers in front of the given type.  */
5187 static dw_die_ref
5188 modified_type_die (type, is_const_type, is_volatile_type, context_die)
5189      register tree type;
5190      register int is_const_type;
5191      register int is_volatile_type;
5192      register dw_die_ref context_die;
5193 {
5194   register enum tree_code code = TREE_CODE (type);
5195   register dw_die_ref mod_type_die = NULL;
5196   register dw_die_ref sub_die = NULL;
5197   register tree item_type;
5198
5199   if (code != ERROR_MARK)
5200     {
5201       type = build_type_variant (type, is_const_type, is_volatile_type);
5202
5203       mod_type_die = lookup_type_die (type);
5204       if (mod_type_die)
5205         return mod_type_die;
5206
5207       /* Handle C typedef types. */
5208       if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5209           && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
5210         {
5211           tree dtype = TREE_TYPE (TYPE_NAME (type));
5212           if (type == dtype)
5213             {
5214               /* For a named type, use the typedef.  */
5215               gen_type_die (type, context_die);
5216               mod_type_die = lookup_type_die (type);
5217             }
5218           else if (is_const_type < TYPE_READONLY (dtype)
5219                    || is_volatile_type < TYPE_VOLATILE (dtype))
5220             /* cv-unqualified version of named type.  Just use the unnamed
5221                type to which it refers.  */
5222             mod_type_die = modified_type_die
5223               (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
5224                is_const_type, is_volatile_type);
5225           /* else cv-qualified version of named type; fall through.  */
5226         }
5227
5228       if (mod_type_die)
5229         /* OK */;
5230       else if (is_const_type)
5231         {
5232           mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
5233           sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
5234         }
5235       else if (is_volatile_type)
5236         {
5237           mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
5238           sub_die = modified_type_die (type, 0, 0, context_die);
5239         }
5240       else if (code == POINTER_TYPE)
5241         {
5242           mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
5243           add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
5244 #if 0
5245           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
5246 #endif
5247           item_type = TREE_TYPE (type);
5248           sub_die = modified_type_die (item_type,
5249                                        TYPE_READONLY (item_type),
5250                                        TYPE_VOLATILE (item_type),
5251                                        context_die);
5252         }
5253       else if (code == REFERENCE_TYPE)
5254         {
5255           mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
5256           add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
5257 #if 0
5258           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
5259 #endif
5260           item_type = TREE_TYPE (type);
5261           sub_die = modified_type_die (item_type,
5262                                        TYPE_READONLY (item_type),
5263                                        TYPE_VOLATILE (item_type),
5264                                        context_die);
5265         }
5266       else if (is_base_type (type))
5267         {
5268           mod_type_die = base_type_die (type);
5269         }
5270       else
5271         {
5272           gen_type_die (type, context_die);
5273
5274           /* We have to get the type_main_variant here (and pass that to the
5275              `lookup_type_die' routine) because the ..._TYPE node we have
5276              might simply be a *copy* of some original type node (where the
5277              copy was created to help us keep track of typedef names) and
5278              that copy might have a different TYPE_UID from the original
5279              ..._TYPE node.  */
5280           mod_type_die = lookup_type_die (type_main_variant (type));
5281           assert (mod_type_die != NULL);
5282         }
5283     }
5284   if (sub_die != NULL)
5285     {
5286       add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
5287     }
5288   equate_type_number_to_die (type, mod_type_die);
5289   return mod_type_die;
5290 }
5291
5292 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
5293    an enumerated type.   */
5294 inline int
5295 type_is_enum (type)
5296      register tree type;
5297 {
5298   return TREE_CODE (type) == ENUMERAL_TYPE;
5299 }
5300
5301 /* Return the register number described by a given RTL node.  */
5302 static unsigned
5303 reg_number (rtl)
5304      register rtx rtl;
5305 {
5306   register unsigned regno = REGNO (rtl);
5307
5308   if (regno >= FIRST_PSEUDO_REGISTER)
5309     {
5310       warning_with_decl (dwarf_last_decl, "internal regno botch: regno = %d\n",
5311                          regno);
5312       regno = 0;
5313     }
5314   regno = DBX_REGISTER_NUMBER (regno);
5315   return regno;
5316 }
5317
5318 /* Return a location descriptor that designates a machine register.  */
5319 static dw_loc_descr_ref
5320 reg_loc_descriptor (rtl)
5321      register rtx rtl;
5322 {
5323   register dw_loc_descr_ref loc_result = NULL;
5324   register unsigned reg = reg_number (rtl);
5325   if (reg >= 0 && reg <= 31)
5326     {
5327       loc_result = new_loc_descr (DW_OP_reg0 + reg, 0);
5328     }
5329   else
5330     {
5331       loc_result = new_loc_descr (DW_OP_regx, reg, 0);
5332     }
5333   return loc_result;
5334 }
5335
5336 /* Return a location descriptor that designates a base+offset location.  */
5337 static dw_loc_descr_ref
5338 based_loc_descr (reg, offset)
5339      unsigned reg;
5340      long int offset;
5341 {
5342   register dw_loc_descr_ref loc_result;
5343   /* For the "frame base", we use the frame pointer or stack pointer
5344      registers, since the RTL for local variables is relative to one of
5345      them.  */
5346   register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
5347                                                   ? FRAME_POINTER_REGNUM
5348                                                   : STACK_POINTER_REGNUM);
5349   if (reg == fp_reg)
5350     {
5351       loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
5352     }
5353   else if (reg >= 0 && reg <= 31)
5354     {
5355       loc_result = new_loc_descr (DW_OP_breg0 + reg, offset);
5356     }
5357   else
5358     {
5359       loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
5360     }
5361   return loc_result;
5362 }
5363
5364 /* Return true if this RTL expression describes a base+offset calculation.  */
5365 inline int
5366 is_based_loc (rtl)
5367      register rtx rtl;
5368 {
5369     return GET_CODE (rtl) == PLUS
5370            && ((GET_CODE (XEXP (rtl, 0)) == REG
5371                 && GET_CODE (XEXP (rtl, 1)) == CONST_INT));
5372 }
5373
5374 /* The following routine converts the RTL for a variable or parameter
5375    (resident in memory) into an equivalent Dwarf representation of a
5376    mechanism for getting the address of that same variable onto the top of a
5377    hypothetical "address evaluation" stack.
5378    When creating memory location descriptors, we are effectively transforming
5379    the RTL for a memory-resident object into its Dwarf postfix expression
5380    equivalent.  This routine recursively descends an RTL tree, turning
5381    it into Dwarf postfix code as it goes.  */
5382 static dw_loc_descr_ref
5383 mem_loc_descriptor (rtl)
5384      register rtx rtl;
5385 {
5386   dw_loc_descr_ref mem_loc_result = NULL;
5387   /* Note that for a dynamically sized array, the location we will generate a
5388      description of here will be the lowest numbered location which is
5389      actually within the array.  That's *not* necessarily the same as the
5390      zeroth element of the array.  */
5391   switch (GET_CODE (rtl))
5392     {
5393     case SUBREG:
5394       /* The case of a subreg may arise when we have a local (register)
5395          variable or a formal (register) parameter which doesn't quite fill
5396          up an entire register.  For now, just assume that it is
5397          legitimate to make the Dwarf info refer to the whole register which
5398          contains the given subreg.  */
5399       rtl = XEXP (rtl, 0);
5400       /* Drop thru.  */
5401
5402     case REG:
5403       /* Whenever a register number forms a part of the description of the
5404          method for calculating the (dynamic) address of a memory resident
5405          object, DWARF rules require the register number be referred to as
5406          a "base register".  This distinction is not based in any way upon
5407          what category of register the hardware believes the given register
5408          belongs to.  This is strictly DWARF terminology we're dealing with
5409          here. Note that in cases where the location of a memory-resident
5410          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
5411          OP_CONST (0)) the actual DWARF location descriptor that we generate
5412          may just be OP_BASEREG (basereg).  This may look deceptively like
5413          the object in question was allocated to a register (rather than in
5414          memory) so DWARF consumers need to be aware of the subtle
5415          distinction between OP_REG and OP_BASEREG.  */
5416       mem_loc_result = based_loc_descr (reg_number (rtl), 0);
5417       break;
5418
5419     case MEM:
5420       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0));
5421       add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
5422       break;
5423
5424     case CONST:
5425     case SYMBOL_REF:
5426       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
5427       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
5428       mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
5429       break;
5430
5431     case PLUS:
5432       if (is_based_loc (rtl))
5433         {
5434           mem_loc_result = based_loc_descr (
5435                               reg_number (XEXP (rtl, 0)),
5436                               INTVAL (XEXP (rtl, 1)));
5437         }
5438       else
5439         {
5440           add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
5441           add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
5442           add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
5443         }
5444       break;
5445
5446     case MULT:
5447       /* If a pseudo-reg is optimized away, it is possible for it to
5448          be replaced with a MEM containing a multiply.  */
5449       add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
5450       add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
5451       add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
5452       break;
5453
5454     case CONST_INT:
5455       mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
5456       break;
5457
5458     default:
5459       abort ();
5460     }
5461   return mem_loc_result;
5462 }
5463
5464 /* Output a proper Dwarf location descriptor for a variable or parameter
5465    which is either allocated in a register or in a memory location.  For a
5466    register, we just generate an OP_REG and the register number.  For a
5467    memory location we provide a Dwarf postfix expression describing how to
5468    generate the (dynamic) address of the object onto the address stack.  */
5469 static dw_loc_descr_ref
5470 loc_descriptor (rtl)
5471      register rtx rtl;
5472 {
5473   dw_loc_descr_ref loc_result = NULL;
5474   switch (GET_CODE (rtl))
5475     {
5476     case SUBREG:
5477
5478       /* The case of a subreg may arise when we have a local (register)
5479          variable or a formal (register) parameter which doesn't quite fill
5480          up an entire register.       For now, just assume that it is
5481          legitimate to make the Dwarf info refer to the whole register which
5482          contains the given subreg.  */
5483
5484       rtl = XEXP (rtl, 0);
5485       /* fall through */
5486
5487     case REG:
5488       loc_result = reg_loc_descriptor (rtl);
5489       break;
5490
5491     case MEM:
5492       loc_result = mem_loc_descriptor (XEXP (rtl, 0));
5493       break;
5494
5495     default:
5496       abort ();                 /* Should never happen */
5497     }
5498   return loc_result;
5499 }
5500
5501 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
5502    which is not less than the value itself.  */
5503 inline unsigned
5504 ceiling (value, boundary)
5505      register unsigned value;
5506      register unsigned boundary;
5507 {
5508   return (((value + boundary - 1) / boundary) * boundary);
5509 }
5510
5511 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
5512    pointer to the declared type for the relevant field variable, or return
5513    `integer_type_node' if the given node turns out to be an
5514    ERROR_MARK node.  */
5515 inline tree
5516 field_type (decl)
5517      register tree decl;
5518 {
5519   register tree type;
5520
5521   if (TREE_CODE (decl) == ERROR_MARK)
5522     return integer_type_node;
5523
5524   type = DECL_BIT_FIELD_TYPE (decl);
5525   if (type == NULL)
5526     type = TREE_TYPE (decl);
5527
5528   return type;
5529 }
5530
5531 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
5532    node, return the alignment in bits for the type, or else return
5533    BITS_PER_WORD if the node actually turns out to be an
5534    ERROR_MARK node.  */
5535 inline unsigned
5536 simple_type_align_in_bits (type)
5537      register tree type;
5538 {
5539   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
5540 }
5541
5542 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
5543    node, return the size in bits for the type if it is a constant, or else
5544    return the alignment for the type if the type's size is not constant, or
5545    else return BITS_PER_WORD if the type actually turns out to be an
5546    ERROR_MARK node.  */
5547 inline unsigned
5548 simple_type_size_in_bits (type)
5549      register tree type;
5550 {
5551   if (TREE_CODE (type) == ERROR_MARK)
5552     return BITS_PER_WORD;
5553   else
5554     {
5555       register tree type_size_tree = TYPE_SIZE (type);
5556
5557       if (TREE_CODE (type_size_tree) != INTEGER_CST)
5558         return TYPE_ALIGN (type);
5559
5560       return (unsigned) TREE_INT_CST_LOW (type_size_tree);
5561     }
5562 }
5563
5564 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
5565    return the byte offset of the lowest addressed byte of the "containing
5566    object" for the given FIELD_DECL, or return 0 if we are unable to
5567    determine what that offset is, either because the argument turns out to
5568    be a pointer to an ERROR_MARK node, or because the offset is actually
5569    variable.  (We can't handle the latter case just yet).  */
5570 static unsigned
5571 field_byte_offset (decl)
5572      register tree decl;
5573 {
5574   register unsigned type_align_in_bytes;
5575   register unsigned type_align_in_bits;
5576   register unsigned type_size_in_bits;
5577   register unsigned object_offset_in_align_units;
5578   register unsigned object_offset_in_bits;
5579   register unsigned object_offset_in_bytes;
5580   register tree type;
5581   register tree bitpos_tree;
5582   register tree field_size_tree;
5583   register unsigned bitpos_int;
5584   register unsigned deepest_bitpos;
5585   register unsigned field_size_in_bits;
5586
5587   if (TREE_CODE (decl) == ERROR_MARK)
5588     return 0;
5589
5590   if (TREE_CODE (decl) != FIELD_DECL)
5591     abort ();
5592
5593   type = field_type (decl);
5594
5595   bitpos_tree = DECL_FIELD_BITPOS (decl);
5596   field_size_tree = DECL_SIZE (decl);
5597
5598   /* We cannot yet cope with fields whose positions or sizes are variable, so
5599      for now, when we see such things, we simply return 0.  Someday, we may
5600      be able to handle such cases, but it will be damn difficult.  */
5601   if (TREE_CODE (bitpos_tree) != INTEGER_CST)
5602     return 0;
5603   bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
5604
5605   if (TREE_CODE (field_size_tree) != INTEGER_CST)
5606     return 0;
5607   field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
5608
5609   type_size_in_bits = simple_type_size_in_bits (type);
5610
5611   type_align_in_bits = simple_type_align_in_bits (type);
5612   type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
5613
5614   /* Note that the GCC front-end doesn't make any attempt to keep track of
5615      the starting bit offset (relative to the start of the containing
5616      structure type) of the hypothetical "containing object" for a bit-
5617      field.  Thus, when computing the byte offset value for the start of the
5618      "containing object" of a bit-field, we must deduce this information on
5619      our own. This can be rather tricky to do in some cases.  For example,
5620      handling the following structure type definition when compiling for an
5621      i386/i486 target (which only aligns long long's to 32-bit boundaries)
5622      can be very tricky:
5623
5624          struct S { int field1; long long field2:31; };
5625
5626      Fortunately, there is a simple rule-of-thumb which can be
5627      used in such cases.  When compiling for an i386/i486, GCC will allocate
5628      8 bytes for the structure shown above.  It decides to do this based upon
5629      one simple rule for bit-field allocation.  Quite simply, GCC allocates
5630      each "containing object" for each bit-field at the first (i.e. lowest
5631      addressed) legitimate alignment boundary (based upon the required
5632      minimum alignment for the declared type of the field) which it can
5633      possibly use, subject to the condition that there is still enough
5634      available space remaining in the containing object (when allocated at
5635      the selected point) to fully accommodate all of the bits of the
5636      bit-field itself.  This simple rule makes it obvious why GCC allocates
5637      8 bytes for each object of the structure type shown above.  When looking
5638      for a place to allocate the "containing object" for `field2', the
5639      compiler simply tries to allocate a 64-bit "containing object" at each
5640      successive 32-bit boundary (starting at zero) until it finds a place to
5641      allocate that 64- bit field such that at least 31 contiguous (and
5642      previously unallocated) bits remain within that selected 64 bit field.
5643      (As it turns out, for the example above, the compiler finds that it is
5644      OK to allocate the "containing object" 64-bit field at bit-offset zero
5645      within the structure type.) Here we attempt to work backwards from the
5646      limited set of facts we're given, and we try to deduce from those facts,
5647      where GCC must have believed that the containing object started (within
5648      the structure type). The value we deduce is then used (by the callers of
5649      this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
5650      for fields (both bit-fields and, in the case of DW_AT_location, regular
5651      fields as well).  */
5652
5653   /* Figure out the bit-distance from the start of the structure to the
5654      "deepest" bit of the bit-field.  */
5655   deepest_bitpos = bitpos_int + field_size_in_bits;
5656
5657   /* This is the tricky part.  Use some fancy footwork to deduce where the
5658      lowest addressed bit of the containing object must be.  */
5659   object_offset_in_bits
5660     = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
5661
5662   /* Compute the offset of the containing object in "alignment units".  */
5663   object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
5664
5665   /* Compute the offset of the containing object in bytes.  */
5666   object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
5667
5668   return object_offset_in_bytes;
5669 }
5670
5671
5672 \f
5673 /****************************** attributes *********************************/
5674
5675 /* The following routines define various Dwarf attributes
5676    (and any data associated with them).  */
5677
5678
5679 /* Output the form of location attributes suitable for whole variables and
5680    whole parameters.  Note that the location attributes for struct fields are
5681    generated by the routine `data_member_location_attribute' below.  */
5682 static void
5683 add_location_attribute (die, rtl)
5684      dw_die_ref die;
5685      register rtx rtl;
5686 {
5687   dw_loc_descr_ref loc_descr = NULL;
5688
5689   /* Handle a special case.  If we are about to output a location descriptor
5690      for a variable or parameter which has been optimized out of existence,
5691      don't do that.  Instead we output a null location descriptor value as
5692      part of the location attribute. A variable which has been optimized out
5693      of existence will have a DECL_RTL value which denotes a pseudo-reg.
5694      Currently, in some rare cases, variables can have DECL_RTL values which
5695      look like (MEM (REG pseudo-reg#)).  These cases are due to bugs
5696      elsewhere in the compiler.  We treat such cases as if the variable(s) in
5697      question had been optimized out of existence. Note that in all cases
5698      where we wish to express the fact that a variable has been optimized out
5699      of existence, we do not simply suppress the generation of the entire
5700      location attribute because the absence of a location attribute in
5701      certain kinds of DIEs is used to indicate something else entirely...
5702      i.e. that the DIE represents an object declaration, but not a
5703      definition.  So sayeth the PLSIG.  */
5704   if (!is_pseudo_reg (rtl)
5705       && (GET_CODE (rtl) != MEM
5706           || !is_pseudo_reg (XEXP (rtl, 0))))
5707     {
5708       loc_descr = loc_descriptor (eliminate_regs (rtl, 0, NULL_RTX));
5709     }
5710
5711 #ifdef MIPS_DEBUGGING_INFO
5712   /* ??? SGI's dwarf reader is buggy, and will not accept a zero size
5713      location descriptor.  Lets just use r0 for now to represent a
5714      variable that has been optimized away.  */
5715   if (loc_descr == NULL)
5716     {
5717       loc_descr = loc_descriptor (gen_rtx (REG, word_mode, 0));
5718     }
5719 #endif
5720
5721   add_AT_loc (die, DW_AT_location, loc_descr);
5722 }
5723
5724 /* Attach the specialized form of location attribute used for data
5725    members of struct and union types.  In the special case of a
5726    FIELD_DECL node which represents a bit-field, the "offset" part
5727    of this special location descriptor must indicate the distance
5728    in bytes from the lowest-addressed byte of the containing struct
5729    or union type to the lowest-addressed byte of the "containing
5730    object" for the bit-field.  (See the `field_byte_offset' function
5731    above).. For any given bit-field, the "containing object" is a
5732    hypothetical object (of some integral or enum type) within which
5733    the given bit-field lives.  The type of this hypothetical
5734    "containing object" is always the same as the declared type of
5735    the individual bit-field itself (for GCC anyway... the DWARF
5736    spec doesn't actually mandate this).  Note that it is the size
5737    (in bytes) of the hypothetical "containing object" which will
5738    be given in the DW_AT_byte_size attribute for this bit-field.
5739    (See the `byte_size_attribute' function below.)  It is also used
5740    when calculating the value of the DW_AT_bit_offset attribute.
5741    (See the `bit_offset_attribute' function below).  */
5742 static void
5743 add_data_member_location_attribute (die, decl)
5744      register dw_die_ref die;
5745      register tree decl;
5746 {
5747   register unsigned long offset;
5748   register dw_loc_descr_ref loc_descr;
5749   register enum dwarf_location_atom op;
5750
5751   if (TREE_CODE (decl) == TREE_VEC)
5752     offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
5753   else
5754     offset = field_byte_offset (decl);
5755
5756   /* The DWARF2 standard says that we should assume that the structure address
5757      is already on the stack, so we can specify a structure field address
5758      by using DW_OP_plus_uconst.  */
5759 #ifdef MIPS_DEBUGGING_INFO
5760   /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
5761      correctly.  It works only if we leave the offset on the stack.  */
5762   op = DW_OP_constu;
5763 #else
5764   op = DW_OP_plus_uconst;
5765 #endif
5766   loc_descr = new_loc_descr (op, offset, 0);
5767   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
5768 }
5769
5770 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
5771    does not have a "location" either in memory or in a register.  These
5772    things can arise in GNU C when a constant is passed as an actual parameter
5773    to an inlined function.  They can also arise in C++ where declared
5774    constants do not necessarily get memory "homes".  */
5775 static void
5776 add_const_value_attribute (die, rtl)
5777      register dw_die_ref die;
5778      register rtx rtl;
5779 {
5780   switch (GET_CODE (rtl))
5781     {
5782     case CONST_INT:
5783       /* Note that a CONST_INT rtx could represent either an integer or a
5784          floating-point constant.  A CONST_INT is used whenever the constant
5785          will fit into a single word.  In all such cases, the original mode
5786          of the constant value is wiped out, and the CONST_INT rtx is
5787          assigned VOIDmode.  */
5788       add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
5789       break;
5790
5791     case CONST_DOUBLE:
5792       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
5793          floating-point constant.  A CONST_DOUBLE is used whenever the
5794          constant requires more than one word in order to be adequately
5795          represented.  We output CONST_DOUBLEs as blocks.  */
5796       {
5797         register enum machine_mode mode = GET_MODE (rtl);
5798
5799         if (GET_MODE_CLASS (mode) == MODE_FLOAT)
5800           {
5801             union real_extract u;
5802             jmp_buf handler;
5803             register unsigned length = GET_MODE_SIZE (mode) / 4;
5804             register long *array = (long *) xmalloc (length * sizeof (long));
5805
5806             bcopy ((char *) &CONST_DOUBLE_LOW (rtl), (char *) &u, sizeof u);
5807
5808             if (setjmp (handler))
5809               {
5810                 error ("floating point trap outputting debug info");
5811                 u.d = dconst0;
5812               }
5813
5814             set_float_handler (handler);
5815
5816             switch (mode)
5817               {
5818               case SFmode:
5819                 REAL_VALUE_TO_TARGET_SINGLE (u.d, array[0]);
5820                 break;
5821
5822               case DFmode:
5823                 REAL_VALUE_TO_TARGET_DOUBLE (u.d, array);
5824                 break;
5825
5826               case XFmode:
5827               case TFmode:
5828                 REAL_VALUE_TO_TARGET_LONG_DOUBLE (u.d, array);
5829                 break;
5830
5831               default:
5832                 abort ();
5833               }
5834
5835             set_float_handler (NULL_PTR);
5836
5837             add_AT_float (die, DW_AT_const_value, length, array);
5838           }
5839         else
5840           add_AT_long_long (die, DW_AT_const_value,
5841                             CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
5842       }
5843       break;
5844
5845     case CONST_STRING:
5846       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
5847       break;
5848
5849     case SYMBOL_REF:
5850     case LABEL_REF:
5851     case CONST:
5852       add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
5853       break;
5854
5855     case PLUS:
5856       /* In cases where an inlined instance of an inline function is passed
5857          the address of an `auto' variable (which is local to the caller) we
5858          can get a situation where the DECL_RTL of the artificial local
5859          variable (for the inlining) which acts as a stand-in for the
5860          corresponding formal parameter (of the inline function) will look
5861          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
5862          exactly a compile-time constant expression, but it isn't the address
5863          of the (artificial) local variable either.  Rather, it represents the
5864          *value* which the artificial local variable always has during its
5865          lifetime.  We currently have no way to represent such quasi-constant
5866          values in Dwarf, so for now we just punt and generate an
5867          DW_AT_const_value attribute with null address.  */
5868       add_AT_addr (die, DW_AT_const_value, addr_to_string (const0_rtx));
5869       break;
5870
5871     default:
5872       /* No other kinds of rtx should be possible here.  */
5873       abort ();
5874     }
5875
5876 }
5877
5878 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
5879    data attribute for a variable or a parameter.  We generate the
5880    DW_AT_const_value attribute only in those cases where the given variable
5881    or parameter does not have a true "location" either in memory or in a
5882    register.  This can happen (for example) when a constant is passed as an
5883    actual argument in a call to an inline function.  (It's possible that
5884    these things can crop up in other ways also.)  Note that one type of
5885    constant value which can be passed into an inlined function is a constant
5886    pointer.  This can happen for example if an actual argument in an inlined
5887    function call evaluates to a compile-time constant address.  */
5888 static void
5889 add_location_or_const_value_attribute (die, decl)
5890      register dw_die_ref die;
5891      register tree decl;
5892 {
5893   register rtx rtl;
5894   register tree declared_type;
5895   register tree passed_type;
5896
5897   if (TREE_CODE (decl) == ERROR_MARK)
5898     {
5899       return;
5900     }
5901   if ((TREE_CODE (decl) != VAR_DECL)
5902       && (TREE_CODE (decl) != PARM_DECL))
5903     {
5904       /* Should never happen.  */
5905       abort ();
5906       return;
5907     }
5908   /* Here we have to decide where we are going to say the parameter "lives"
5909      (as far as the debugger is concerned).  We only have a couple of
5910      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
5911      DECL_RTL normally indicates where the parameter lives during most of the
5912      activa- tion of the function.  If optimization is enabled however, this
5913      could be either NULL or else a pseudo-reg.  Both of those cases indicate
5914      that the parameter doesn't really live anywhere (as far as the code
5915      generation parts of GCC are concerned) during most of the function's
5916      activation.  That will happen (for example) if the parameter is never
5917      referenced within the function.  We could just generate a location
5918      descriptor here for all non-NULL non-pseudo values of DECL_RTL and
5919      ignore all of the rest, but we can be a little nicer than that if we
5920      also consider DECL_INCOMING_RTL in cases where DECL_RTL is NULL or is a
5921      pseudo-reg. Note however that we can only get away with using
5922      DECL_INCOMING_RTL as a backup substitute for DECL_RTL in certain limited
5923      cases.  In cases where DECL_ARG_TYPE(decl) indicates the same type as
5924      TREE_TYPE(decl) we can be sure that the parameter was passed using the
5925      same type as it is declared to have within the function, and that its
5926      DECL_INCOMING_RTL points us to a place where a value of that type is
5927      passed.  In cases where DECL_ARG_TYPE(decl) and TREE_TYPE(decl) are
5928      different types however, we cannot (in general) use DECL_INCOMING_RTL as
5929      a backup substitute for DECL_RTL because in these cases,
5930      DECL_INCOMING_RTL points us to a value of some type which is *different*
5931      from the type of the parameter itself.  Thus, if we tried to use
5932      DECL_INCOMING_RTL to generate a location attribute in such cases, the
5933      debugger would end up (for example) trying to fetch a `float' from a
5934      place which actually contains the first part of a `double'.  That would
5935      lead to really incorrect and confusing output at debug-time, and we
5936      don't want that now do we? So in general, we DO NOT use
5937      DECL_INCOMING_RTL as a backup for DECL_RTL in cases where
5938      DECL_ARG_TYPE(decl) != TREE_TYPE(decl).  There are a couple of cute
5939      exceptions however.  On little-endian machines we can get away with
5940      using DECL_INCOMING_RTL even when DECL_ARG_TYPE(decl) is not the same as
5941      TREE_TYPE(decl) but only when DECL_ARG_TYPE(decl) is an integral type
5942      which is smaller than TREE_TYPE(decl). These cases arise when (on a
5943      little-endian machine) a non-prototyped function has a parameter
5944      declared to be of type `short' or `char'.  In such cases,
5945      TREE_TYPE(decl) will be `short' or `char', DECL_ARG_TYPE(decl) will be
5946      `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
5947      passed `int' value.  If the debugger then uses that address to fetch a
5948      `short' or a `char' (on a little-endian machine) the result will be the
5949      correct data, so we allow for such exceptional cases below. Note that
5950      our goal here is to describe the place where the given formal parameter
5951      lives during most of the function's activation (i.e. between the end of
5952      the prologue and the start of the epilogue).  We'll do that as best as
5953      we can. Note however that if the given formal parameter is modified
5954      sometime during the execution of the function, then a stack backtrace
5955      (at debug-time) will show the function as having been called with the
5956      *new* value rather than the value which was originally passed in.  This
5957      happens rarely enough that it is not a major problem, but it *is* a
5958      problem, and I'd like to fix it.  A future version of dwarf2out.c may
5959      generate two additional attributes for any given DW_TAG_formal_parameter
5960      DIE which will describe the "passed type" and the "passed location" for
5961      the given formal parameter in addition to the attributes we now generate
5962      to indicate the "declared type" and the "active location" for each
5963      parameter.  This additional set of attributes could be used by debuggers
5964      for stack backtraces. Separately, note that sometimes DECL_RTL can be
5965      NULL and DECL_INCOMING_RTL can be NULL also.  This happens (for example)
5966      for inlined-instances of inline function formal parameters which are
5967      never referenced.  This really shouldn't be happening.  All PARM_DECL
5968      nodes should get valid non-NULL DECL_INCOMING_RTL values, but
5969      integrate.c doesn't currently generate these values for inlined
5970      instances of inline function parameters, so when we see such cases, we
5971      are just SOL (shit-out-of-luck) for the time being (until integrate.c
5972      gets fixed).  */
5973
5974   /* Use DECL_RTL as the "location" unless we find something better.  */
5975   rtl = DECL_RTL (decl);
5976
5977   if (TREE_CODE (decl) == PARM_DECL)
5978     {
5979       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
5980         {
5981           declared_type = type_main_variant (TREE_TYPE (decl));
5982           passed_type = type_main_variant (DECL_ARG_TYPE (decl));
5983           /* This decl represents a formal parameter which was
5984              optimized out.
5985
5986              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
5987              all* cases where (rtl == NULL_RTX) just below.  */
5988           if (declared_type == passed_type)
5989             {
5990               rtl = DECL_INCOMING_RTL (decl);
5991             }
5992           else if (!BYTES_BIG_ENDIAN)
5993             {
5994               if (TREE_CODE (declared_type) == INTEGER_TYPE)
5995                 {
5996                   if (TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
5997                     {
5998                       rtl = DECL_INCOMING_RTL (decl);
5999                     }
6000                 }
6001             }
6002         }
6003     }
6004   if (rtl == NULL_RTX)
6005     return;
6006
6007   switch (GET_CODE (rtl))
6008     {
6009     case CONST_INT:
6010     case CONST_DOUBLE:
6011     case CONST_STRING:
6012     case SYMBOL_REF:
6013     case LABEL_REF:
6014     case CONST:
6015     case PLUS:
6016       /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
6017       add_const_value_attribute (die, rtl);
6018       break;
6019
6020     case MEM:
6021     case REG:
6022     case SUBREG:
6023       add_location_attribute (die, rtl);
6024       break;
6025
6026     default:
6027       abort ();                 /* Should never happen.  */
6028     }
6029 }
6030
6031 /* Generate an DW_AT_name attribute given some string value to be included as
6032    the value of the attribute.  */
6033 inline void
6034 add_name_attribute (die, name_string)
6035      register dw_die_ref die;
6036      register char *name_string;
6037 {
6038   if (name_string && *name_string)
6039     {
6040       add_AT_string (die, DW_AT_name, name_string);
6041     }
6042 }
6043
6044 /* Given a tree node describing an array bound (either lower or upper) output
6045    a representation for that bound.
6046
6047    FIXME: This uses location descriptions for variable bounds, whereas the
6048    DWARF-2 spec only allowes for constants or DIE references.  */
6049 static void
6050 add_bound_info (subrange_die, bound_attr, bound)
6051      register dw_die_ref subrange_die;
6052      register enum dwarf_attribute bound_attr;
6053      register tree bound;
6054 {
6055   register dw_loc_descr_ref bound_loc = NULL;
6056   register unsigned bound_value = 0;
6057   switch (TREE_CODE (bound))
6058     {
6059     case ERROR_MARK:
6060       return;
6061
6062     /* All fixed-bounds are represented by INTEGER_CST nodes.        */
6063     case INTEGER_CST:
6064       bound_value = TREE_INT_CST_LOW (bound);
6065       if (bound_attr == DW_AT_lower_bound
6066           && ((is_c_family () && bound_value == 0)
6067               || (is_fortran () && bound_value == 1)))
6068         /* use the default */;
6069       else
6070         add_AT_unsigned (subrange_die, bound_attr, bound_value);
6071       break;
6072
6073     /* Dynamic bounds may be represented by NOP_EXPR nodes containing
6074        SAVE_EXPR nodes.  */
6075     case NOP_EXPR:
6076       bound = TREE_OPERAND (bound, 0);
6077       /* ... fall thru...  */
6078
6079     case SAVE_EXPR:
6080       /* Handle the simple case of `int ar[i];'.  */
6081       if (bound_attr == DW_AT_upper_bound && is_c_family ()
6082           && TREE_CODE (TREE_OPERAND (bound, 0)) == MINUS_EXPR)
6083         {
6084           tree t = TREE_OPERAND (bound, 0);
6085           if (integer_onep (TREE_OPERAND (bound, 1)))
6086             t = TREE_OPERAND (t, 0);
6087           if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
6088             {
6089               add_AT_die_ref (subrange_die, DW_AT_count, lookup_decl_die (t));
6090               return;
6091             }
6092         }
6093
6094       /* If optimization is turned on, the SAVE_EXPRs that describe how to
6095          access the upper bound values are essentially bogus. They only
6096          describe (at best) how to get at these values at the points in the
6097          generated code right after they have just been computed.  Worse
6098          yet, in the typical case, the upper bound values will not even
6099          *be* computed in the optimized code, so these SAVE_EXPRs are
6100          entirely bogus. In order to compensate for this fact, we check
6101          here to see if optimization is enabled, and if so, we don't add an
6102          attribute for the (unknown and unknowable) upper bound.  This
6103          should not cause too much trouble for existing (stupid?)
6104          debuggers because they have to deal with empty upper bounds
6105          location descriptions anyway in order to be able to deal with
6106          incomplete array types.  Of course an intelligent debugger (GDB?)
6107          should be able to comprehend that a missing upper bound
6108          specification in a array type used for a storage class `auto'
6109          local array variable indicates that the upper bound is both
6110          unknown (at compile- time) and unknowable (at run-time) due to
6111          optimization.  */
6112       if (!optimize)
6113         {
6114           bound_loc = mem_loc_descriptor
6115             (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
6116           add_AT_loc (subrange_die, bound_attr, bound_loc);
6117         }
6118       /* else leave out the attribute.  */
6119       break;
6120
6121     default:
6122       abort ();
6123     }
6124 }
6125
6126 /* Note that the block of subscript information for an array type also
6127    includes information about the element type of type given array type.  */
6128 static void
6129 add_subscript_info (type_die, type)
6130      register dw_die_ref type_die;
6131      register tree type;
6132 {
6133   register unsigned dimension_number;
6134   register tree lower, upper;
6135   register dw_die_ref subrange_die;
6136
6137   /* The GNU compilers represent multidimensional array types as sequences of
6138      one dimensional array types whose element types are themselves array
6139      types.  Here we squish that down, so that each multidimensional array
6140      type gets only one array_type DIE in the Dwarf debugging info. The draft
6141      Dwarf specification say that we are allowed to do this kind of
6142      compression in C (because there is no difference between an array or
6143      arrays and a multidimensional array in C) but for other source languages
6144      (e.g. Ada) we probably shouldn't do this.  */
6145   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
6146      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
6147      We work around this by disabling this feature.  See also
6148      gen_array_type_die.  */
6149 #ifndef MIPS_DEBUGGING_INFO
6150   for (dimension_number = 0;
6151        TREE_CODE (type) == ARRAY_TYPE;
6152        type = TREE_TYPE (type), dimension_number++)
6153     {
6154 #endif
6155       register tree domain = TYPE_DOMAIN (type);
6156
6157       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
6158          and (in GNU C only) variable bounds.  Handle all three forms
6159          here.  */
6160       subrange_die = new_die (DW_TAG_subrange_type, type_die);
6161       if (domain)
6162         {
6163           /* We have an array type with specified bounds.  */
6164           lower = TYPE_MIN_VALUE (domain);
6165           upper = TYPE_MAX_VALUE (domain);
6166
6167           /* define the index type.  */
6168           if (TREE_TYPE (domain))
6169             add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
6170                                 type_die);
6171
6172           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
6173           add_bound_info (subrange_die, DW_AT_upper_bound, upper);
6174         }
6175       else
6176         {
6177           /* We have an array type with an unspecified length.  The DWARF-2
6178              spec does not say how to handle this; let's just leave out the
6179              bounds.  */
6180         }
6181 #ifndef MIPS_DEBUGGING_INFO
6182     }
6183 #endif
6184 }
6185
6186 static void
6187 add_byte_size_attribute (die, tree_node)
6188      dw_die_ref die;
6189      register tree tree_node;
6190 {
6191   register unsigned size;
6192
6193   switch (TREE_CODE (tree_node))
6194     {
6195     case ERROR_MARK:
6196       size = 0;
6197       break;
6198     case ENUMERAL_TYPE:
6199     case RECORD_TYPE:
6200     case UNION_TYPE:
6201     case QUAL_UNION_TYPE:
6202       size = int_size_in_bytes (tree_node);
6203       break;
6204     case FIELD_DECL:
6205       /* For a data member of a struct or union, the DW_AT_byte_size is
6206          generally given as the number of bytes normally allocated for an
6207          object of the *declared* type of the member itself.  This is true
6208          even for bit-fields.  */
6209       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
6210       break;
6211     default:
6212       abort ();
6213     }
6214
6215   /* Note that `size' might be -1 when we get to this point.  If it is, that
6216      indicates that the byte size of the entity in question is variable.  We
6217      have no good way of expressing this fact in Dwarf at the present time,
6218      so just let the -1 pass on through.  */
6219
6220   add_AT_unsigned (die, DW_AT_byte_size, size);
6221 }
6222
6223 /* For a FIELD_DECL node which represents a bit-field, output an attribute
6224    which specifies the distance in bits from the highest order bit of the
6225    "containing object" for the bit-field to the highest order bit of the
6226    bit-field itself.
6227
6228    For any given bit-field, the "containing object" is a hypothetical
6229    object (of some integral or enum type) within which the given bit-field
6230    lives.  The type of this hypothetical "containing object" is always the
6231    same as the declared type of the individual bit-field itself.  The
6232    determination of the exact location of the "containing object" for a
6233    bit-field is rather complicated.  It's handled by the
6234    `field_byte_offset' function (above).
6235
6236    Note that it is the size (in bytes) of the hypothetical "containing object"
6237    which will be given in the DW_AT_byte_size attribute for this bit-field.
6238    (See `byte_size_attribute' above).  */
6239 inline void
6240 add_bit_offset_attribute (die, decl)
6241      register dw_die_ref die;
6242      register tree decl;
6243 {
6244   register unsigned object_offset_in_bytes = field_byte_offset (decl);
6245   register tree type = DECL_BIT_FIELD_TYPE (decl);
6246   register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
6247   register unsigned bitpos_int;
6248   register unsigned highest_order_object_bit_offset;
6249   register unsigned highest_order_field_bit_offset;
6250   register unsigned bit_offset;
6251
6252   assert (TREE_CODE (decl) == FIELD_DECL);      /* Must be a field.  */
6253   assert (type);                                /* Must be a bit field.  */
6254
6255   /* We can't yet handle bit-fields whose offsets are variable, so if we
6256      encounter such things, just return without generating any attribute
6257      whatsoever.  */
6258   if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6259     {
6260       return;
6261     }
6262   bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6263
6264   /* Note that the bit offset is always the distance (in bits) from the
6265      highest-order bit of the "containing object" to the highest-order bit of
6266      the bit-field itself.  Since the "high-order end" of any object or field
6267      is different on big-endian and little-endian machines, the computation
6268      below must take account of these differences.  */
6269   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
6270   highest_order_field_bit_offset = bitpos_int;
6271
6272   if (!BYTES_BIG_ENDIAN)
6273     {
6274       highest_order_field_bit_offset
6275         += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
6276
6277       highest_order_object_bit_offset += simple_type_size_in_bits (type);
6278     }
6279   bit_offset =
6280     (!BYTES_BIG_ENDIAN
6281      ? highest_order_object_bit_offset - highest_order_field_bit_offset
6282      : highest_order_field_bit_offset - highest_order_object_bit_offset);
6283
6284   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
6285 }
6286
6287 /* For a FIELD_DECL node which represents a bit field, output an attribute
6288    which specifies the length in bits of the given field.  */
6289 inline void
6290 add_bit_size_attribute (die, decl)
6291      register dw_die_ref die;
6292      register tree decl;
6293 {
6294   assert (TREE_CODE (decl) == FIELD_DECL);      /* Must be a field.  */
6295   assert (DECL_BIT_FIELD_TYPE (decl));          /* Must be a bit field.  */
6296   add_AT_unsigned (die, DW_AT_bit_size,
6297                    (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
6298 }
6299
6300 /* If the compiled language is ANSI C, then add a 'prototyped'
6301    attribute, if arg types are given for the parameters of a function.  */
6302 inline void
6303 add_prototyped_attribute (die, func_type)
6304      register dw_die_ref die;
6305      register tree func_type;
6306 {
6307   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
6308       && TYPE_ARG_TYPES (func_type) != NULL)
6309     add_AT_flag (die, DW_AT_prototyped, 1);
6310 }
6311
6312
6313 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
6314    by looking in either the type declaration or object declaration
6315    equate table.  */
6316 inline void
6317 add_abstract_origin_attribute (die, origin)
6318      register dw_die_ref die;
6319      register tree origin;
6320 {
6321   dw_die_ref origin_die = NULL;
6322   if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
6323     {
6324       origin_die = lookup_decl_die (origin);
6325     }
6326   else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
6327     {
6328       origin_die = lookup_type_die (origin);
6329     }
6330   add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
6331 }
6332
6333 /* We do not currently support the pure_virtual attribute.  */
6334
6335 inline void
6336 add_pure_or_virtual_attribute (die, func_decl)
6337      register dw_die_ref die;
6338      register tree func_decl;
6339 {
6340   if (DECL_VINDEX (func_decl))
6341     {
6342       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
6343       add_AT_loc (die, DW_AT_vtable_elem_location, new_loc_descr
6344                   (DW_OP_constu, TREE_INT_CST_LOW (DECL_VINDEX (func_decl))));
6345       /* GNU extension: Record what type this method came from originally.  */
6346       if (debug_info_level > DINFO_LEVEL_TERSE)
6347         add_AT_die_ref (die, DW_AT_containing_type,
6348                         lookup_type_die (DECL_CONTEXT (func_decl)));
6349     }
6350 }
6351 \f
6352 /********************* utility routines for DIEs *************************/
6353
6354 /* Add source coordinate attributes for the given decl.  */
6355 static void
6356 add_src_coords_attributes (die, decl)
6357      register dw_die_ref die;
6358      register tree decl;
6359 {
6360   register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
6361   add_AT_unsigned (die, DW_AT_decl_file, file_index);
6362   add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
6363 }
6364
6365 /* Add an DW_AT_name attribute and source coordinate attribute for the
6366    given decl, but only if it actually has a name.  */
6367 static void
6368 add_name_and_src_coords_attributes (die, decl)
6369      register dw_die_ref die;
6370      register tree decl;
6371 {
6372   register tree decl_name;
6373   decl_name = DECL_NAME (decl);
6374   if (decl_name && IDENTIFIER_POINTER (decl_name))
6375     {
6376       add_name_attribute (die, dwarf2_name (decl, 0));
6377       add_src_coords_attributes (die, decl);
6378       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
6379           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
6380         add_AT_string (die, DW_AT_MIPS_linkage_name,
6381                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
6382     }
6383 }
6384
6385 /* Push a new declaration scope. */
6386 static void
6387 push_decl_scope (scope)
6388      tree scope;
6389 {
6390   /* Make room in the decl_scope_table, if necessary.  */
6391   if (decl_scope_table_allocated == decl_scope_depth)
6392     {
6393       decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
6394       decl_scope_table = (tree *) xrealloc (decl_scope_table,
6395                            decl_scope_table_allocated * sizeof (tree));
6396     }
6397   decl_scope_table[decl_scope_depth++] = scope;
6398 }
6399
6400 /* Return the DIE for the scope the immediately contains this declaration.  */
6401 static dw_die_ref
6402 scope_die_for (t, context_die)
6403     register tree t;
6404     register dw_die_ref context_die;
6405 {
6406   register dw_die_ref scope_die = NULL;
6407   register tree containing_scope;
6408   register unsigned long i;
6409
6410   /* Function-local tags and functions get stuck in limbo until they are
6411      fixed up by decls_for_scope.  */
6412   if (context_die == NULL
6413       && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t)))
6414     return NULL;
6415
6416   /* Walk back up the declaration tree looking for a place to define
6417      this type.  */
6418   if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
6419     containing_scope = TYPE_CONTEXT (t);
6420   else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t))
6421     containing_scope = decl_class_context (t);
6422   else
6423     containing_scope = DECL_CONTEXT (t);
6424
6425   if (containing_scope == NULL)
6426     {
6427       scope_die = comp_unit_die;
6428     }
6429   else
6430     {
6431       for (i = decl_scope_depth, scope_die = context_die;
6432            i > 0 && decl_scope_table[i - 1] != containing_scope;
6433            scope_die = scope_die->die_parent, --i)
6434         /* nothing */ ;
6435       if (i == 0)
6436         {
6437           assert (scope_die == comp_unit_die);
6438           assert (TREE_CODE_CLASS (TREE_CODE (containing_scope)) == 't');
6439           if (debug_info_level > DINFO_LEVEL_TERSE)
6440             assert (TREE_ASM_WRITTEN (containing_scope));
6441         }
6442     }
6443   return scope_die;
6444 }
6445
6446 /* Pop a declaration scope.  */
6447 inline void
6448 pop_decl_scope ()
6449 {
6450   assert (decl_scope_depth > 0);
6451   --decl_scope_depth;
6452 }
6453
6454 /* Many forms of DIEs require a "type description" attribute.  This
6455    routine locates the proper "type descriptor" die for the type given
6456    by 'type', and adds an DW_AT_type attribute below the given die.  */
6457 static void
6458 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
6459      register dw_die_ref object_die;
6460      register tree type;
6461      register int decl_const;
6462      register int decl_volatile;
6463      register dw_die_ref context_die;
6464 {
6465   register enum tree_code code  = TREE_CODE (type);
6466   register dw_die_ref type_die  = NULL;
6467
6468   if (code == ERROR_MARK)
6469     {
6470       return;
6471     }
6472
6473   /* Handle a special case.  For functions whose return type is void, we
6474      generate *no* type attribute.  (Note that no object may have type
6475      `void', so this only applies to function return types).  */
6476   if (code == VOID_TYPE)
6477     {
6478       return;
6479     }
6480
6481   type_die = modified_type_die (type,
6482                                 decl_const || TYPE_READONLY (type),
6483                                 decl_volatile || TYPE_VOLATILE (type),
6484                                 context_die);
6485   if (type_die != NULL)
6486     {
6487       add_AT_die_ref (object_die, DW_AT_type, type_die);
6488     }
6489 }
6490
6491 /* Given a tree pointer to a struct, class, union, or enum type node, return
6492    a pointer to the (string) tag name for the given type, or zero if the type
6493    was declared without a tag.  */
6494 static char *
6495 type_tag (type)
6496      register tree type;
6497 {
6498   register char *name = 0;
6499
6500   if (TYPE_NAME (type) != 0)
6501     {
6502       register tree t = 0;
6503
6504       /* Find the IDENTIFIER_NODE for the type name.  */
6505       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6506         t = TYPE_NAME (type);
6507
6508       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
6509          a TYPE_DECL node, regardless of whether or not a `typedef' was
6510          involved.  */
6511       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6512                && ! DECL_IGNORED_P (TYPE_NAME (type)))
6513         t = DECL_NAME (TYPE_NAME (type));
6514
6515       /* Now get the name as a string, or invent one.  */
6516       if (t != 0)
6517         name = IDENTIFIER_POINTER (t);
6518     }
6519   return (name == 0 || *name == '\0') ? 0 : name;
6520 }
6521
6522 /* Return the type associated with a data member, make a special check
6523    for bit field types.  */
6524 inline tree
6525 member_declared_type (member)
6526      register tree member;
6527 {
6528   return (DECL_BIT_FIELD_TYPE (member))
6529     ? DECL_BIT_FIELD_TYPE (member)
6530     : TREE_TYPE (member);
6531 }
6532
6533 /* Get the decl's label, as described by its RTL. This may be different
6534    from the DECL_NAME name used in the source file.  */
6535 static char *
6536 decl_start_label (decl)
6537      register tree decl;
6538 {
6539   rtx x;
6540   char *fnname;
6541   x = DECL_RTL (decl);
6542   if (GET_CODE (x) != MEM)
6543     {
6544       abort ();
6545     }
6546   x = XEXP (x, 0);
6547   if (GET_CODE (x) != SYMBOL_REF)
6548     {
6549       abort ();
6550     }
6551   fnname = XSTR (x, 0);
6552   return fnname;
6553 }
6554 \f
6555 /******************************* DIE Generation *************************/
6556
6557 /* These routines generate the internnal representation of the DIE's for
6558    the compilation unit.  Debugging information is collected by walking
6559    the declaration trees passed in from dwarf2out_decl().  */
6560
6561 static void
6562 gen_array_type_die (type, context_die)
6563      register tree type;
6564      register dw_die_ref context_die;
6565 {
6566   register dw_die_ref scope_die = scope_die_for (type, context_die);
6567   register dw_die_ref array_die;
6568   register tree element_type;
6569
6570   /* ??? The SGI dwarf reader fails for array of array of enum types unless
6571      the inner array type comes before the outer array type.  Thus we must
6572      call gen_type_die before we call new_die.  See below also.  */
6573 #ifdef MIPS_DEBUGGING_INFO
6574   gen_type_die (TREE_TYPE (type), context_die);
6575 #endif
6576
6577   array_die = new_die (DW_TAG_array_type, scope_die);
6578
6579 #if 0
6580   /* We default the array ordering.  SDB will probably do
6581      the right things even if DW_AT_ordering is not present.  It's not even
6582      an issue until we start to get into multidimensional arrays anyway.  If
6583      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
6584      then we'll have to put the DW_AT_ordering attribute back in.  (But if
6585      and when we find out that we need to put these in, we will only do so
6586      for multidimensional arrays.  */
6587   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
6588 #endif
6589
6590 #ifdef MIPS_DEBUGGING_INFO
6591   /* The SGI compilers handle arrays of unknown bound by setting
6592      AT_declaration and not emitting any subrange DIEs.  */
6593   if (! TYPE_DOMAIN (type))
6594     add_AT_unsigned (array_die, DW_AT_declaration, 1);
6595   else
6596 #endif
6597     add_subscript_info (array_die, type);
6598
6599   equate_type_number_to_die (type, array_die);
6600
6601   /* Add representation of the type of the elements of this array type.  */
6602   element_type = TREE_TYPE (type);
6603   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
6604      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
6605      We work around this by disabling this feature.  See also
6606      add_subscript_info.  */
6607 #ifndef MIPS_DEBUGGING_INFO
6608   while (TREE_CODE (element_type) == ARRAY_TYPE)
6609     {
6610       element_type = TREE_TYPE (element_type);
6611     }
6612   gen_type_die (element_type, context_die);
6613 #endif
6614
6615   add_type_attribute (array_die, element_type, 0, 0, context_die);
6616 }
6617
6618 static void
6619 gen_set_type_die (type, context_die)
6620      register tree type;
6621      register dw_die_ref context_die;
6622 {
6623   register dw_die_ref type_die = new_die
6624     (DW_TAG_set_type, scope_die_for (type, context_die));
6625   equate_type_number_to_die (type, type_die);
6626   add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
6627 }
6628
6629 static void
6630 gen_entry_point_die (decl, context_die)
6631      register tree decl;
6632      register dw_die_ref context_die;
6633 {
6634   register tree origin = decl_ultimate_origin (decl);
6635   register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
6636   if (origin != NULL)
6637     {
6638       add_abstract_origin_attribute (decl_die, origin);
6639     }
6640   else
6641     {
6642       add_name_and_src_coords_attributes (decl_die, decl);
6643       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
6644                           0, 0, context_die);
6645     }
6646   if (DECL_ABSTRACT (decl))
6647     {
6648       equate_decl_number_to_die (decl, decl_die);
6649     }
6650   else
6651     {
6652       add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
6653     }
6654 }
6655
6656 /* Remember a type in the pending_types_list.  */
6657
6658 static void
6659 pend_type (type)
6660      register tree type;
6661 {
6662   if (pending_types == pending_types_allocated)
6663     {
6664       pending_types_allocated += PENDING_TYPES_INCREMENT;
6665       pending_types_list
6666         = (tree *) xrealloc (pending_types_list,
6667                              sizeof (tree) * pending_types_allocated);
6668     }
6669   pending_types_list[pending_types++] = type;
6670 }
6671
6672 /* Output any pending types (from the pending_types list) which we can output
6673    now (taking into account the scope that we are working on now).
6674
6675    For each type output, remove the given type from the pending_types_list
6676    *before* we try to output it.  */
6677
6678 static void
6679 output_pending_types_for_scope (context_die)
6680      register dw_die_ref context_die;
6681 {
6682   register tree type;
6683
6684   while (pending_types)
6685     {
6686       --pending_types;
6687       type = pending_types_list[pending_types];
6688       gen_type_die (type, context_die);
6689       assert (TREE_ASM_WRITTEN (type));
6690     }
6691 }
6692
6693 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
6694 static void
6695 gen_inlined_enumeration_type_die (type, context_die)
6696      register tree type;
6697      register dw_die_ref context_die;
6698 {
6699   register dw_die_ref type_die;
6700   type_die = new_die (DW_TAG_enumeration_type,
6701                       scope_die_for (type, context_die));
6702   assert (TREE_ASM_WRITTEN (type));
6703   add_abstract_origin_attribute (type_die, type);
6704 }
6705
6706 /* Generate a DIE to represent an inlined instance of a structure type.  */
6707 static void
6708 gen_inlined_structure_type_die (type, context_die)
6709      register tree type;
6710      register dw_die_ref context_die;
6711 {
6712   register dw_die_ref type_die;
6713   type_die = new_die (DW_TAG_structure_type,
6714                       scope_die_for (type, context_die));
6715   assert (TREE_ASM_WRITTEN (type));
6716   add_abstract_origin_attribute (type_die, type);
6717 }
6718
6719 /* Generate a DIE to represent an inlined instance of a union type.  */
6720 static void
6721 gen_inlined_union_type_die (type, context_die)
6722      register tree type;
6723      register dw_die_ref context_die;
6724 {
6725   register dw_die_ref type_die;
6726   type_die = new_die (DW_TAG_union_type,
6727                       scope_die_for (type, context_die));
6728   assert (TREE_ASM_WRITTEN (type));
6729   add_abstract_origin_attribute (type_die, type);
6730 }
6731
6732 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
6733    include all of the information about the enumeration values also. Each
6734    enumerated type name/value is listed as a child of the enumerated type
6735    DIE.  */
6736 static void
6737 gen_enumeration_type_die (type, context_die)
6738      register tree type;
6739      register dw_die_ref context_die;
6740 {
6741   register dw_die_ref type_die = lookup_type_die (type);
6742
6743   if (type_die == NULL)
6744     {
6745       type_die = new_die (DW_TAG_enumeration_type,
6746                           scope_die_for (type, context_die));
6747       equate_type_number_to_die (type, type_die);
6748       add_name_attribute (type_die, type_tag (type));
6749     }
6750   else if (! TYPE_SIZE (type))
6751     return;
6752   else
6753     remove_AT (type_die, DW_AT_declaration);
6754
6755   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
6756      given enum type is incomplete, do not generate the DW_AT_byte_size
6757      attribute or the DW_AT_element_list attribute.  */
6758   if (TYPE_SIZE (type))
6759     {
6760       register tree link;
6761       TREE_ASM_WRITTEN (type) = 1;
6762       add_byte_size_attribute (type_die, type);
6763       if (type_tag (type))
6764         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
6765       for (link = TYPE_FIELDS (type);
6766            link != NULL; link = TREE_CHAIN (link))
6767         {
6768           register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
6769           add_name_attribute (enum_die,
6770                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
6771           add_AT_unsigned (enum_die, DW_AT_const_value,
6772                            (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
6773         }
6774     }
6775   else
6776     add_AT_flag (type_die, DW_AT_declaration, 1);
6777 }
6778
6779
6780 /* Generate a DIE to represent either a real live formal parameter decl or to
6781    represent just the type of some formal parameter position in some function
6782    type.
6783    Note that this routine is a bit unusual because its argument may be a
6784    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
6785    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
6786    node.  If it's the former then this function is being called to output a
6787    DIE to represent a formal parameter object (or some inlining thereof).  If
6788    it's the latter, then this function is only being called to output a
6789    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
6790    argument type of some subprogram type.  */
6791 static dw_die_ref
6792 gen_formal_parameter_die (node, context_die)
6793      register tree node;
6794      register dw_die_ref context_die;
6795 {
6796   register dw_die_ref parm_die = new_die (DW_TAG_formal_parameter,
6797                                           context_die);
6798   register tree origin;
6799   switch (TREE_CODE_CLASS (TREE_CODE (node)))
6800     {
6801       /* We were called with some kind of a ..._DECL node.  */
6802     case 'd':
6803       origin = decl_ultimate_origin (node);
6804       if (origin != NULL)
6805         add_abstract_origin_attribute (parm_die, origin);
6806       else
6807         {
6808           add_name_and_src_coords_attributes (parm_die, node);
6809           add_type_attribute (parm_die, TREE_TYPE (node),
6810                               TREE_READONLY (node),
6811                               TREE_THIS_VOLATILE (node),
6812                               context_die);
6813           if (DECL_ARTIFICIAL (node))
6814             add_AT_flag (parm_die, DW_AT_artificial, 1);
6815         }
6816       equate_decl_number_to_die (node, parm_die);
6817       if (! DECL_ABSTRACT (node))
6818         add_location_or_const_value_attribute (parm_die, node);
6819       break;
6820
6821       /* We were called with some kind of a ..._TYPE node.  */
6822     case 't':
6823       add_type_attribute (parm_die, node, 0, 0, context_die);
6824       break;
6825
6826       /* Should never happen.  */
6827     default:
6828       abort ();
6829     }
6830   return parm_die;
6831 }
6832
6833 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
6834    at the end of an (ANSI prototyped) formal parameters list.  */
6835 static void
6836 gen_unspecified_parameters_die (decl_or_type, context_die)
6837      register tree decl_or_type;
6838      register dw_die_ref context_die;
6839 {
6840   register dw_die_ref parm_die = new_die (DW_TAG_unspecified_parameters,
6841                                           context_die);
6842 }
6843
6844 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
6845    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
6846    parameters as specified in some function type specification (except for
6847    those which appear as part of a function *definition*).
6848    Note that we must be careful here to output all of the parameter DIEs before*
6849    we output any DIEs needed to represent the types of the formal parameters.
6850    This keeps svr4 SDB happy because it (incorrectly) thinks that the first
6851    non-parameter DIE it sees ends the formal parameter list.  */
6852 static void
6853 gen_formal_types_die (function_or_method_type, context_die)
6854      register tree function_or_method_type;
6855      register dw_die_ref context_die;
6856 {
6857   register tree link;
6858   register tree formal_type = NULL;
6859   register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
6860
6861 #if 0
6862   /* In the case where we are generating a formal types list for a C++
6863      non-static member function type, skip over the first thing on the
6864      TYPE_ARG_TYPES list because it only represents the type of the hidden
6865      `this pointer'.  The debugger should be able to figure out (without
6866      being explicitly told) that this non-static member function type takes a
6867      `this pointer' and should be able to figure what the type of that hidden
6868      parameter is from the DW_AT_member attribute of the parent
6869      DW_TAG_subroutine_type DIE.  */
6870   if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
6871     first_parm_type = TREE_CHAIN (first_parm_type);
6872 #endif
6873
6874   /* Make our first pass over the list of formal parameter types and output a
6875      DW_TAG_formal_parameter DIE for each one.  */
6876   for (link = first_parm_type; link; link = TREE_CHAIN (link))
6877     {
6878       register dw_die_ref parm_die;
6879
6880       formal_type = TREE_VALUE (link);
6881       if (formal_type == void_type_node)
6882         break;
6883
6884       /* Output a (nameless) DIE to represent the formal parameter itself.  */
6885       parm_die = gen_formal_parameter_die (formal_type, context_die);
6886       if (TREE_CODE (function_or_method_type) == METHOD_TYPE
6887           && link == first_parm_type)
6888         add_AT_flag (parm_die, DW_AT_artificial, 1);
6889     }
6890
6891   /* If this function type has an ellipsis, add a
6892      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
6893   if (formal_type != void_type_node)
6894     gen_unspecified_parameters_die (function_or_method_type, context_die);
6895
6896   /* Make our second (and final) pass over the list of formal parameter types
6897      and output DIEs to represent those types (as necessary).  */
6898   for (link = TYPE_ARG_TYPES (function_or_method_type);
6899        link;
6900        link = TREE_CHAIN (link))
6901     {
6902       formal_type = TREE_VALUE (link);
6903       if (formal_type == void_type_node)
6904         break;
6905
6906       gen_type_die (formal_type, context_die);
6907     }
6908 }
6909
6910 /* Generate a DIE to represent a declared function (either file-scope or
6911    block-local).  */
6912 static void
6913 gen_subprogram_die (decl, context_die)
6914      register tree decl;
6915      register dw_die_ref context_die;
6916 {
6917   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
6918   register tree origin = decl_ultimate_origin (decl);
6919   register dw_die_ref subr_die;
6920   register dw_loc_descr_ref fp_loc = NULL;
6921   register unsigned fp_reg;
6922   register tree fn_arg_types;
6923   register tree outer_scope;
6924   register dw_die_ref old_die = lookup_decl_die (decl);
6925   register int declaration = (current_function_decl != decl
6926                               || context_die->die_tag == DW_TAG_structure_type
6927                               || context_die->die_tag == DW_TAG_union_type);
6928
6929   if (origin != NULL)
6930     {
6931       subr_die = new_die (DW_TAG_subprogram, context_die);
6932       add_abstract_origin_attribute (subr_die, origin);
6933     }
6934   else if (old_die)
6935     {
6936       register unsigned file_index
6937         = lookup_filename (DECL_SOURCE_FILE (decl));
6938
6939       assert (get_AT_flag (old_die, DW_AT_declaration) == 1);
6940
6941       /* If the definition comes from the same place as the declaration,
6942          maybe use the old DIE.  We always want the DIE for this function
6943          that has the *_pc attributes to be under comp_unit_die so the
6944          debugger can find it.  For inlines, that is the concrete instance,
6945          so we can use the old DIE here.  For non-inline methods, we want a
6946          specification DIE at toplevel, so we need a new DIE.  For local
6947          class methods, this does not apply.  */
6948       if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
6949            || context_die == NULL)
6950           && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
6951           && (get_AT_unsigned (old_die, DW_AT_decl_line)
6952               == DECL_SOURCE_LINE (decl)))
6953         {
6954           subr_die = old_die;
6955
6956           /* Clear out the declaration attribute and the parm types.  */
6957           remove_AT (subr_die, DW_AT_declaration);
6958           remove_children (subr_die);
6959         }
6960       else
6961         {
6962           subr_die = new_die (DW_TAG_subprogram, context_die);
6963           add_AT_die_ref (subr_die, DW_AT_specification, old_die);
6964           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
6965             add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
6966           if (get_AT_unsigned (old_die, DW_AT_decl_line)
6967               != DECL_SOURCE_LINE (decl))
6968             add_AT_unsigned
6969               (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
6970         }
6971     }
6972   else
6973     {
6974       register dw_die_ref scope_die;
6975
6976       if (DECL_CONTEXT (decl))
6977         scope_die = scope_die_for (decl, context_die);
6978       else
6979         /* Don't put block extern declarations under comp_unit_die.  */
6980         scope_die = context_die;
6981
6982       subr_die = new_die (DW_TAG_subprogram, scope_die);
6983
6984       if (TREE_PUBLIC (decl))
6985         add_AT_flag (subr_die, DW_AT_external, 1);
6986       add_name_and_src_coords_attributes (subr_die, decl);
6987       if (debug_info_level > DINFO_LEVEL_TERSE)
6988         {
6989           register tree type = TREE_TYPE (decl);
6990           add_prototyped_attribute (subr_die, type);
6991           add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
6992         }
6993       add_pure_or_virtual_attribute (subr_die, decl);
6994       if (DECL_ARTIFICIAL (decl))
6995         add_AT_flag (subr_die, DW_AT_artificial, 1);
6996       if (TREE_PROTECTED (decl))
6997         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
6998       else if (TREE_PRIVATE (decl))
6999         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
7000     }
7001
7002   if (declaration)
7003     {
7004       add_AT_flag (subr_die, DW_AT_declaration, 1);
7005
7006       /* The first time we see a member function, it is in the context of
7007          the class to which it belongs.  We make sure of this by emitting
7008          the class first.  The next time is the definition, which is
7009          handled above.  The two may come from the same source text.  */
7010       if (decl_class_context (decl))
7011         equate_decl_number_to_die (decl, subr_die);
7012     }
7013   else if (DECL_ABSTRACT (decl))
7014     {
7015       if (DECL_DEFER_OUTPUT (decl))
7016         {
7017           if (DECL_INLINE (decl))
7018             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
7019           else
7020             add_AT_unsigned (subr_die, DW_AT_inline,
7021                              DW_INL_declared_not_inlined);
7022         }
7023       else if (DECL_INLINE (decl))
7024         add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
7025       else if (declaration)
7026         /* block extern declaration in an inline function.  */
7027         add_AT_flag (subr_die, DW_AT_declaration, 1);
7028       else
7029         abort ();
7030
7031       equate_decl_number_to_die (decl, subr_die);
7032     }
7033   else if (!DECL_EXTERNAL (decl))
7034     {
7035       if (origin == NULL)
7036         equate_decl_number_to_die (decl, subr_die);
7037       ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
7038                                    current_funcdef_number);
7039       add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
7040       ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
7041                                    current_funcdef_number);
7042       add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
7043
7044       add_pubname (decl, subr_die);
7045       add_arange (decl, subr_die);
7046
7047 #ifdef MIPS_DEBUGGING_INFO
7048       /* Add a reference to the FDE for this routine.  */
7049       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
7050 #endif
7051
7052       /* Define the "frame base" location for this routine.  We use the
7053          frame pointer or stack pointer registers, since the RTL for local
7054          variables is relative to one of them.  */
7055       fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
7056                                     ? FRAME_POINTER_REGNUM
7057                                     : STACK_POINTER_REGNUM);
7058       assert (fp_reg >= 0 && fp_reg <= 31);
7059       fp_loc = new_loc_descr (DW_OP_reg0 + fp_reg);
7060       add_AT_loc (subr_die, DW_AT_frame_base, fp_loc);
7061
7062       if (current_function_needs_context)
7063         add_AT_loc (subr_die, DW_AT_static_link,
7064                     loc_descriptor (lookup_static_chain (decl)));
7065     }
7066
7067   /* Now output descriptions of the arguments for this function. This gets
7068      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
7069      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
7070      `...' at the end of the formal parameter list.  In order to find out if
7071      there was a trailing ellipsis or not, we must instead look at the type
7072      associated with the FUNCTION_DECL.  This will be a node of type
7073      FUNCTION_TYPE. If the chain of type nodes hanging off of this
7074      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
7075      an ellipsis at the end.  */
7076
7077   push_decl_scope (decl);
7078   /* In the case where we are describing a mere function declaration, all we
7079      need to do here (and all we *can* do here) is to describe the *types* of
7080      its formal parameters.  */
7081   if (debug_info_level <= DINFO_LEVEL_TERSE)
7082     /* do nothing */;
7083   else if (declaration)
7084     gen_formal_types_die (TREE_TYPE (decl), subr_die);
7085   else
7086     {
7087       /* Generate DIEs to represent all known formal parameters */
7088       register tree arg_decls = DECL_ARGUMENTS (decl);
7089       register tree parm;
7090
7091       /* When generating DIEs, generate the unspecified_parameters DIE
7092          instead if we come across the arg "__builtin_va_alist" */
7093       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
7094         {
7095           if (TREE_CODE (parm) == PARM_DECL)
7096             {
7097               if (DECL_NAME (parm) &&
7098                   !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
7099                            "__builtin_va_alist"))
7100                 {
7101                   gen_unspecified_parameters_die (parm, subr_die);
7102                 }
7103               else
7104                 {
7105                   gen_decl_die (parm, subr_die);
7106                 }
7107             }
7108         }
7109
7110       /* Decide whether we need a unspecified_parameters DIE at the end.
7111          There are 2 more cases to do this for: 1) the ansi ... declaration -
7112          this is detectable when the end of the arg list is not a
7113          void_type_node 2) an unprototyped function declaration (not a
7114          definition).  This just means that we have no info about the
7115          parameters at all.  */
7116       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
7117       if (fn_arg_types)
7118         {
7119           /* this is the prototyped case, check for ...  */
7120           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
7121             {
7122               gen_unspecified_parameters_die (decl, subr_die);
7123             }
7124         }
7125       else
7126         {
7127           /* this is unprotoyped, check for undefined (just declaration) */
7128           if (!DECL_INITIAL (decl))
7129             {
7130               gen_unspecified_parameters_die (decl, subr_die);
7131             }
7132         }
7133     }
7134
7135   /* Output Dwarf info for all of the stuff within the body of the function
7136      (if it has one - it may be just a declaration).  */
7137   outer_scope = DECL_INITIAL (decl);
7138
7139   /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
7140      node created to represent a function. This outermost BLOCK actually
7141      represents the outermost binding contour for the function, i.e. the
7142      contour in which the function's formal parameters and labels get
7143      declared. Curiously, it appears that the front end doesn't actually
7144      put the PARM_DECL nodes for the current function onto the BLOCK_VARS
7145      list for this outer scope.  (They are strung off of the DECL_ARGUMENTS
7146      list for the function instead.) The BLOCK_VARS list for the
7147      `outer_scope' does provide us with a list of the LABEL_DECL nodes for
7148      the function however, and we output DWARF info for those in
7149      decls_for_scope.  Just within the `outer_scope' there will be a BLOCK
7150      node representing the function's outermost pair of curly braces, and
7151      any blocks used for the base and member initializers of a C++
7152      constructor function.  */
7153   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
7154     {
7155       current_function_has_inlines = 0;
7156       decls_for_scope (outer_scope, subr_die, 0);
7157 #if 0 && defined (MIPS_DEBUGGING_INFO)
7158       if (current_function_has_inlines)
7159         {
7160           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
7161           if (! comp_unit_has_inlines)
7162             {
7163               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
7164               comp_unit_has_inlines = 1;
7165             }
7166         }
7167 #endif
7168     }
7169   pop_decl_scope ();
7170 }
7171
7172 /* Generate a DIE to represent a declared data object.  */
7173 static void
7174 gen_variable_die (decl, context_die)
7175      register tree decl;
7176      register dw_die_ref context_die;
7177 {
7178   register tree origin = decl_ultimate_origin (decl);
7179   register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
7180   dw_die_ref old_die = lookup_decl_die (decl);
7181   int declaration
7182     = (DECL_EXTERNAL (decl)
7183        || current_function_decl != decl_function_context (decl)
7184        || context_die->die_tag == DW_TAG_structure_type
7185        || context_die->die_tag == DW_TAG_union_type);
7186
7187   if (origin != NULL)
7188     {
7189       add_abstract_origin_attribute (var_die, origin);
7190     }
7191   else if (old_die && TREE_STATIC (decl))
7192     {
7193       assert (get_AT_flag (old_die, DW_AT_declaration) == 1);
7194       add_AT_die_ref (var_die, DW_AT_specification, old_die);
7195       if (DECL_NAME (decl))
7196         {
7197           register unsigned file_index
7198             = lookup_filename (DECL_SOURCE_FILE (decl));
7199           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
7200             add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
7201           if (get_AT_unsigned (old_die, DW_AT_decl_line)
7202               != DECL_SOURCE_LINE (decl))
7203             add_AT_unsigned
7204               (var_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7205         }
7206     }
7207   else
7208     {
7209       add_name_and_src_coords_attributes (var_die, decl);
7210       add_type_attribute (var_die, TREE_TYPE (decl),
7211                           TREE_READONLY (decl),
7212                           TREE_THIS_VOLATILE (decl), context_die);
7213       if (TREE_PUBLIC (decl))
7214         add_AT_flag (var_die, DW_AT_external, 1);
7215       if (DECL_ARTIFICIAL (decl))
7216         add_AT_flag (var_die, DW_AT_artificial, 1);
7217       if (TREE_PROTECTED (decl))
7218         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
7219       else if (TREE_PRIVATE (decl))
7220         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
7221     }
7222
7223   if (declaration)
7224     add_AT_flag (var_die, DW_AT_declaration, 1);
7225
7226   if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl))
7227     equate_decl_number_to_die (decl, var_die);
7228
7229   if (! declaration && ! DECL_ABSTRACT (decl))
7230     {
7231       equate_decl_number_to_die (decl, var_die);
7232       add_location_or_const_value_attribute (var_die, decl);
7233       add_pubname (decl, var_die);
7234     }
7235 }
7236
7237 /* Generate a DIE to represent a label identifier.  */
7238 static void
7239 gen_label_die (decl, context_die)
7240      register tree decl;
7241      register dw_die_ref context_die;
7242 {
7243   register tree origin = decl_ultimate_origin (decl);
7244   register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
7245   register rtx insn;
7246   char label[MAX_ARTIFICIAL_LABEL_BYTES];
7247   char label2[MAX_ARTIFICIAL_LABEL_BYTES];
7248   if (origin != NULL)
7249     {
7250       add_abstract_origin_attribute (lbl_die, origin);
7251     }
7252   else
7253     {
7254       add_name_and_src_coords_attributes (lbl_die, decl);
7255     }
7256   if (DECL_ABSTRACT (decl))
7257     {
7258       equate_decl_number_to_die (decl, lbl_die);
7259     }
7260   else
7261     {
7262       insn = DECL_RTL (decl);
7263       if (GET_CODE (insn) == CODE_LABEL)
7264         {
7265           /* When optimization is enabled (via -O) some parts of the compiler
7266              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
7267              represent source-level labels which were explicitly declared by
7268              the user.  This really shouldn't be happening though, so catch
7269              it if it ever does happen.  */
7270           if (INSN_DELETED_P (insn))
7271             {
7272               abort ();         /* Should never happen.  */
7273             }
7274           sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
7275           ASM_GENERATE_INTERNAL_LABEL (label, label2,
7276                                        (unsigned) INSN_UID (insn));
7277           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
7278         }
7279     }
7280 }
7281
7282 /* Generate a DIE for a lexical block.  */
7283 static void
7284 gen_lexical_block_die (stmt, context_die, depth)
7285      register tree stmt;
7286      register dw_die_ref context_die;
7287      int depth;
7288 {
7289   register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
7290   char label[MAX_ARTIFICIAL_LABEL_BYTES];
7291   if (!BLOCK_ABSTRACT (stmt))
7292     {
7293       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
7294                                    next_block_number);
7295       add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
7296       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
7297       add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
7298     }
7299   push_decl_scope (stmt);
7300   decls_for_scope (stmt, stmt_die, depth);
7301   pop_decl_scope ();
7302 }
7303
7304 /* Generate a DIE for an inlined subprogram.  */
7305 static void
7306 gen_inlined_subroutine_die (stmt, context_die, depth)
7307      register tree stmt;
7308      register dw_die_ref context_die;
7309      int depth;
7310 {
7311   if (!BLOCK_ABSTRACT (stmt))
7312     {
7313       register dw_die_ref subr_die = new_die (DW_TAG_inlined_subroutine,
7314                                               context_die);
7315       register tree decl = block_ultimate_origin (stmt);
7316       char label[MAX_ARTIFICIAL_LABEL_BYTES];
7317       add_abstract_origin_attribute (subr_die, decl);
7318       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
7319                                    next_block_number);
7320       add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
7321       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
7322       add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
7323       push_decl_scope (decl);
7324       decls_for_scope (stmt, subr_die, depth);
7325       pop_decl_scope ();
7326       current_function_has_inlines = 1;
7327     }
7328 }
7329
7330 /* Generate a DIE for a field in a record, or structure.  */
7331 static void
7332 gen_field_die (decl, context_die)
7333      register tree decl;
7334      register dw_die_ref context_die;
7335 {
7336   register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
7337   add_name_and_src_coords_attributes (decl_die, decl);
7338   add_type_attribute (decl_die, member_declared_type (decl),
7339                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
7340                       context_die);
7341   /* If this is a bit field...  */
7342   if (DECL_BIT_FIELD_TYPE (decl))
7343     {
7344       add_byte_size_attribute (decl_die, decl);
7345       add_bit_size_attribute (decl_die, decl);
7346       add_bit_offset_attribute (decl_die, decl);
7347     }
7348   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
7349     add_data_member_location_attribute (decl_die, decl);
7350   if (DECL_ARTIFICIAL (decl))
7351     add_AT_flag (decl_die, DW_AT_artificial, 1);
7352   if (TREE_PROTECTED (decl))
7353     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
7354   else if (TREE_PRIVATE (decl))
7355     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
7356 }
7357
7358 #if 0
7359 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
7360    Use modified_type_die instead.
7361    We keep this code here just in case these types of DIEs may be needed to
7362    represent certain things in other languages (e.g. Pascal) someday.  */
7363 static void
7364 gen_pointer_type_die (type, context_die)
7365      register tree type;
7366      register dw_die_ref context_die;
7367 {
7368   register dw_die_ref ptr_die = new_die
7369     (DW_TAG_pointer_type, scope_die_for (type, context_die));
7370   equate_type_number_to_die (type, ptr_die);
7371   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
7372   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
7373 }
7374
7375 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
7376    Use modified_type_die instead.
7377    We keep this code here just in case these types of DIEs may be needed to
7378    represent certain things in other languages (e.g. Pascal) someday.  */
7379 static void
7380 gen_reference_type_die (type, context_die)
7381      register tree type;
7382      register dw_die_ref context_die;
7383 {
7384   register dw_die_ref ref_die = new_die
7385     (DW_TAG_reference_type, scope_die_for (type, context_die));
7386   equate_type_number_to_die (type, ref_die);
7387   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
7388   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
7389 }
7390 #endif
7391
7392 /* Generate a DIE for a pointer to a member type.  */
7393 static void
7394 gen_ptr_to_mbr_type_die (type, context_die)
7395      register tree type;
7396      register dw_die_ref context_die;
7397 {
7398   register dw_die_ref ptr_die = new_die
7399     (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
7400   equate_type_number_to_die (type, ptr_die);
7401   add_AT_die_ref (ptr_die, DW_AT_containing_type,
7402                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
7403   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
7404 }
7405
7406 /* Generate the DIE for the compilation unit.  */
7407 static void
7408 gen_compile_unit_die (main_input_filename)
7409      register char *main_input_filename;
7410 {
7411   char producer[250];
7412   char *wd = getpwd ();
7413
7414   comp_unit_die = new_die (DW_TAG_compile_unit, NULL);
7415
7416   add_name_attribute (comp_unit_die, main_input_filename);
7417
7418   if (wd)
7419     {
7420       add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
7421     }
7422
7423   sprintf (producer, "%s %s", language_string, version_string);
7424
7425 #ifdef MIPS_DEBUGGING_INFO
7426   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
7427      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
7428      not appear in the producer string, the debugger reaches the conclusion
7429      that the object file is stripped and has no debugging information.
7430      To get the MIPS/SGI debugger to believe that there is debugging
7431      information in the object file, we add a -g to the producer string.  */
7432   if (debug_info_level > DINFO_LEVEL_TERSE)
7433     strcat (producer, " -g");
7434 #endif
7435
7436   add_AT_string (comp_unit_die, DW_AT_producer, producer);
7437
7438   if (strcmp (language_string, "GNU C++") == 0)
7439     add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus);
7440   else if (strcmp (language_string, "GNU Ada") == 0)
7441     add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83);
7442   else if (strcmp (language_string, "GNU F77") == 0)
7443     add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77);
7444   else if (flag_traditional)
7445     add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C);
7446   else
7447     add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89);
7448
7449 #if 0 /* unimplemented */
7450   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
7451     add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0);
7452 #endif
7453 }
7454
7455 /* Generate a DIE for a string type.  */
7456 static void
7457 gen_string_type_die (type, context_die)
7458      register tree type;
7459      register dw_die_ref context_die;
7460 {
7461   register dw_die_ref type_die = new_die
7462     (DW_TAG_string_type, scope_die_for (type, context_die));
7463   equate_type_number_to_die (type, type_die);
7464
7465   /* Fudge the string length attribute for now.  */
7466
7467   /* TODO: add string length info.
7468      string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
7469                               bound_representation (upper_bound, 0, 'u'); */
7470 }
7471
7472 /* Generate the DIE for a base class.  */
7473 static void
7474 gen_inheritance_die (binfo, context_die)
7475      register tree binfo;
7476      register dw_die_ref context_die;
7477 {
7478   dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
7479   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
7480   add_data_member_location_attribute (die, binfo);
7481   if (TREE_VIA_VIRTUAL (binfo))
7482     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7483   if (TREE_VIA_PUBLIC (binfo))
7484     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
7485   else if (TREE_VIA_PROTECTED (binfo))
7486     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
7487 }
7488
7489 /* Genearate a DIE for a class member.  */
7490 static void
7491 gen_member_die (type, context_die)
7492      register tree type;
7493      register dw_die_ref context_die;
7494 {
7495   register tree member;
7496   /* If this is not an incomplete type, output descriptions of each of its
7497      members. Note that as we output the DIEs necessary to represent the
7498      members of this record or union type, we will also be trying to output
7499      DIEs to represent the *types* of those members. However the `type'
7500      function (above) will specifically avoid generating type DIEs for member
7501      types *within* the list of member DIEs for this (containing) type execpt
7502      for those types (of members) which are explicitly marked as also being
7503      members of this (containing) type themselves.  The g++ front- end can
7504      force any given type to be treated as a member of some other
7505      (containing) type by setting the TYPE_CONTEXT of the given (member) type
7506      to point to the TREE node representing the appropriate (containing)
7507      type.  */
7508
7509   /* First output info about the base classes.  */
7510   if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
7511     {
7512       register tree bases = TYPE_BINFO_BASETYPES (type);
7513       register int n_bases = TREE_VEC_LENGTH (bases);
7514       register int i;
7515
7516       for (i = 0; i < n_bases; i++)
7517         gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
7518     }
7519
7520   /* Now output info about the data members and type members.  */
7521   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
7522     gen_decl_die (member, context_die);
7523
7524   /* Now output info about the function members (if any).  */
7525   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
7526     gen_decl_die (member, context_die);
7527 }
7528
7529 /* Generate a DIE for a structure or union type.  */
7530 static void
7531 gen_struct_or_union_type_die (type, context_die)
7532      register tree type;
7533      register dw_die_ref context_die;
7534 {
7535   register dw_die_ref type_die = lookup_type_die (type);
7536   register dw_die_ref scope_die = 0;
7537   register int nested = 0;
7538
7539   if (type_die && ! TYPE_SIZE (type))
7540     return;
7541
7542   if (TYPE_CONTEXT (type)
7543       && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't')
7544     nested = 1;
7545
7546   scope_die = scope_die_for (type, context_die);
7547
7548   if (! type_die || (nested && scope_die == comp_unit_die))
7549     /* First occurrence of type or toplevel definition of nested class.  */
7550     {
7551       register dw_die_ref old_die = type_die;
7552       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
7553                           ? DW_TAG_structure_type : DW_TAG_union_type,
7554                           scope_die);
7555       equate_type_number_to_die (type, type_die);
7556       add_name_attribute (type_die, type_tag (type));
7557       if (old_die)
7558         add_AT_die_ref (type_die, DW_AT_specification, old_die);
7559     }
7560   else
7561     remove_AT (type_die, DW_AT_declaration);
7562
7563   /* If we're not in the right context to be defining this type, defer to
7564      avoid tricky recursion.  */
7565   if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die)
7566     {
7567       add_AT_flag (type_die, DW_AT_declaration, 1);
7568       pend_type (type);
7569     }
7570   /* If this type has been completed, then give it a byte_size attribute and
7571      then give a list of members.  */
7572   else if (TYPE_SIZE (type))
7573     {
7574       /* Prevent infinite recursion in cases where the type of some member of
7575          this type is expressed in terms of this type itself.  */
7576       TREE_ASM_WRITTEN (type) = 1;
7577       add_byte_size_attribute (type_die, type);
7578       if (type_tag (type))
7579         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
7580       push_decl_scope (type);
7581       gen_member_die (type, type_die);
7582       pop_decl_scope ();
7583       /* GNU extension: Record what type our vtable lives in.  */
7584       if (TYPE_VFIELD (type))
7585         {
7586           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
7587           gen_type_die (vtype, context_die);
7588           add_AT_die_ref (type_die, DW_AT_containing_type,
7589                           lookup_type_die (vtype));
7590         }
7591     }
7592   else
7593     add_AT_flag (type_die, DW_AT_declaration, 1);
7594 }
7595
7596 /* Generate a DIE for a subroutine _type_.  */
7597 static void
7598 gen_subroutine_type_die (type, context_die)
7599      register tree type;
7600      register dw_die_ref context_die;
7601 {
7602   register tree return_type = TREE_TYPE (type);
7603   register dw_die_ref subr_die = new_die
7604     (DW_TAG_subroutine_type, scope_die_for (type, context_die));
7605   equate_type_number_to_die (type, subr_die);
7606   add_prototyped_attribute (subr_die, type);
7607   add_type_attribute (subr_die, return_type, 0, 0, context_die);
7608   gen_formal_types_die (type, subr_die);
7609 }
7610
7611 /* Generate a DIE for a type definition */
7612 static void
7613 gen_typedef_die (decl, context_die)
7614      register tree decl;
7615      register dw_die_ref context_die;
7616 {
7617   register dw_die_ref type_die;
7618   register tree origin;
7619
7620   if (TREE_ASM_WRITTEN (decl))
7621     return;
7622   TREE_ASM_WRITTEN (decl) = 1;
7623
7624   type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die));
7625   origin = decl_ultimate_origin (decl);
7626   if (origin != NULL)
7627     add_abstract_origin_attribute (type_die, origin);
7628   else
7629     {
7630       register tree type;
7631       add_name_and_src_coords_attributes (type_die, decl);
7632       if (DECL_ORIGINAL_TYPE (decl))
7633         {
7634           type = DECL_ORIGINAL_TYPE (decl);
7635           equate_type_number_to_die (TREE_TYPE (decl), type_die);
7636         }
7637       else
7638         type = TREE_TYPE (decl);
7639       add_type_attribute (type_die, type, TREE_READONLY (decl),
7640                           TREE_THIS_VOLATILE (decl), context_die);
7641     }
7642   if (DECL_ABSTRACT (decl))
7643     equate_decl_number_to_die (decl, type_die);
7644 }
7645
7646 /* Generate a type description DIE.  */
7647 static void
7648 gen_type_die (type, context_die)
7649      register tree type;
7650      register dw_die_ref context_die;
7651 {
7652   if (type == 0 || type == error_mark_node)
7653     {
7654       return;
7655     }
7656
7657   /* We are going to output a DIE to represent the unqualified version of of
7658      this type (i.e. without any const or volatile qualifiers) so get the
7659      main variant (i.e. the unqualified version) of this type now.  */
7660   type = type_main_variant (type);
7661
7662   if (TREE_ASM_WRITTEN (type))
7663     {
7664       return;
7665     }
7666
7667   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7668       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
7669     {
7670       TREE_ASM_WRITTEN (type) = 1;
7671       gen_decl_die (TYPE_NAME (type), context_die);
7672       return;
7673     }
7674
7675   switch (TREE_CODE (type))
7676     {
7677     case ERROR_MARK:
7678       break;
7679
7680     case POINTER_TYPE:
7681     case REFERENCE_TYPE:
7682       /* For these types, all that is required is that we output a DIE (or a
7683          set of DIEs) to represent the "basis" type.  */
7684       gen_type_die (TREE_TYPE (type), context_die);
7685       break;
7686
7687     case OFFSET_TYPE:
7688       /* This code is used for C++ pointer-to-data-member types.  */
7689       /* Output a description of the relevant class type.  */
7690       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
7691       /* Output a description of the type of the object pointed to.  */
7692       gen_type_die (TREE_TYPE (type), context_die);
7693       /* Now output a DIE to represent this pointer-to-data-member type
7694          itself.  */
7695       gen_ptr_to_mbr_type_die (type, context_die);
7696       break;
7697
7698     case SET_TYPE:
7699       gen_type_die (TYPE_DOMAIN (type), context_die);
7700       gen_set_type_die (type, context_die);
7701       break;
7702
7703     case FILE_TYPE:
7704       gen_type_die (TREE_TYPE (type), context_die);
7705       abort ();                 /* No way to represent these in Dwarf yet!  */
7706       break;
7707
7708     case FUNCTION_TYPE:
7709       /* Force out return type (in case it wasn't forced out already).  */
7710       gen_type_die (TREE_TYPE (type), context_die);
7711       gen_subroutine_type_die (type, context_die);
7712       break;
7713
7714     case METHOD_TYPE:
7715       /* Force out return type (in case it wasn't forced out already).  */
7716       gen_type_die (TREE_TYPE (type), context_die);
7717       gen_subroutine_type_die (type, context_die);
7718       break;
7719
7720     case ARRAY_TYPE:
7721       if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
7722         {
7723           gen_type_die (TREE_TYPE (type), context_die);
7724           gen_string_type_die (type, context_die);
7725         }
7726       else
7727         {
7728           gen_array_type_die (type, context_die);
7729         }
7730       break;
7731
7732     case ENUMERAL_TYPE:
7733     case RECORD_TYPE:
7734     case UNION_TYPE:
7735     case QUAL_UNION_TYPE:
7736       /* If this is a nested type whose containing class hasn't been
7737          written out yet, writing it out will cover this one, too.  */
7738       if (TYPE_CONTEXT (type)
7739           && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
7740           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
7741         {
7742           gen_type_die (TYPE_CONTEXT (type), context_die);
7743
7744           if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
7745             return;
7746
7747           /* If that failed, attach ourselves to the stub.  */
7748           push_decl_scope (TYPE_CONTEXT (type));
7749           context_die = lookup_type_die (TYPE_CONTEXT (type));
7750         }
7751
7752       if (TREE_CODE (type) == ENUMERAL_TYPE)
7753         gen_enumeration_type_die (type, context_die);
7754       else
7755         gen_struct_or_union_type_die (type, context_die);
7756
7757       if (TYPE_CONTEXT (type)
7758           && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
7759           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
7760         pop_decl_scope ();
7761
7762       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
7763          it up if it is ever completed.  gen_*_type_die will set it for us
7764          when appropriate.  */
7765       return;
7766
7767     case VOID_TYPE:
7768     case INTEGER_TYPE:
7769     case REAL_TYPE:
7770     case COMPLEX_TYPE:
7771     case BOOLEAN_TYPE:
7772     case CHAR_TYPE:
7773       /* No DIEs needed for fundamental types.  */
7774       break;
7775
7776     case LANG_TYPE:
7777       /* No Dwarf representation currently defined.  */
7778       break;
7779
7780     default:
7781       abort ();
7782     }
7783
7784   TREE_ASM_WRITTEN (type) = 1;
7785 }
7786
7787 /* Generate a DIE for a tagged type instantiation.  */
7788 static void
7789 gen_tagged_type_instantiation_die (type, context_die)
7790      register tree type;
7791      register dw_die_ref context_die;
7792 {
7793   if (type == 0 || type == error_mark_node)
7794     {
7795       return;
7796     }
7797
7798   /* We are going to output a DIE to represent the unqualified version of of
7799      this type (i.e. without any const or volatile qualifiers) so make sure
7800      that we have the main variant (i.e. the unqualified version) of this
7801      type now.  */
7802   assert (type == type_main_variant (type));
7803   assert (TREE_ASM_WRITTEN (type));
7804
7805   switch (TREE_CODE (type))
7806     {
7807     case ERROR_MARK:
7808       break;
7809
7810     case ENUMERAL_TYPE:
7811       gen_inlined_enumeration_type_die (type, context_die);
7812       break;
7813
7814     case RECORD_TYPE:
7815       gen_inlined_structure_type_die (type, context_die);
7816       break;
7817
7818     case UNION_TYPE:
7819     case QUAL_UNION_TYPE:
7820       gen_inlined_union_type_die (type, context_die);
7821       break;
7822
7823     default:
7824       abort ();                 /* Should never happen.  */
7825     }
7826 }
7827
7828 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
7829    things which are local to the given block.  */
7830 static void
7831 gen_block_die (stmt, context_die, depth)
7832      register tree stmt;
7833      register dw_die_ref context_die;
7834      int depth;
7835 {
7836   register int must_output_die = 0;
7837   register tree origin;
7838   register tree decl;
7839   register enum tree_code origin_code;
7840
7841   /* Ignore blocks never really used to make RTL.  */
7842
7843   if (!stmt || !TREE_USED (stmt))
7844     {
7845       return;
7846     }
7847
7848   /* Determine the "ultimate origin" of this block.  This block may be an
7849      inlined instance of an inlined instance of inline function, so we have
7850      to trace all of the way back through the origin chain to find out what
7851      sort of node actually served as the original seed for the creation of
7852      the current block.  */
7853   origin = block_ultimate_origin (stmt);
7854   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
7855
7856   /* Determine if we need to output any Dwarf DIEs at all to represent this
7857      block.  */
7858   if (origin_code == FUNCTION_DECL)
7859     {
7860       /* The outer scopes for inlinings *must* always be represented.  We
7861          generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
7862       must_output_die = 1;
7863     }
7864   else
7865     {
7866       /* In the case where the current block represents an inlining of the
7867          "body block" of an inline function, we must *NOT* output any DIE for
7868          this block because we have already output a DIE to represent the
7869          whole inlined function scope and the "body block" of any function
7870          doesn't really represent a different scope according to ANSI C
7871          rules.  So we check here to make sure that this block does not
7872          represent a "body block inlining" before trying to set the
7873          `must_output_die' flag.  */
7874       if (! is_body_block (origin ? origin : stmt))
7875         {
7876           /* Determine if this block directly contains any "significant"
7877              local declarations which we will need to output DIEs for.  */
7878           if (debug_info_level > DINFO_LEVEL_TERSE)
7879             {
7880               /* We are not in terse mode so *any* local declaration counts
7881                  as being a "significant" one.  */
7882               must_output_die = (BLOCK_VARS (stmt) != NULL);
7883             }
7884           else
7885             {
7886               /* We are in terse mode, so only local (nested) function
7887                  definitions count as "significant" local declarations.  */
7888               for (decl = BLOCK_VARS (stmt);
7889                    decl != NULL; decl = TREE_CHAIN (decl))
7890                 {
7891                   if (TREE_CODE (decl) == FUNCTION_DECL
7892                       && DECL_INITIAL (decl))
7893                     {
7894                       must_output_die = 1;
7895                       break;
7896                     }
7897                 }
7898             }
7899         }
7900     }
7901
7902   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
7903      DIE for any block which contains no significant local declarations at
7904      all.  Rather, in such cases we just call `decls_for_scope' so that any
7905      needed Dwarf info for any sub-blocks will get properly generated. Note
7906      that in terse mode, our definition of what constitutes a "significant"
7907      local declaration gets restricted to include only inlined function
7908      instances and local (nested) function definitions.  */
7909   if (must_output_die)
7910     {
7911       if (origin_code == FUNCTION_DECL)
7912         {
7913           gen_inlined_subroutine_die (stmt, context_die, depth);
7914         }
7915       else
7916         {
7917           gen_lexical_block_die (stmt, context_die, depth);
7918         }
7919     }
7920   else
7921     decls_for_scope (stmt, context_die, depth);
7922 }
7923
7924 /* Generate all of the decls declared within a given scope and (recursively)
7925    all of it's sub-blocks.  */
7926 static void
7927 decls_for_scope (stmt, context_die, depth)
7928      register tree stmt;
7929      register dw_die_ref context_die;
7930      int depth;
7931 {
7932   register tree decl;
7933   register tree subblocks;
7934   /* Ignore blocks never really used to make RTL.  */
7935   if (!stmt || !TREE_USED (stmt))
7936     {
7937       return;
7938     }
7939   if (!BLOCK_ABSTRACT (stmt) && depth > 0)
7940     {
7941       next_block_number++;
7942     }
7943
7944   /* Output the DIEs to represent all of the data objects and typedefs
7945      declared directly within this block but not within any nested
7946      sub-blocks.  Also, nested function and tag DIEs have been
7947      generated with a parent of NULL; fix that up now.  */
7948   for (decl = BLOCK_VARS (stmt);
7949        decl != NULL; decl = TREE_CHAIN (decl))
7950     {
7951       register dw_die_ref die;
7952
7953       if (TREE_CODE (decl) == FUNCTION_DECL)
7954         die = lookup_decl_die (decl);
7955       else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
7956         die = lookup_type_die (TREE_TYPE (decl));
7957       else
7958         die = NULL;
7959
7960       if (die && die->die_parent == NULL)
7961         {
7962           add_child_die (context_die, die);
7963           --limbo_die_count;
7964         }
7965       else
7966         gen_decl_die (decl, context_die);
7967     }
7968
7969   /* Output the DIEs to represent all sub-blocks (and the items declared
7970      therein) of this block.  */
7971   for (subblocks = BLOCK_SUBBLOCKS (stmt);
7972        subblocks != NULL;
7973        subblocks = BLOCK_CHAIN (subblocks))
7974     {
7975       gen_block_die (subblocks, context_die, depth + 1);
7976     }
7977 }
7978
7979 /* Is this a typedef we can avoid emitting?  */
7980 inline int
7981 is_redundant_typedef (decl)
7982      register tree decl;
7983 {
7984   if (TYPE_DECL_IS_STUB (decl))
7985     return 1;
7986   if (DECL_ARTIFICIAL (decl)
7987       && DECL_CONTEXT (decl)
7988       && is_tagged_type (DECL_CONTEXT (decl))
7989       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
7990       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
7991     /* Also ignore the artificial member typedef for the class name.  */
7992     return 1;
7993   return 0;
7994 }
7995
7996 /* Generate Dwarf debug information for a decl described by DECL.  */
7997 static void
7998 gen_decl_die (decl, context_die)
7999      register tree decl;
8000      register dw_die_ref context_die;
8001 {
8002   register tree origin;
8003   /* Make a note of the decl node we are going to be working on.  We may need
8004      to give the user the source coordinates of where it appeared in case we
8005      notice (later on) that something about it looks screwy.  */
8006   dwarf_last_decl = decl;
8007
8008   if (TREE_CODE (decl) == ERROR_MARK)
8009     {
8010       return;
8011     }
8012
8013   /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
8014      ignore a function definition, since that would screw up our count of
8015      blocks, and that it turn will completely screw up the the labels we will
8016      reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
8017      subsequent blocks).  */
8018   if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
8019     {
8020       return;
8021     }
8022
8023   switch (TREE_CODE (decl))
8024     {
8025     case CONST_DECL:
8026       /* The individual enumerators of an enum type get output when we output
8027          the Dwarf representation of the relevant enum type itself.  */
8028       break;
8029
8030     case FUNCTION_DECL:
8031       /* Don't output any DIEs to represent mere function declarations,
8032          unless they are class members or explicit block externs.  */
8033       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
8034           && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl)))
8035         {
8036           break;
8037         }
8038
8039       if (debug_info_level > DINFO_LEVEL_TERSE)
8040         {
8041           /* Before we describe the FUNCTION_DECL itself, make sure that we
8042              have described its return type.  */
8043           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
8044
8045           /* And its containing type.  */
8046           origin = decl_class_context (decl);
8047           if (origin)
8048             gen_type_die (origin, context_die);
8049
8050           /* And its virtual context.  */
8051           if (DECL_VINDEX (decl))
8052             gen_type_die (DECL_CONTEXT (decl), context_die);
8053         }
8054
8055       /* Now output a DIE to represent the function itself.  */
8056       gen_subprogram_die (decl, context_die);
8057       break;
8058
8059     case TYPE_DECL:
8060       /* If we are in terse mode, don't generate any DIEs to represent any
8061          actual typedefs.  */
8062       if (debug_info_level <= DINFO_LEVEL_TERSE)
8063         break;
8064
8065       /* In the special case of a TYPE_DECL node representing the
8066          declaration of some type tag, if the given TYPE_DECL is marked as
8067          having been instantiated from some other (original) TYPE_DECL node
8068          (e.g. one which was generated within the original definition of an
8069          inline function) we have to generate a special (abbreviated)
8070          DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration-type
8071          DIE here.  */
8072       if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl))
8073         {
8074           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
8075           break;
8076         }
8077
8078       if (is_redundant_typedef (decl))
8079         gen_type_die (TREE_TYPE (decl), context_die);
8080       else
8081         {
8082           /* Output a DIE to represent the typedef itself.  */
8083           gen_typedef_die (decl, context_die);
8084         }
8085       break;
8086
8087     case LABEL_DECL:
8088       if (debug_info_level >= DINFO_LEVEL_NORMAL)
8089         {
8090           gen_label_die (decl, context_die);
8091         }
8092       break;
8093
8094     case VAR_DECL:
8095       /* If we are in terse mode, don't generate any DIEs to represent any
8096          variable declarations or definitions.  */
8097       if (debug_info_level <= DINFO_LEVEL_TERSE)
8098         {
8099           break;
8100         }
8101
8102       /* Output any DIEs that are needed to specify the type of this data
8103          object.  */
8104       gen_type_die (TREE_TYPE (decl), context_die);
8105
8106       /* And its containing type.  */
8107       origin = decl_class_context (decl);
8108       if (origin)
8109         gen_type_die (origin, context_die);
8110
8111       /* Now output the DIE to represent the data object itself.  This gets
8112          complicated because of the possibility that the VAR_DECL really
8113          represents an inlined instance of a formal parameter for an inline
8114          function.  */
8115       origin = decl_ultimate_origin (decl);
8116       if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
8117         {
8118           gen_formal_parameter_die (decl, context_die);
8119         }
8120       else
8121         {
8122           gen_variable_die (decl, context_die);
8123         }
8124       break;
8125
8126     case FIELD_DECL:
8127       /* Ignore the nameless fields that are used to skip bits, but
8128          handle C++ anonymous unions.  */
8129       if (DECL_NAME (decl) != 0 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
8130         {
8131           gen_type_die (member_declared_type (decl), context_die);
8132           gen_field_die (decl, context_die);
8133         }
8134       break;
8135
8136     case PARM_DECL:
8137       gen_type_die (TREE_TYPE (decl), context_die);
8138       gen_formal_parameter_die (decl, context_die);
8139       break;
8140
8141     default:
8142       abort ();
8143     }
8144 }
8145 \f
8146 /***************** Debug Information Generation Hooks ***********************/
8147 void
8148 dwarf2out_decl (decl)
8149      register tree decl;
8150 {
8151   register dw_die_ref context_die = comp_unit_die;
8152
8153   if (TREE_CODE (decl) == ERROR_MARK)
8154     {
8155       return;
8156     }
8157
8158   /* If this ..._DECL node is marked to be ignored, then ignore it.  We gotta
8159      hope that the node in question doesn't represent a function definition.
8160      If it does, then totally ignoring it is bound to screw up our count of
8161      blocks, and that it turn will completely screw up the the labels we will
8162      reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
8163      subsequent blocks).  (It's too bad that BLOCK nodes don't carry their
8164      own sequence numbers with them!) */
8165   if (DECL_IGNORED_P (decl))
8166     {
8167       if (TREE_CODE (decl) == FUNCTION_DECL
8168           && DECL_INITIAL (decl) != NULL)
8169         {
8170           abort ();
8171         }
8172       return;
8173     }
8174
8175   switch (TREE_CODE (decl))
8176     {
8177     case FUNCTION_DECL:
8178       /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
8179          builtin function.  Explicit programmer-supplied declarations of
8180          these same functions should NOT be ignored however.  */
8181       if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
8182         {
8183           return;
8184         }
8185
8186       /* What we would really like to do here is to filter out all mere
8187          file-scope declarations of file-scope functions which are never
8188          referenced later within this translation unit (and keep all of ones
8189          that *are* referenced later on) but we aren't clarvoiant, so we have
8190          no idea which functions will be referenced in the future (i.e. later
8191          on within the current translation unit). So here we just ignore all
8192          file-scope function declarations which are not also definitions.  If
8193          and when the debugger needs to know something about these funcstion,
8194          it wil have to hunt around and find the DWARF information associated
8195          with the definition of the function. Note that we can't just check
8196          `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
8197          definitions and which ones represent mere declarations.  We have to
8198          check `DECL_INITIAL' instead. That's because the C front-end
8199          supports some weird semantics for "extern inline" function
8200          definitions.  These can get inlined within the current translation
8201          unit (an thus, we need to generate DWARF info for their abstract
8202          instances so that the DWARF info for the concrete inlined instances
8203          can have something to refer to) but the compiler never generates any
8204          out-of-lines instances of such things (despite the fact that they
8205          *are* definitions).  The important point is that the C front-end
8206          marks these "extern inline" functions as DECL_EXTERNAL, but we need
8207          to generate DWARF for them anyway. Note that the C++ front-end also
8208          plays some similar games for inline function definitions appearing
8209          within include files which also contain
8210          `#pragma interface' pragmas.  */
8211       if (DECL_INITIAL (decl) == NULL_TREE)
8212         {
8213           return;
8214         }
8215
8216       /* If we're a nested function, initially use a parent of NULL; if we're
8217          a plain function, this will be fixed up in decls_for_scope.  If
8218          we're a method, it will be ignored, since we already have a DIE.  */
8219       if (decl_function_context (decl))
8220         context_die = NULL;
8221
8222       break;
8223
8224     case VAR_DECL:
8225       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
8226          declaration and if the declaration was never even referenced from
8227          within this entire compilation unit.  We suppress these DIEs in
8228          order to save space in the .debug section (by eliminating entries
8229          which are probably useless).  Note that we must not suppress
8230          block-local extern declarations (whether used or not) because that
8231          would screw-up the debugger's name lookup mechanism and cause it to
8232          miss things which really ought to be in scope at a given point.  */
8233       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
8234         {
8235           return;
8236         }
8237
8238       /* If we are in terse mode, don't generate any DIEs to represent any
8239          variable declarations or definitions.  */
8240       if (debug_info_level <= DINFO_LEVEL_TERSE)
8241         {
8242           return;
8243         }
8244       break;
8245
8246     case TYPE_DECL:
8247       /* Don't bother trying to generate any DIEs to represent any of the
8248          normal built-in types for the language we are compiling.  */
8249       if (DECL_SOURCE_LINE (decl) == 0)
8250         {
8251           /* OK, we need to generate one for `bool' so GDB knows what type
8252              comparisons have.  */
8253           if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
8254                == DW_LANG_C_plus_plus)
8255               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
8256             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
8257           return;
8258         }
8259
8260       /* If we are in terse mode, don't generate any DIEs for types.  */
8261       if (debug_info_level <= DINFO_LEVEL_TERSE)
8262         return;
8263
8264       /* If we're a function-scope tag, initially use a parent of NULL;
8265          this will be fixed up in decls_for_scope.  */
8266       if (decl_function_context (decl))
8267         context_die = NULL;
8268
8269       break;
8270
8271     default:
8272       return;
8273     }
8274
8275   gen_decl_die (decl, context_die);
8276   output_pending_types_for_scope (comp_unit_die);
8277
8278   if (TREE_CODE (decl) == FUNCTION_DECL
8279       && DECL_INITIAL (decl) != NULL)
8280     {
8281       current_funcdef_number++;
8282     }
8283
8284 }
8285
8286 /* Output a marker (i.e. a label) for the beginning of the generated code for
8287    a lexical block.  */
8288 void
8289 dwarf2out_begin_block (blocknum)
8290      register unsigned blocknum;
8291 {
8292   function_section (current_function_decl);
8293   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
8294 }
8295
8296 /* Output a marker (i.e. a label) for the end of the generated code for a
8297    lexical block.  */
8298 void
8299 dwarf2out_end_block (blocknum)
8300      register unsigned blocknum;
8301 {
8302   function_section (current_function_decl);
8303   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
8304 }
8305
8306 /* Output a marker (i.e. a label) at a point in the assembly code which
8307    corresponds to a given source level label.  */
8308 void
8309 dwarf2out_label (insn)
8310      register rtx insn;
8311 {
8312   char label[MAX_ARTIFICIAL_LABEL_BYTES];
8313   if (debug_info_level >= DINFO_LEVEL_NORMAL)
8314     {
8315       function_section (current_function_decl);
8316       sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
8317       ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
8318                                  (unsigned) INSN_UID (insn));
8319     }
8320 }
8321
8322 /* Output a marker (i.e. a label) for the beginning of a function, before
8323    the prologue.  */
8324 void
8325 dwarf2out_begin_prologue ()
8326 {
8327   char label[MAX_ARTIFICIAL_LABEL_BYTES];
8328   register dw_fde_ref fde;
8329
8330   function_section (current_function_decl);
8331   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
8332                                current_funcdef_number);
8333   ASM_OUTPUT_LABEL (asm_out_file, label);
8334
8335   /* Expand the fde table if necessary.  */
8336   if (fde_table_in_use == fde_table_allocated)
8337     {
8338       fde_table_allocated += FDE_TABLE_INCREMENT;
8339       fde_table = (dw_fde_ref) xrealloc (fde_table,
8340                fde_table_allocated * sizeof (dw_fde_node));
8341     }
8342
8343   /* Record the FDE associated with this function.  */
8344   current_funcdef_fde = fde_table_in_use;
8345
8346   /* Add the new FDE at the end of the fde_table.  */
8347   fde = &fde_table[fde_table_in_use++];
8348   fde->dw_fde_begin = xstrdup (label);
8349   fde->dw_fde_current_label = NULL;
8350   fde->dw_fde_end = NULL;
8351   fde->dw_fde_cfi = NULL;
8352 }
8353
8354 /* Output a marker (i.e. a label) for the absolute end of the generated code
8355    for a function definition.  This gets called *after* the epilogue code has
8356    been generated.  */
8357 void
8358 dwarf2out_end_epilogue ()
8359 {
8360   dw_fde_ref fde;
8361   char label[MAX_ARTIFICIAL_LABEL_BYTES];
8362   /* Output a label to mark the endpoint of the code generated for this
8363      function.        */
8364   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
8365   ASM_OUTPUT_LABEL (asm_out_file, label);
8366   fde = &fde_table[fde_table_in_use - 1];
8367   fde->dw_fde_end = xstrdup (label);
8368 }
8369
8370 /* Lookup a filename (in the list of filenames that we know about here in
8371    dwarf2out.c) and return its "index".  The index of each (known) filename is
8372    just a unique number which is associated with only that one filename.
8373    We need such numbers for the sake of generating labels
8374    (in the .debug_sfnames section) and references to those
8375    files  numbers (in the .debug_srcinfo and.debug_macinfo sections).
8376    If the filename given as an argument is not found in our current list,
8377    add it to the list and assign it the next available unique index number.
8378    In order to speed up searches, we remember the index of the filename
8379    was looked up last.  This handles the majority of all searches.  */
8380 static unsigned
8381 lookup_filename (file_name)
8382      char *file_name;
8383 {
8384   static unsigned last_file_lookup_index = 0;
8385   register char *fn;
8386   register unsigned i;
8387
8388   /* Check to see if the file name that was searched on the previous call
8389      matches this file name. If so, return the index.  */
8390   if (last_file_lookup_index != 0)
8391     {
8392       fn = file_table[last_file_lookup_index];
8393       if (strcmp (file_name, fn) == 0)
8394         {
8395           return last_file_lookup_index;
8396         }
8397     }
8398
8399   /* Didn't match the previous lookup, search the table */
8400   for (i = 1; i < file_table_in_use; ++i)
8401     {
8402       fn = file_table[i];
8403       if (strcmp (file_name, fn) == 0)
8404         {
8405           last_file_lookup_index = i;
8406           return i;
8407         }
8408     }
8409
8410   /* Prepare to add a new table entry by making sure there is enough space in
8411      the table to do so.  If not, expand the current table.  */
8412   if (file_table_in_use == file_table_allocated)
8413     {
8414       file_table_allocated += FILE_TABLE_INCREMENT;
8415       file_table
8416         = (char **)
8417         xrealloc (file_table, file_table_allocated * sizeof (char *));
8418     }
8419
8420   /* add the new entry to the end of the filename table.  */
8421   file_table[file_table_in_use] = xstrdup (file_name);
8422   last_file_lookup_index = file_table_in_use++;
8423   return last_file_lookup_index;
8424 }
8425
8426 /* Output a label to mark the beginning of a source code line entry
8427    and record information relating to this source line, in
8428    'line_info_table' for later output of the .debug_line section.  */
8429 void
8430 dwarf2out_line (filename, line)
8431      register char *filename;
8432      register unsigned line;
8433 {
8434   if (debug_info_level >= DINFO_LEVEL_NORMAL)
8435     {
8436       function_section (current_function_decl);
8437
8438       if (DECL_SECTION_NAME (current_function_decl))
8439         {
8440           register dw_separate_line_info_ref line_info;
8441           ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
8442                                      separate_line_info_table_in_use);
8443           fputc ('\n', asm_out_file);
8444
8445           /* expand the line info table if necessary */
8446           if (separate_line_info_table_in_use
8447               == separate_line_info_table_allocated)
8448             {
8449               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
8450               separate_line_info_table
8451                 = (dw_separate_line_info_ref) xrealloc
8452                 (separate_line_info_table,
8453                  separate_line_info_table_allocated
8454                  * sizeof (dw_separate_line_info_entry));
8455             }
8456           /* add the new entry at the end of the line_info_table.  */
8457           line_info
8458             = &separate_line_info_table[separate_line_info_table_in_use++];
8459           line_info->dw_file_num = lookup_filename (filename);
8460           line_info->dw_line_num = line;
8461           line_info->function = current_funcdef_number;
8462         }
8463       else
8464         {
8465           register dw_line_info_ref line_info;
8466           ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
8467                                      line_info_table_in_use);
8468           fputc ('\n', asm_out_file);
8469
8470           /* expand the line info table if necessary */
8471           if (line_info_table_in_use == line_info_table_allocated)
8472             {
8473               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
8474               line_info_table
8475                 = (dw_line_info_ref) xrealloc
8476                 (line_info_table,
8477                  line_info_table_allocated * sizeof (dw_line_info_entry));
8478             }
8479           /* add the new entry at the end of the line_info_table.  */
8480           line_info = &line_info_table[line_info_table_in_use++];
8481           line_info->dw_file_num = lookup_filename (filename);
8482           line_info->dw_line_num = line;
8483         }
8484     }
8485 }
8486
8487 /* Record the beginning of a new source file, for later output
8488    of the .debug_macinfo section.  At present, unimplemented.  */
8489 void
8490 dwarf2out_start_source_file (filename)
8491      register char *filename;
8492 {
8493 }
8494
8495 /* Record the end of a source file, for later output
8496    of the .debug_macinfo section.  At present, unimplemented.  */
8497 void
8498 dwarf2out_end_source_file ()
8499 {
8500 }
8501
8502 /* Called from check_newline in c-parse.y.  The `buffer' parameter contains
8503    the tail part of the directive line, i.e. the part which is past the
8504    initial whitespace, #, whitespace, directive-name, whitespace part.  */
8505 void
8506 dwarf2out_define (lineno, buffer)
8507      register unsigned lineno;
8508      register char *buffer;
8509 {
8510   static int initialized = 0;
8511   if (!initialized)
8512     {
8513       dwarf2out_start_source_file (primary_filename);
8514       initialized = 1;
8515     }
8516 }
8517
8518 /* Called from check_newline in c-parse.y.  The `buffer' parameter contains
8519    the tail part of the directive line, i.e. the part which is past the
8520    initial whitespace, #, whitespace, directive-name, whitespace part.  */
8521 void
8522 dwarf2out_undef (lineno, buffer)
8523      register unsigned lineno;
8524      register char *buffer;
8525 {
8526 }
8527
8528 /* Set up for Dwarf output at the start of compilation.  */
8529 void
8530 dwarf2out_init (asm_out_file, main_input_filename)
8531      register FILE *asm_out_file;
8532      register char *main_input_filename;
8533 {
8534   /* Remember the name of the primary input file.  */
8535   primary_filename = main_input_filename;
8536
8537   /* Allocate the initial hunk of the file_table.  */
8538   file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
8539   bzero (file_table, FILE_TABLE_INCREMENT * sizeof (char *));
8540   file_table_allocated = FILE_TABLE_INCREMENT;
8541   /* skip the first entry - file numbers begin at 1 */
8542   file_table_in_use = 1;
8543
8544   /* Allocate the initial hunk of the decl_die_table.  */
8545   decl_die_table
8546     = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
8547   bzero (decl_die_table, DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
8548   decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
8549   decl_die_table_in_use = 0;
8550
8551   /* Allocate the initial hunk of the decl_scope_table.  */
8552   decl_scope_table
8553     = (tree *) xmalloc (DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
8554   bzero (decl_scope_table, DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
8555   decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
8556   decl_scope_depth = 0;
8557
8558   /* Allocate the initial hunk of the abbrev_die_table.  */
8559   abbrev_die_table
8560     = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
8561                               * sizeof (dw_die_ref));
8562   bzero (abbrev_die_table, ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
8563   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
8564   /* zero-th entry is allocated, but unused */
8565   abbrev_die_table_in_use = 1;
8566
8567   /* Allocate the initial hunk of the line_info_table.  */
8568   line_info_table
8569     = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
8570                                   * sizeof (dw_line_info_entry));
8571   bzero (line_info_table, LINE_INFO_TABLE_INCREMENT
8572          * sizeof (dw_line_info_entry));
8573   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
8574   /* zero-th entry is allocated, but unused */
8575   line_info_table_in_use = 1;
8576
8577   /* Allocate the initial hunk of the fde_table.  */
8578   fde_table = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
8579   bzero (fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
8580   fde_table_allocated = FDE_TABLE_INCREMENT;
8581   fde_table_in_use = 0;
8582
8583   /* Generate the initial DIE for the .debug section.  Note that the (string)
8584      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
8585      will (typically) be a relative pathname and that this pathname should be
8586      taken as being relative to the directory from which the compiler was
8587      invoked when the given (base) source file was compiled.  */
8588   gen_compile_unit_die (main_input_filename);
8589
8590   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
8591
8592   /* Generate the CFA instructions common to all FDE's.  Do it now for the
8593      sake of lookup_cfa.  */
8594
8595 #ifdef INCOMING_RETURN_ADDR_RTX
8596   /* On entry, the Canonical Frame Address is at SP+0.  */
8597   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, 0);
8598   initial_return_save (INCOMING_RETURN_ADDR_RTX);
8599 #endif
8600 }
8601
8602 /* Output stuff that dwarf requires at the end of every file,
8603    and generate the DWARF-2 debugging info.  */
8604 void
8605 dwarf2out_finish ()
8606 {
8607   /* Traverse the DIE tree and add sibling attributes to those DIE's
8608      that have children.  */
8609   add_sibling_attributes (comp_unit_die);
8610
8611   /* Output a terminator label for the .text section.  */
8612   fputc ('\n', asm_out_file);
8613   ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
8614   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
8615
8616 #if 0
8617   /* Output a terminator label for the .data section.  */
8618   fputc ('\n', asm_out_file);
8619   ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
8620   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
8621
8622   /* Output a terminator label for the .bss section.  */
8623   fputc ('\n', asm_out_file);
8624   ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
8625   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
8626 #endif
8627
8628   /* Output the source line correspondence table.  */
8629   if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
8630     {
8631       fputc ('\n', asm_out_file);
8632       ASM_OUTPUT_SECTION (asm_out_file, LINE_SECTION);
8633       output_line_info ();
8634
8635       /* We can only use the low/high_pc attributes if all of the code
8636          was in .text.  */
8637       if (separate_line_info_table_in_use == 0)
8638         {
8639           add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, TEXT_SECTION);
8640           add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
8641         }
8642       add_AT_section_offset (comp_unit_die, DW_AT_stmt_list, LINE_SECTION);
8643     }
8644
8645   /* Output the abbreviation table.  */
8646   fputc ('\n', asm_out_file);
8647   ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
8648   build_abbrev_table (comp_unit_die);
8649   output_abbrev_section ();
8650
8651   /* Initialize the beginning DIE offset - and calculate sizes/offsets.   */
8652   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8653   calc_die_sizes (comp_unit_die);
8654
8655   /* calculate sizes/offsets for FDEs.  */
8656   calc_fde_sizes ();
8657
8658   /* Output debugging information.  */
8659   fputc ('\n', asm_out_file);
8660   ASM_OUTPUT_SECTION (asm_out_file, DEBUG_SECTION);
8661   output_compilation_unit_header ();
8662   output_die (comp_unit_die);
8663
8664   if (pubname_table_in_use)
8665     {
8666       /* Output public names table.  */
8667       fputc ('\n', asm_out_file);
8668       ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
8669       output_pubnames ();
8670     }
8671
8672   if (fde_table_in_use)
8673     {
8674       /* Output call frame information.  */
8675       output_call_frame_info ();
8676
8677       /* Output the address range information.  */
8678       fputc ('\n', asm_out_file);
8679       ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
8680       output_aranges ();
8681     }
8682
8683   /* The only DIE we should have with a parent of NULL is comp_unit_die.  */
8684   assert (limbo_die_count == 1);
8685 }
8686 #endif /* DWARF2_DEBUGGING_INFO */