gcc/dwarfout.c

   1 /* Output Dwarf format symbol table information from the GNU C compiler.
   2    Copyright (C) 1992, 1993, 1995, 1996 Free Software Foundation, Inc.
   3    Contributed by Ron Guilmette (rfg@monkeys.com) of Network Computing Devices.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23
  24 #ifndef DWARF_VERSION
  25 #define DWARF_VERSION 1
  26 #endif
  27 #if defined (DWARF_DEBUGGING_INFO) && (DWARF_VERSION != 2)
  28 #include <stdio.h>
  29 #include "dwarf.h"
  30 #include "tree.h"
  31 #include "flags.h"
  32 #include "rtl.h"
  33 #include "hard-reg-set.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 #if defined(DWARF_TIMESTAMPS)
  43 #if defined(POSIX)
  44 #include <time.h>
  45 #else /* !defined(POSIX) */
  46 #include <sys/types.h>
  47 #if defined(__STDC__)
  48 extern time_t time (time_t *);
  49 #else /* !defined(__STDC__) */
  50 extern time_t time ();
  51 #endif /* !defined(__STDC__) */
  52 #endif /* !defined(POSIX) */
  53 #endif /* defined(DWARF_TIMESTAMPS) */
  54
  55 extern char *getpwd ();
  56
  57 extern char *index ();
  58 extern char *rindex ();
  59
  60 /* IMPORTANT NOTE: Please see the file README.DWARF for important details
  61    regarding the GNU implementation of Dwarf.  */
  62
  63 /* NOTE: In the comments in this file, many references are made to
  64    so called "Debugging Information Entries".  For the sake of brevity,
  65    this term is abbreviated to `DIE' throughout the remainder of this
  66    file.  */
  67
  68 /* Note that the implementation of C++ support herein is (as yet) unfinished.
  69    If you want to try to complete it, more power to you.  */
  70
  71 #if !defined(__GNUC__) || (NDEBUG != 1)
  72 #define inline
  73 #endif
  74
  75 /* How to start an assembler comment.  */
  76 #ifndef ASM_COMMENT_START
  77 #define ASM_COMMENT_START ";#"
  78 #endif
  79
  80 /* How to print out a register name.  */
  81 #ifndef PRINT_REG
  82 #define PRINT_REG(RTX, CODE, FILE) \
  83   fprintf ((FILE), "%s", reg_names[REGNO (RTX)])
  84 #endif
  85
  86 /* Define a macro which returns non-zero for any tagged type which is
  87    used (directly or indirectly) in the specification of either some
  88    function's return type or some formal parameter of some function.
  89    We use this macro when we are operating in "terse" mode to help us
  90    know what tagged types have to be represented in Dwarf (even in
  91    terse mode) and which ones don't.
  92
  93    A flag bit with this meaning really should be a part of the normal
  94    GCC ..._TYPE nodes, but at the moment, there is no such bit defined
  95    for these nodes.  For now, we have to just fake it.  It it safe for
  96    us to simply return zero for all complete tagged types (which will
  97    get forced out anyway if they were used in the specification of some
  98    formal or return type) and non-zero for all incomplete tagged types.
  99 */
 100
 101 #define TYPE_USED_FOR_FUNCTION(tagged_type) (TYPE_SIZE (tagged_type) == 0)
 102
 103 extern int flag_traditional;
 104 extern char *version_string;
 105 extern char *language_string;
 106
 107 /* Maximum size (in bytes) of an artificially generated label.  */
 108
 109 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 110 \f
 111 /* Make sure we know the sizes of the various types dwarf can describe.
 112    These are only defaults.  If the sizes are different for your target,
 113    you should override these values by defining the appropriate symbols
 114    in your tm.h file.  */
 115
 116 #ifndef CHAR_TYPE_SIZE
 117 #define CHAR_TYPE_SIZE BITS_PER_UNIT
 118 #endif
 119
 120 #ifndef SHORT_TYPE_SIZE
 121 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
 122 #endif
 123
 124 #ifndef INT_TYPE_SIZE
 125 #define INT_TYPE_SIZE BITS_PER_WORD
 126 #endif
 127
 128 #ifndef LONG_TYPE_SIZE
 129 #define LONG_TYPE_SIZE BITS_PER_WORD
 130 #endif
 131
 132 #ifndef LONG_LONG_TYPE_SIZE
 133 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
 134 #endif
 135
 136 #ifndef WCHAR_TYPE_SIZE
 137 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
 138 #endif
 139
 140 #ifndef WCHAR_UNSIGNED
 141 #define WCHAR_UNSIGNED 0
 142 #endif
 143
 144 #ifndef FLOAT_TYPE_SIZE
 145 #define FLOAT_TYPE_SIZE BITS_PER_WORD
 146 #endif
 147
 148 #ifndef DOUBLE_TYPE_SIZE
 149 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
 150 #endif
 151
 152 #ifndef LONG_DOUBLE_TYPE_SIZE
 153 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
 154 #endif
 155 \f
 156 /* Structure to keep track of source filenames.  */
 157
 158 struct filename_entry {
 159   unsigned      number;
 160   char *        name;
 161 };
 162
 163 typedef struct filename_entry filename_entry;
 164
 165 /* Pointer to an array of elements, each one having the structure above.  */
 166
 167 static filename_entry *filename_table;
 168
 169 /* Total number of entries in the table (i.e. array) pointed to by
 170    `filename_table'.  This is the *total* and includes both used and
 171    unused slots.  */
 172
 173 static unsigned ft_entries_allocated;
 174
 175 /* Number of entries in the filename_table which are actually in use.  */
 176
 177 static unsigned ft_entries;
 178
 179 /* Size (in elements) of increments by which we may expand the filename
 180    table.  Actually, a single hunk of space of this size should be enough
 181    for most typical programs.    */
 182
 183 #define FT_ENTRIES_INCREMENT 64
 184
 185 /* Local pointer to the name of the main input file.  Initialized in
 186    dwarfout_init.  */
 187
 188 static char *primary_filename;
 189
 190 /* Pointer to the most recent filename for which we produced some line info.  */
 191
 192 static char *last_filename;
 193
 194 /* For Dwarf output, we must assign lexical-blocks id numbers
 195    in the order in which their beginnings are encountered.
 196    We output Dwarf debugging info that refers to the beginnings
 197    and ends of the ranges of code for each lexical block with
 198    assembler labels ..Bn and ..Bn.e, where n is the block number.
 199    The labels themselves are generated in final.c, which assigns
 200    numbers to the blocks in the same way.  */
 201
 202 static unsigned next_block_number = 2;
 203
 204 /* Counter to generate unique names for DIEs.  */
 205
 206 static unsigned next_unused_dienum = 1;
 207
 208 /* Number of the DIE which is currently being generated.  */
 209
 210 static unsigned current_dienum;
 211
 212 /* Number to use for the special "pubname" label on the next DIE which
 213    represents a function or data object defined in this compilation
 214    unit which has "extern" linkage.  */
 215
 216 static next_pubname_number = 0;
 217
 218 #define NEXT_DIE_NUM pending_sibling_stack[pending_siblings-1]
 219
 220 /* Pointer to a dynamically allocated list of pre-reserved and still
 221    pending sibling DIE numbers.  Note that this list will grow as needed.  */
 222
 223 static unsigned *pending_sibling_stack;
 224
 225 /* Counter to keep track of the number of pre-reserved and still pending
 226    sibling DIE numbers.  */
 227
 228 static unsigned pending_siblings;
 229
 230 /* The currently allocated size of the above list (expressed in number of
 231    list elements).  */
 232
 233 static unsigned pending_siblings_allocated;
 234
 235 /* Size (in elements) of increments by which we may expand the pending
 236    sibling stack.  Actually, a single hunk of space of this size should
 237    be enough for most typical programs.  */
 238
 239 #define PENDING_SIBLINGS_INCREMENT 64
 240
 241 /* Non-zero if we are performing our file-scope finalization pass and if
 242    we should force out Dwarf descriptions of any and all file-scope
 243    tagged types which are still incomplete types.  */
 244
 245 static int finalizing = 0;
 246
 247 /* A pointer to the base of a list of pending types which we haven't
 248    generated DIEs for yet, but which we will have to come back to
 249    later on.  */
 250
 251 static tree *pending_types_list;
 252
 253 /* Number of elements currently allocated for the pending_types_list.  */
 254
 255 static unsigned pending_types_allocated;
 256
 257 /* Number of elements of pending_types_list currently in use.  */
 258
 259 static unsigned pending_types;
 260
 261 /* Size (in elements) of increments by which we may expand the pending
 262    types list.  Actually, a single hunk of space of this size should
 263    be enough for most typical programs.  */
 264
 265 #define PENDING_TYPES_INCREMENT 64
 266
 267 /* Pointer to an artificial RECORD_TYPE which we create in dwarfout_init.
 268    This is used in a hack to help us get the DIEs describing types of
 269    formal parameters to come *after* all of the DIEs describing the formal
 270    parameters themselves.  That's necessary in order to be compatible
 271    with what the brain-damaged svr4 SDB debugger requires.  */
 272
 273 static tree fake_containing_scope;
 274
 275 /* The number of the current function definition that we are generating
 276    debugging information for.  These numbers range from 1 up to the maximum
 277    number of function definitions contained within the current compilation
 278    unit.  These numbers are used to create unique labels for various things
 279    contained within various function definitions.  */
 280
 281 static unsigned current_funcdef_number = 1;
 282
 283 /* A pointer to the ..._DECL node which we have most recently been working
 284    on.  We keep this around just in case something about it looks screwy
 285    and we want to tell the user what the source coordinates for the actual
 286    declaration are.  */
 287
 288 static tree dwarf_last_decl;
 289
 290 /* Forward declarations for functions defined in this file.  */
 291
 292 static char *dwarf_tag_name             PROTO((unsigned));
 293 static char *dwarf_attr_name            PROTO((unsigned));
 294 static char *dwarf_stack_op_name        PROTO((unsigned));
 295 static char *dwarf_typemod_name         PROTO((unsigned));
 296 static char *dwarf_fmt_byte_name        PROTO((unsigned));
 297 static char *dwarf_fund_type_name       PROTO((unsigned));
 298 static tree decl_ultimate_origin        PROTO((tree));
 299 static tree block_ultimate_origin       PROTO((tree));
 300 static void output_unsigned_leb128      PROTO((unsigned long));
 301 static void output_signed_leb128        PROTO((long));
 302 static inline int is_body_block         PROTO((tree));
 303 static int fundamental_type_code        PROTO((tree));
 304 static tree root_type                   PROTO((tree));
 305 static void write_modifier_bytes        PROTO((tree, int, int));
 306 static inline int type_is_fundamental   PROTO((tree));
 307 static void equate_decl_number_to_die_number PROTO((tree));
 308 static inline void equate_type_number_to_die_number PROTO((tree));
 309 static void output_reg_number           PROTO((rtx));
 310 static void output_mem_loc_descriptor   PROTO((rtx));
 311 static void output_loc_descriptor       PROTO((rtx));
 312 static void output_bound_representation PROTO((tree, unsigned, int));
 313 static void output_enumeral_list        PROTO((tree));
 314 static inline unsigned ceiling          PROTO((unsigned, unsigned));
 315 static inline tree field_type           PROTO((tree));
 316 static inline unsigned simple_type_align_in_bits PROTO((tree));
 317 static inline unsigned simple_type_size_in_bits  PROTO((tree));
 318 static unsigned field_byte_offset       PROTO((tree));
 319 static inline void sibling_attribute    PROTO((void));
 320 static void location_attribute          PROTO((rtx));
 321 static void data_member_location_attribute PROTO((tree));
 322 static void const_value_attribute       PROTO((rtx));
 323 static void location_or_const_value_attribute PROTO((tree));
 324 static inline void name_attribute       PROTO((char *));
 325 static inline void fund_type_attribute  PROTO((unsigned));
 326 static void mod_fund_type_attribute     PROTO((tree, int, int));
 327 static inline void user_def_type_attribute PROTO((tree));
 328 static void mod_u_d_type_attribute      PROTO((tree, int, int));
 329 static inline void ordering_attribute   PROTO((unsigned));
 330 static void subscript_data_attribute    PROTO((tree));
 331 static void byte_size_attribute         PROTO((tree));
 332 static inline void bit_offset_attribute PROTO((tree));
 333 static inline void bit_size_attribute   PROTO((tree));
 334 static inline void element_list_attribute PROTO((tree));
 335 static inline void stmt_list_attribute  PROTO((char *));
 336 static inline void low_pc_attribute     PROTO((char *));
 337 static inline void high_pc_attribute    PROTO((char *));
 338 static inline void body_begin_attribute PROTO((char *));
 339 static inline void body_end_attribute   PROTO((char *));
 340 static inline void langauge_attribute   PROTO((unsigned));
 341 static inline void member_attribute     PROTO((tree));
 342 static inline void string_length_attribute PROTO((tree));
 343 static inline void comp_dir_attribute   PROTO((char *));
 344 static inline void sf_names_attribute   PROTO((char *));
 345 static inline void src_info_attribute   PROTO((char *));
 346 static inline void mac_info_attribute   PROTO((char *));
 347 static inline void prototyped_attribute PROTO((tree));
 348 static inline void producer_attribute   PROTO((char *));
 349 static inline void inline_attribute     PROTO((tree));
 350 static inline void containing_type_attribute PROTO((tree));
 351 static inline void abstract_origin_attribute PROTO((tree));
 352 static inline void src_coords_attribute PROTO((unsigned, unsigned));
 353 static inline void pure_or_virtual_attribute PROTO((tree));
 354 static void name_and_src_coords_attributes PROTO((tree));
 355 static void type_attribute              PROTO((tree, int, int));
 356 static char *type_tag                   PROTO((tree));
 357 static inline void dienum_push          PROTO((void));
 358 static inline void dienum_pop           PROTO((void));
 359 static inline tree member_declared_type PROTO((tree));
 360 static char *function_start_label       PROTO((tree));
 361 static void output_array_type_die       PROTO((void *));
 362 static void output_set_type_die         PROTO((void *));
 363 static void output_entry_point_die      PROTO((void *));
 364 static void output_inlined_enumeration_type_die PROTO((void *));
 365 static void output_inlined_structure_type_die PROTO((void *));
 366 static void output_inlined_union_type_die PROTO((void *));
 367 static void output_enumeration_type_die PROTO((void *));
 368 static void output_formal_parameter_die PROTO((void *));
 369 static void output_global_subroutine_die PROTO((void *));
 370 static void output_global_variable_die  PROTO((void *));
 371 static void output_label_die            PROTO((void *));
 372 static void output_lexical_block_die    PROTO((void *));
 373 static void output_inlined_subroutine_die PROTO((void *));
 374 static void output_local_variable_die   PROTO((void *));
 375 static void output_member_die           PROTO((void *));
 376 static void output_pointer_type_die     PROTO((void *));
 377 static void output_reference_type_die   PROTO((void *));
 378 static void output_ptr_to_mbr_type_die  PROTO((void *));
 379 static void output_compile_unit_die     PROTO((void *));
 380 static void output_string_type_die      PROTO((void *));
 381 static void output_structure_type_die   PROTO((void *));
 382 static void output_local_subroutine_die PROTO((void *));
 383 static void output_subroutine_type_die  PROTO((void *));
 384 static void output_typedef_die          PROTO((void *));
 385 static void output_union_type_die       PROTO((void *));
 386 static void output_unspecified_parameters_die PROTO((void *));
 387 static void output_padded_null_die      PROTO((void *));
 388 static void output_die                  PROTO((void (*) (), void *));
 389 static void end_sibling_chain           PROTO((void));
 390 static void output_formal_types         PROTO((tree));
 391 static void pend_type                   PROTO((tree));
 392 static inline int type_of_for_scope     PROTO((tree, tree));
 393 static void output_pending_types_for_scope PROTO((tree));
 394 static void output_type                 PROTO((tree, tree));
 395 static void output_tagged_type_instantiation PROTO((tree));
 396 static void output_block                PROTO((tree, int));
 397 static void output_decls_for_scope      PROTO((tree, int));
 398 static void output_decl                 PROTO((tree, tree));
 399 static void shuffle_filename_entry      PROTO((filename_entry *));
 400 static void geneate_new_sfname_entry    PROTO((void));
 401 static unsigned lookup_filename         PROTO((char *));
 402 static void generate_srcinfo_entry      PROTO((unsigned, unsigned));
 403 static void generate_macinfo_entry      PROTO((char *, char *));
 404 \f
 405 /* Definitions of defaults for assembler-dependent names of various
 406    pseudo-ops and section names.
 407
 408    Theses may be overridden in your tm.h file (if necessary) for your
 409    particular assembler.  The default values provided here correspond to
 410    what is expected by "standard" AT&T System V.4 assemblers.  */
 411
 412 #ifndef FILE_ASM_OP
 413 #define FILE_ASM_OP             ".file"
 414 #endif
 415 #ifndef VERSION_ASM_OP
 416 #define VERSION_ASM_OP          ".version"
 417 #endif
 418 #ifndef UNALIGNED_SHORT_ASM_OP
 419 #define UNALIGNED_SHORT_ASM_OP  ".2byte"
 420 #endif
 421 #ifndef UNALIGNED_INT_ASM_OP
 422 #define UNALIGNED_INT_ASM_OP    ".4byte"
 423 #endif
 424 #ifndef ASM_BYTE_OP
 425 #define ASM_BYTE_OP             ".byte"
 426 #endif
 427 #ifndef SET_ASM_OP
 428 #define SET_ASM_OP              ".set"
 429 #endif
 430
 431 /* Pseudo-ops for pushing the current section onto the section stack (and
 432    simultaneously changing to a new section) and for poping back to the
 433    section we were in immediately before this one.  Note that most svr4
 434    assemblers only maintain a one level stack... you can push all the
 435    sections you want, but you can only pop out one level.  (The sparc
 436    svr4 assembler is an exception to this general rule.)  That's
 437    OK because we only use at most one level of the section stack herein.  */
 438
 439 #ifndef PUSHSECTION_ASM_OP
 440 #define PUSHSECTION_ASM_OP      ".section"
 441 #endif
 442 #ifndef POPSECTION_ASM_OP
 443 #define POPSECTION_ASM_OP       ".previous"
 444 #endif
 445
 446 /* The default format used by the ASM_OUTPUT_PUSH_SECTION macro (see below)
 447    to print the PUSHSECTION_ASM_OP and the section name.  The default here
 448    works for almost all svr4 assemblers, except for the sparc, where the
 449    section name must be enclosed in double quotes.  (See sparcv4.h.)  */
 450
 451 #ifndef PUSHSECTION_FORMAT
 452 #define PUSHSECTION_FORMAT      "\t%s\t%s\n"
 453 #endif
 454
 455 #ifndef DEBUG_SECTION
 456 #define DEBUG_SECTION           ".debug"
 457 #endif
 458 #ifndef LINE_SECTION
 459 #define LINE_SECTION            ".line"
 460 #endif
 461 #ifndef SFNAMES_SECTION
 462 #define SFNAMES_SECTION         ".debug_sfnames"
 463 #endif
 464 #ifndef SRCINFO_SECTION
 465 #define SRCINFO_SECTION         ".debug_srcinfo"
 466 #endif
 467 #ifndef MACINFO_SECTION
 468 #define MACINFO_SECTION         ".debug_macinfo"
 469 #endif
 470 #ifndef PUBNAMES_SECTION
 471 #define PUBNAMES_SECTION        ".debug_pubnames"
 472 #endif
 473 #ifndef ARANGES_SECTION
 474 #define ARANGES_SECTION         ".debug_aranges"
 475 #endif
 476 #ifndef TEXT_SECTION
 477 #define TEXT_SECTION            ".text"
 478 #endif
 479 #ifndef DATA_SECTION
 480 #define DATA_SECTION            ".data"
 481 #endif
 482 #ifndef DATA1_SECTION
 483 #define DATA1_SECTION           ".data1"
 484 #endif
 485 #ifndef RODATA_SECTION
 486 #define RODATA_SECTION          ".rodata"
 487 #endif
 488 #ifndef RODATA1_SECTION
 489 #define RODATA1_SECTION         ".rodata1"
 490 #endif
 491 #ifndef BSS_SECTION
 492 #define BSS_SECTION             ".bss"
 493 #endif
 494 \f
 495 /* Definitions of defaults for formats and names of various special
 496    (artificial) labels which may be generated within this file (when
 497    the -g options is used and DWARF_DEBUGGING_INFO is in effect.
 498
 499    If necessary, these may be overridden from within your tm.h file,
 500    but typically, you should never need to override these.
 501
 502    These labels have been hacked (temporarily) so that they all begin with
 503    a `.L' sequence so as to appease the stock sparc/svr4 assembler and the
 504    stock m88k/svr4 assembler, both of which need to see .L at the start of
 505    a label in order to prevent that label from going into the linker symbol
 506    table).  When I get time, I'll have to fix this the right way so that we
 507    will use ASM_GENERATE_INTERNAL_LABEL and ASM_OUTPUT_INTERNAL_LABEL herein,
 508    but that will require a rather massive set of changes.  For the moment,
 509    the following definitions out to produce the right results for all svr4
 510    and svr3 assemblers. -- rfg
 511 */
 512
 513 #ifndef TEXT_BEGIN_LABEL
 514 #define TEXT_BEGIN_LABEL        ".L_text_b"
 515 #endif
 516 #ifndef TEXT_END_LABEL
 517 #define TEXT_END_LABEL          ".L_text_e"
 518 #endif
 519
 520 #ifndef DATA_BEGIN_LABEL
 521 #define DATA_BEGIN_LABEL        ".L_data_b"
 522 #endif
 523 #ifndef DATA_END_LABEL
 524 #define DATA_END_LABEL          ".L_data_e"
 525 #endif
 526
 527 #ifndef DATA1_BEGIN_LABEL
 528 #define DATA1_BEGIN_LABEL       ".L_data1_b"
 529 #endif
 530 #ifndef DATA1_END_LABEL
 531 #define DATA1_END_LABEL         ".L_data1_e"
 532 #endif
 533
 534 #ifndef RODATA_BEGIN_LABEL
 535 #define RODATA_BEGIN_LABEL      ".L_rodata_b"
 536 #endif
 537 #ifndef RODATA_END_LABEL
 538 #define RODATA_END_LABEL        ".L_rodata_e"
 539 #endif
 540
 541 #ifndef RODATA1_BEGIN_LABEL
 542 #define RODATA1_BEGIN_LABEL     ".L_rodata1_b"
 543 #endif
 544 #ifndef RODATA1_END_LABEL
 545 #define RODATA1_END_LABEL       ".L_rodata1_e"
 546 #endif
 547
 548 #ifndef BSS_BEGIN_LABEL
 549 #define BSS_BEGIN_LABEL         ".L_bss_b"
 550 #endif
 551 #ifndef BSS_END_LABEL
 552 #define BSS_END_LABEL           ".L_bss_e"
 553 #endif
 554
 555 #ifndef LINE_BEGIN_LABEL
 556 #define LINE_BEGIN_LABEL        ".L_line_b"
 557 #endif
 558 #ifndef LINE_LAST_ENTRY_LABEL
 559 #define LINE_LAST_ENTRY_LABEL   ".L_line_last"
 560 #endif
 561 #ifndef LINE_END_LABEL
 562 #define LINE_END_LABEL          ".L_line_e"
 563 #endif
 564
 565 #ifndef DEBUG_BEGIN_LABEL
 566 #define DEBUG_BEGIN_LABEL       ".L_debug_b"
 567 #endif
 568 #ifndef SFNAMES_BEGIN_LABEL
 569 #define SFNAMES_BEGIN_LABEL     ".L_sfnames_b"
 570 #endif
 571 #ifndef SRCINFO_BEGIN_LABEL
 572 #define SRCINFO_BEGIN_LABEL     ".L_srcinfo_b"
 573 #endif
 574 #ifndef MACINFO_BEGIN_LABEL
 575 #define MACINFO_BEGIN_LABEL     ".L_macinfo_b"
 576 #endif
 577
 578 #ifndef DIE_BEGIN_LABEL_FMT
 579 #define DIE_BEGIN_LABEL_FMT     ".L_D%u"
 580 #endif
 581 #ifndef DIE_END_LABEL_FMT
 582 #define DIE_END_LABEL_FMT       ".L_D%u_e"
 583 #endif
 584 #ifndef PUB_DIE_LABEL_FMT
 585 #define PUB_DIE_LABEL_FMT       ".L_P%u"
 586 #endif
 587 #ifndef INSN_LABEL_FMT
 588 #define INSN_LABEL_FMT          ".L_I%u_%u"
 589 #endif
 590 #ifndef BLOCK_BEGIN_LABEL_FMT
 591 #define BLOCK_BEGIN_LABEL_FMT   ".L_B%u"
 592 #endif
 593 #ifndef BLOCK_END_LABEL_FMT
 594 #define BLOCK_END_LABEL_FMT     ".L_B%u_e"
 595 #endif
 596 #ifndef SS_BEGIN_LABEL_FMT
 597 #define SS_BEGIN_LABEL_FMT      ".L_s%u"
 598 #endif
 599 #ifndef SS_END_LABEL_FMT
 600 #define SS_END_LABEL_FMT        ".L_s%u_e"
 601 #endif
 602 #ifndef EE_BEGIN_LABEL_FMT
 603 #define EE_BEGIN_LABEL_FMT      ".L_e%u"
 604 #endif
 605 #ifndef EE_END_LABEL_FMT
 606 #define EE_END_LABEL_FMT        ".L_e%u_e"
 607 #endif
 608 #ifndef MT_BEGIN_LABEL_FMT
 609 #define MT_BEGIN_LABEL_FMT      ".L_t%u"
 610 #endif
 611 #ifndef MT_END_LABEL_FMT
 612 #define MT_END_LABEL_FMT        ".L_t%u_e"
 613 #endif
 614 #ifndef LOC_BEGIN_LABEL_FMT
 615 #define LOC_BEGIN_LABEL_FMT     ".L_l%u"
 616 #endif
 617 #ifndef LOC_END_LABEL_FMT
 618 #define LOC_END_LABEL_FMT       ".L_l%u_e"
 619 #endif
 620 #ifndef BOUND_BEGIN_LABEL_FMT
 621 #define BOUND_BEGIN_LABEL_FMT   ".L_b%u_%u_%c"
 622 #endif
 623 #ifndef BOUND_END_LABEL_FMT
 624 #define BOUND_END_LABEL_FMT     ".L_b%u_%u_%c_e"
 625 #endif
 626 #ifndef DERIV_BEGIN_LABEL_FMT
 627 #define DERIV_BEGIN_LABEL_FMT   ".L_d%u"
 628 #endif
 629 #ifndef DERIV_END_LABEL_FMT
 630 #define DERIV_END_LABEL_FMT     ".L_d%u_e"
 631 #endif
 632 #ifndef SL_BEGIN_LABEL_FMT
 633 #define SL_BEGIN_LABEL_FMT      ".L_sl%u"
 634 #endif
 635 #ifndef SL_END_LABEL_FMT
 636 #define SL_END_LABEL_FMT        ".L_sl%u_e"
 637 #endif
 638 #ifndef BODY_BEGIN_LABEL_FMT
 639 #define BODY_BEGIN_LABEL_FMT    ".L_b%u"
 640 #endif
 641 #ifndef BODY_END_LABEL_FMT
 642 #define BODY_END_LABEL_FMT      ".L_b%u_e"
 643 #endif
 644 #ifndef FUNC_END_LABEL_FMT
 645 #define FUNC_END_LABEL_FMT      ".L_f%u_e"
 646 #endif
 647 #ifndef TYPE_NAME_FMT
 648 #define TYPE_NAME_FMT           ".L_T%u"
 649 #endif
 650 #ifndef DECL_NAME_FMT
 651 #define DECL_NAME_FMT           ".L_E%u"
 652 #endif
 653 #ifndef LINE_CODE_LABEL_FMT
 654 #define LINE_CODE_LABEL_FMT     ".L_LC%u"
 655 #endif
 656 #ifndef SFNAMES_ENTRY_LABEL_FMT
 657 #define SFNAMES_ENTRY_LABEL_FMT ".L_F%u"
 658 #endif
 659 #ifndef LINE_ENTRY_LABEL_FMT
 660 #define LINE_ENTRY_LABEL_FMT    ".L_LE%u"
 661 #endif
 662 \f
 663 /* Definitions of defaults for various types of primitive assembly language
 664    output operations.
 665
 666    If necessary, these may be overridden from within your tm.h file,
 667    but typically, you shouldn't need to override these.  */
 668
 669 #ifndef ASM_OUTPUT_PUSH_SECTION
 670 #define ASM_OUTPUT_PUSH_SECTION(FILE, SECTION) \
 671   fprintf ((FILE), PUSHSECTION_FORMAT, PUSHSECTION_ASM_OP, SECTION)
 672 #endif
 673
 674 #ifndef ASM_OUTPUT_POP_SECTION
 675 #define ASM_OUTPUT_POP_SECTION(FILE) \
 676   fprintf ((FILE), "\t%s\n", POPSECTION_ASM_OP)
 677 #endif
 678
 679 #ifndef ASM_OUTPUT_SOURCE_FILENAME
 680 #define ASM_OUTPUT_SOURCE_FILENAME(FILE,NAME) \
 681   do {  fprintf (FILE, "\t%s\t", FILE_ASM_OP);                          \
 682         output_quoted_string (FILE, NAME);                              \
 683         fputc ('\n', FILE);                                             \
 684   } while (0)
 685 #endif
 686
 687 #ifndef ASM_OUTPUT_DWARF_DELTA2
 688 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2)                     \
 689  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP);             \
 690         assemble_name (FILE, LABEL1);                                   \
 691         fprintf (FILE, "-");                                            \
 692         assemble_name (FILE, LABEL2);                                   \
 693         fprintf (FILE, "\n");                                           \
 694   } while (0)
 695 #endif
 696
 697 #ifndef ASM_OUTPUT_DWARF_DELTA4
 698 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2)                     \
 699  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP);               \
 700         assemble_name (FILE, LABEL1);                                   \
 701         fprintf (FILE, "-");                                            \
 702         assemble_name (FILE, LABEL2);                                   \
 703         fprintf (FILE, "\n");                                           \
 704   } while (0)
 705 #endif
 706
 707 #ifndef ASM_OUTPUT_DWARF_TAG
 708 #define ASM_OUTPUT_DWARF_TAG(FILE,TAG)                                  \
 709   do {                                                                  \
 710     fprintf ((FILE), "\t%s\t0x%x",                                      \
 711                      UNALIGNED_SHORT_ASM_OP, (unsigned) TAG);           \
 712     if (flag_debug_asm)                                                 \
 713       fprintf ((FILE), "\t%s %s",                                       \
 714                        ASM_COMMENT_START, dwarf_tag_name (TAG));        \
 715     fputc ('\n', (FILE));                                               \
 716   } while (0)
 717 #endif
 718
 719 #ifndef ASM_OUTPUT_DWARF_ATTRIBUTE
 720 #define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTR)                           \
 721   do {                                                                  \
 722     fprintf ((FILE), "\t%s\t0x%x",                                      \
 723                      UNALIGNED_SHORT_ASM_OP, (unsigned) ATTR);          \
 724     if (flag_debug_asm)                                                 \
 725       fprintf ((FILE), "\t%s %s",                                       \
 726                        ASM_COMMENT_START, dwarf_attr_name (ATTR));      \
 727     fputc ('\n', (FILE));                                               \
 728   } while (0)
 729 #endif
 730
 731 #ifndef ASM_OUTPUT_DWARF_STACK_OP
 732 #define ASM_OUTPUT_DWARF_STACK_OP(FILE,OP)                              \
 733   do {                                                                  \
 734     fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) OP);         \
 735     if (flag_debug_asm)                                                 \
 736       fprintf ((FILE), "\t%s %s",                                       \
 737                        ASM_COMMENT_START, dwarf_stack_op_name (OP));    \
 738     fputc ('\n', (FILE));                                               \
 739   } while (0)
 740 #endif
 741
 742 #ifndef ASM_OUTPUT_DWARF_FUND_TYPE
 743 #define ASM_OUTPUT_DWARF_FUND_TYPE(FILE,FT)                             \
 744   do {                                                                  \
 745     fprintf ((FILE), "\t%s\t0x%x",                                      \
 746                      UNALIGNED_SHORT_ASM_OP, (unsigned) FT);            \
 747     if (flag_debug_asm)                                                 \
 748       fprintf ((FILE), "\t%s %s",                                       \
 749                        ASM_COMMENT_START, dwarf_fund_type_name (FT));   \
 750     fputc ('\n', (FILE));                                               \
 751   } while (0)
 752 #endif
 753
 754 #ifndef ASM_OUTPUT_DWARF_FMT_BYTE
 755 #define ASM_OUTPUT_DWARF_FMT_BYTE(FILE,FMT)                             \
 756   do {                                                                  \
 757     fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) FMT);        \
 758     if (flag_debug_asm)                                                 \
 759       fprintf ((FILE), "\t%s %s",                                       \
 760                        ASM_COMMENT_START, dwarf_fmt_byte_name (FMT));   \
 761     fputc ('\n', (FILE));                                               \
 762   } while (0)
 763 #endif
 764
 765 #ifndef ASM_OUTPUT_DWARF_TYPE_MODIFIER
 766 #define ASM_OUTPUT_DWARF_TYPE_MODIFIER(FILE,MOD)                        \
 767   do {                                                                  \
 768     fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) MOD);        \
 769     if (flag_debug_asm)                                                 \
 770       fprintf ((FILE), "\t%s %s",                                       \
 771                        ASM_COMMENT_START, dwarf_typemod_name (MOD));    \
 772     fputc ('\n', (FILE));                                               \
 773   } while (0)
 774 #endif
 775 \f
 776 #ifndef ASM_OUTPUT_DWARF_ADDR
 777 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL)                               \
 778  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP);               \
 779         assemble_name (FILE, LABEL);                                    \
 780         fprintf (FILE, "\n");                                           \
 781   } while (0)
 782 #endif
 783
 784 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
 785 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX)                           \
 786   do {                                                                  \
 787     fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP);                   \
 788     output_addr_const ((FILE), (RTX));                                  \
 789     fputc ('\n', (FILE));                                               \
 790   } while (0)
 791 #endif
 792
 793 #ifndef ASM_OUTPUT_DWARF_REF
 794 #define ASM_OUTPUT_DWARF_REF(FILE,LABEL)                                \
 795  do {   fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP);               \
 796         assemble_name (FILE, LABEL);                                    \
 797         fprintf (FILE, "\n");                                           \
 798   } while (0)
 799 #endif
 800
 801 #ifndef ASM_OUTPUT_DWARF_DATA1
 802 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
 803   fprintf ((FILE), "\t%s\t0x%x\n", ASM_BYTE_OP, VALUE)
 804 #endif
 805
 806 #ifndef ASM_OUTPUT_DWARF_DATA2
 807 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
 808   fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE)
 809 #endif
 810
 811 #ifndef ASM_OUTPUT_DWARF_DATA4
 812 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
 813   fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, (unsigned) VALUE)
 814 #endif
 815
 816 #ifndef ASM_OUTPUT_DWARF_DATA8
 817 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE)               \
 818   do {                                                                  \
 819     if (WORDS_BIG_ENDIAN)                                               \
 820       {                                                                 \
 821         fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
 822         fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
 823       }                                                                 \
 824     else                                                                \
 825       {                                                                 \
 826         fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
 827         fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
 828       }                                                                 \
 829   } while (0)
 830 #endif
 831
 832 #ifndef ASM_OUTPUT_DWARF_STRING
 833 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
 834   ASM_OUTPUT_ASCII ((FILE), P, strlen (P)+1)
 835 #endif
 836 \f
 837 /************************ general utility functions **************************/
 838
 839 inline int
 840 is_pseudo_reg (rtl)
 841      register rtx rtl;
 842 {
 843   return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
 844           || ((GET_CODE (rtl) == SUBREG)
 845               && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
 846 }
 847
 848 inline tree
 849 type_main_variant (type)
 850      register tree type;
 851 {
 852   type = TYPE_MAIN_VARIANT (type);
 853
 854   /* There really should be only one main variant among any group of variants
 855      of a given type (and all of the MAIN_VARIANT values for all members of
 856      the group should point to that one type) but sometimes the C front-end
 857      messes this up for array types, so we work around that bug here.  */
 858
 859   if (TREE_CODE (type) == ARRAY_TYPE)
 860     {
 861       while (type != TYPE_MAIN_VARIANT (type))
 862         type = TYPE_MAIN_VARIANT (type);
 863     }
 864
 865   return type;
 866 }
 867
 868 /* Return non-zero if the given type node represents a tagged type.  */
 869
 870 inline int
 871 is_tagged_type (type)
 872      register tree type;
 873 {
 874   register enum tree_code code = TREE_CODE (type);
 875
 876   return (code == RECORD_TYPE || code == UNION_TYPE
 877           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
 878 }
 879
 880 static char *
 881 dwarf_tag_name (tag)
 882      register unsigned tag;
 883 {
 884   switch (tag)
 885     {
 886     case TAG_padding:                   return "TAG_padding";
 887     case TAG_array_type:                return "TAG_array_type";
 888     case TAG_class_type:                return "TAG_class_type";
 889     case TAG_entry_point:               return "TAG_entry_point";
 890     case TAG_enumeration_type:          return "TAG_enumeration_type";
 891     case TAG_formal_parameter:          return "TAG_formal_parameter";
 892     case TAG_global_subroutine:         return "TAG_global_subroutine";
 893     case TAG_global_variable:           return "TAG_global_variable";
 894     case TAG_label:                     return "TAG_label";
 895     case TAG_lexical_block:             return "TAG_lexical_block";
 896     case TAG_local_variable:            return "TAG_local_variable";
 897     case TAG_member:                    return "TAG_member";
 898     case TAG_pointer_type:              return "TAG_pointer_type";
 899     case TAG_reference_type:            return "TAG_reference_type";
 900     case TAG_compile_unit:              return "TAG_compile_unit";
 901     case TAG_string_type:               return "TAG_string_type";
 902     case TAG_structure_type:            return "TAG_structure_type";
 903     case TAG_subroutine:                return "TAG_subroutine";
 904     case TAG_subroutine_type:           return "TAG_subroutine_type";
 905     case TAG_typedef:                   return "TAG_typedef";
 906     case TAG_union_type:                return "TAG_union_type";
 907     case TAG_unspecified_parameters:    return "TAG_unspecified_parameters";
 908     case TAG_variant:                   return "TAG_variant";
 909     case TAG_common_block:              return "TAG_common_block";
 910     case TAG_common_inclusion:          return "TAG_common_inclusion";
 911     case TAG_inheritance:               return "TAG_inheritance";
 912     case TAG_inlined_subroutine:        return "TAG_inlined_subroutine";
 913     case TAG_module:                    return "TAG_module";
 914     case TAG_ptr_to_member_type:        return "TAG_ptr_to_member_type";
 915     case TAG_set_type:                  return "TAG_set_type";
 916     case TAG_subrange_type:             return "TAG_subrange_type";
 917     case TAG_with_stmt:                 return "TAG_with_stmt";
 918
 919     /* GNU extensions.  */
 920
 921     case TAG_format_label:              return "TAG_format_label";
 922     case TAG_namelist:                  return "TAG_namelist";
 923     case TAG_function_template:         return "TAG_function_template";
 924     case TAG_class_template:            return "TAG_class_template";
 925
 926     default:                            return "TAG_<unknown>";
 927     }
 928 }
 929
 930 static char *
 931 dwarf_attr_name (attr)
 932      register unsigned attr;
 933 {
 934   switch (attr)
 935     {
 936     case AT_sibling:                    return "AT_sibling";
 937     case AT_location:                   return "AT_location";
 938     case AT_name:                       return "AT_name";
 939     case AT_fund_type:                  return "AT_fund_type";
 940     case AT_mod_fund_type:              return "AT_mod_fund_type";
 941     case AT_user_def_type:              return "AT_user_def_type";
 942     case AT_mod_u_d_type:               return "AT_mod_u_d_type";
 943     case AT_ordering:                   return "AT_ordering";
 944     case AT_subscr_data:                return "AT_subscr_data";
 945     case AT_byte_size:                  return "AT_byte_size";
 946     case AT_bit_offset:                 return "AT_bit_offset";
 947     case AT_bit_size:                   return "AT_bit_size";
 948     case AT_element_list:               return "AT_element_list";
 949     case AT_stmt_list:                  return "AT_stmt_list";
 950     case AT_low_pc:                     return "AT_low_pc";
 951     case AT_high_pc:                    return "AT_high_pc";
 952     case AT_language:                   return "AT_language";
 953     case AT_member:                     return "AT_member";
 954     case AT_discr:                      return "AT_discr";
 955     case AT_discr_value:                return "AT_discr_value";
 956     case AT_string_length:              return "AT_string_length";
 957     case AT_common_reference:           return "AT_common_reference";
 958     case AT_comp_dir:                   return "AT_comp_dir";
 959     case AT_const_value_string:         return "AT_const_value_string";
 960     case AT_const_value_data2:          return "AT_const_value_data2";
 961     case AT_const_value_data4:          return "AT_const_value_data4";
 962     case AT_const_value_data8:          return "AT_const_value_data8";
 963     case AT_const_value_block2:         return "AT_const_value_block2";
 964     case AT_const_value_block4:         return "AT_const_value_block4";
 965     case AT_containing_type:            return "AT_containing_type";
 966     case AT_default_value_addr:         return "AT_default_value_addr";
 967     case AT_default_value_data2:        return "AT_default_value_data2";
 968     case AT_default_value_data4:        return "AT_default_value_data4";
 969     case AT_default_value_data8:        return "AT_default_value_data8";
 970     case AT_default_value_string:       return "AT_default_value_string";
 971     case AT_friends:                    return "AT_friends";
 972     case AT_inline:                     return "AT_inline";
 973     case AT_is_optional:                return "AT_is_optional";
 974     case AT_lower_bound_ref:            return "AT_lower_bound_ref";
 975     case AT_lower_bound_data2:          return "AT_lower_bound_data2";
 976     case AT_lower_bound_data4:          return "AT_lower_bound_data4";
 977     case AT_lower_bound_data8:          return "AT_lower_bound_data8";
 978     case AT_private:                    return "AT_private";
 979     case AT_producer:                   return "AT_producer";
 980     case AT_program:                    return "AT_program";
 981     case AT_protected:                  return "AT_protected";
 982     case AT_prototyped:                 return "AT_prototyped";
 983     case AT_public:                     return "AT_public";
 984     case AT_pure_virtual:               return "AT_pure_virtual";
 985     case AT_return_addr:                return "AT_return_addr";
 986     case AT_abstract_origin:            return "AT_abstract_origin";
 987     case AT_start_scope:                return "AT_start_scope";
 988     case AT_stride_size:                return "AT_stride_size";
 989     case AT_upper_bound_ref:            return "AT_upper_bound_ref";
 990     case AT_upper_bound_data2:          return "AT_upper_bound_data2";
 991     case AT_upper_bound_data4:          return "AT_upper_bound_data4";
 992     case AT_upper_bound_data8:          return "AT_upper_bound_data8";
 993     case AT_virtual:                    return "AT_virtual";
 994
 995     /* GNU extensions */
 996
 997     case AT_sf_names:                   return "AT_sf_names";
 998     case AT_src_info:                   return "AT_src_info";
 999     case AT_mac_info:                   return "AT_mac_info";
1000     case AT_src_coords:                 return "AT_src_coords";
1001     case AT_body_begin:                 return "AT_body_begin";
1002     case AT_body_end:                   return "AT_body_end";
1003
1004     default:                            return "AT_<unknown>";
1005     }
1006 }
1007
1008 static char *
1009 dwarf_stack_op_name (op)
1010      register unsigned op;
1011 {
1012   switch (op)
1013     {
1014     case OP_REG:                return "OP_REG";
1015     case OP_BASEREG:            return "OP_BASEREG";
1016     case OP_ADDR:               return "OP_ADDR";
1017     case OP_CONST:              return "OP_CONST";
1018     case OP_DEREF2:             return "OP_DEREF2";
1019     case OP_DEREF4:             return "OP_DEREF4";
1020     case OP_ADD:                return "OP_ADD";
1021     default:                    return "OP_<unknown>";
1022     }
1023 }
1024
1025 static char *
1026 dwarf_typemod_name (mod)
1027      register unsigned mod;
1028 {
1029   switch (mod)
1030     {
1031     case MOD_pointer_to:        return "MOD_pointer_to";
1032     case MOD_reference_to:      return "MOD_reference_to";
1033     case MOD_const:             return "MOD_const";
1034     case MOD_volatile:          return "MOD_volatile";
1035     default:                    return "MOD_<unknown>";
1036     }
1037 }
1038
1039 static char *
1040 dwarf_fmt_byte_name (fmt)
1041      register unsigned fmt;
1042 {
1043   switch (fmt)
1044     {
1045     case FMT_FT_C_C:    return "FMT_FT_C_C";
1046     case FMT_FT_C_X:    return "FMT_FT_C_X";
1047     case FMT_FT_X_C:    return "FMT_FT_X_C";
1048     case FMT_FT_X_X:    return "FMT_FT_X_X";
1049     case FMT_UT_C_C:    return "FMT_UT_C_C";
1050     case FMT_UT_C_X:    return "FMT_UT_C_X";
1051     case FMT_UT_X_C:    return "FMT_UT_X_C";
1052     case FMT_UT_X_X:    return "FMT_UT_X_X";
1053     case FMT_ET:        return "FMT_ET";
1054     default:            return "FMT_<unknown>";
1055     }
1056 }
1057
1058 static char *
1059 dwarf_fund_type_name (ft)
1060      register unsigned ft;
1061 {
1062   switch (ft)
1063     {
1064     case FT_char:               return "FT_char";
1065     case FT_signed_char:        return "FT_signed_char";
1066     case FT_unsigned_char:      return "FT_unsigned_char";
1067     case FT_short:              return "FT_short";
1068     case FT_signed_short:       return "FT_signed_short";
1069     case FT_unsigned_short:     return "FT_unsigned_short";
1070     case FT_integer:            return "FT_integer";
1071     case FT_signed_integer:     return "FT_signed_integer";
1072     case FT_unsigned_integer:   return "FT_unsigned_integer";
1073     case FT_long:               return "FT_long";
1074     case FT_signed_long:        return "FT_signed_long";
1075     case FT_unsigned_long:      return "FT_unsigned_long";
1076     case FT_pointer:            return "FT_pointer";
1077     case FT_float:              return "FT_float";
1078     case FT_dbl_prec_float:     return "FT_dbl_prec_float";
1079     case FT_ext_prec_float:     return "FT_ext_prec_float";
1080     case FT_complex:            return "FT_complex";
1081     case FT_dbl_prec_complex:   return "FT_dbl_prec_complex";
1082     case FT_void:               return "FT_void";
1083     case FT_boolean:            return "FT_boolean";
1084     case FT_ext_prec_complex:   return "FT_ext_prec_complex";
1085     case FT_label:              return "FT_label";
1086
1087     /* GNU extensions.  */
1088
1089     case FT_long_long:          return "FT_long_long";
1090     case FT_signed_long_long:   return "FT_signed_long_long";
1091     case FT_unsigned_long_long: return "FT_unsigned_long_long";
1092
1093     case FT_int8:               return "FT_int8";
1094     case FT_signed_int8:        return "FT_signed_int8";
1095     case FT_unsigned_int8:      return "FT_unsigned_int8";
1096     case FT_int16:              return "FT_int16";
1097     case FT_signed_int16:       return "FT_signed_int16";
1098     case FT_unsigned_int16:     return "FT_unsigned_int16";
1099     case FT_int32:              return "FT_int32";
1100     case FT_signed_int32:       return "FT_signed_int32";
1101     case FT_unsigned_int32:     return "FT_unsigned_int32";
1102     case FT_int64:              return "FT_int64";
1103     case FT_signed_int64:       return "FT_signed_int64";
1104     case FT_unsigned_int64:     return "FT_signed_int64";
1105
1106     case FT_real32:             return "FT_real32";
1107     case FT_real64:             return "FT_real64";
1108     case FT_real96:             return "FT_real96";
1109     case FT_real128:            return "FT_real128";
1110
1111     default:                    return "FT_<unknown>";
1112     }
1113 }
1114
1115 /* Determine the "ultimate origin" of a decl.  The decl may be an
1116    inlined instance of an inlined instance of a decl which is local
1117    to an inline function, so we have to trace all of the way back
1118    through the origin chain to find out what sort of node actually
1119    served as the original seed for the given block.  */
1120
1121 static tree
1122 decl_ultimate_origin (decl)
1123      register tree decl;
1124 {
1125   register tree immediate_origin = DECL_ABSTRACT_ORIGIN (decl);
1126
1127   if (immediate_origin == NULL)
1128     return NULL;
1129   else
1130     {
1131       register tree ret_val;
1132       register tree lookahead = immediate_origin;
1133
1134       do
1135         {
1136           ret_val = lookahead;
1137           lookahead = DECL_ABSTRACT_ORIGIN (ret_val);
1138         }
1139       while (lookahead != NULL && lookahead != ret_val);
1140       return ret_val;
1141     }
1142 }
1143
1144 /* Determine the "ultimate origin" of a block.  The block may be an
1145    inlined instance of an inlined instance of a block which is local
1146    to an inline function, so we have to trace all of the way back
1147    through the origin chain to find out what sort of node actually
1148    served as the original seed for the given block.  */
1149
1150 static tree
1151 block_ultimate_origin (block)
1152      register tree block;
1153 {
1154   register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
1155
1156   if (immediate_origin == NULL)
1157     return NULL;
1158   else
1159     {
1160       register tree ret_val;
1161       register tree lookahead = immediate_origin;
1162
1163       do
1164         {
1165           ret_val = lookahead;
1166           lookahead = (TREE_CODE (ret_val) == BLOCK)
1167                        ? BLOCK_ABSTRACT_ORIGIN (ret_val)
1168                        : NULL;
1169         }
1170       while (lookahead != NULL && lookahead != ret_val);
1171       return ret_val;
1172     }
1173 }
1174
1175 static void
1176 output_unsigned_leb128 (value)
1177      register unsigned long value;
1178 {
1179   register unsigned long orig_value = value;
1180
1181   do
1182     {
1183       register unsigned byte = (value & 0x7f);
1184
1185       value >>= 7;
1186       if (value != 0)   /* more bytes to follow */
1187         byte |= 0x80;
1188       fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) byte);
1189       if (flag_debug_asm && value == 0)
1190         fprintf (asm_out_file, "\t%s ULEB128 number - value = %u",
1191                  ASM_COMMENT_START, orig_value);
1192       fputc ('\n', asm_out_file);
1193     }
1194   while (value != 0);
1195 }
1196
1197 static void
1198 output_signed_leb128 (value)
1199      register long value;
1200 {
1201   register long orig_value = value;
1202   register int negative = (value < 0);
1203   register int more;
1204
1205   do
1206     {
1207       register unsigned byte = (value & 0x7f);
1208
1209       value >>= 7;
1210       if (negative)
1211         value |= 0xfe000000;  /* manually sign extend */
1212       if (((value == 0) && ((byte & 0x40) == 0))
1213           || ((value == -1) && ((byte & 0x40) == 1)))
1214         more = 0;
1215       else
1216         {
1217           byte |= 0x80;
1218           more = 1;
1219         }
1220       fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) byte);
1221       if (flag_debug_asm && more == 0)
1222         fprintf (asm_out_file, "\t%s SLEB128 number - value = %d",
1223                  ASM_COMMENT_START, orig_value);
1224       fputc ('\n', asm_out_file);
1225     }
1226   while (more);
1227 }
1228 \f
1229 /**************** utility functions for attribute functions ******************/
1230
1231 /* Given a pointer to a BLOCK node return non-zero if (and only if) the
1232    node in question represents the outermost pair of curly braces (i.e.
1233    the "body block") of a function or method.
1234
1235    For any BLOCK node representing a "body block" of a function or method,
1236    the BLOCK_SUPERCONTEXT of the node will point to another BLOCK node
1237    which represents the outermost (function) scope for the function or
1238    method (i.e. the one which includes the formal parameters).  The
1239    BLOCK_SUPERCONTEXT of *that* node in turn will point to the relevant
1240    FUNCTION_DECL node.
1241 */
1242
1243 static inline int
1244 is_body_block (stmt)
1245      register tree stmt;
1246 {
1247   if (TREE_CODE (stmt) == BLOCK)
1248     {
1249       register tree parent = BLOCK_SUPERCONTEXT (stmt);
1250
1251       if (TREE_CODE (parent) == BLOCK)
1252         {
1253           register tree grandparent = BLOCK_SUPERCONTEXT (parent);
1254
1255           if (TREE_CODE (grandparent) == FUNCTION_DECL)
1256             return 1;
1257         }
1258     }
1259   return 0;
1260 }
1261
1262 /* Given a pointer to a tree node for some type, return a Dwarf fundamental
1263    type code for the given type.
1264
1265    This routine must only be called for GCC type nodes that correspond to
1266    Dwarf fundamental types.
1267
1268    The current Dwarf draft specification calls for Dwarf fundamental types
1269    to accurately reflect the fact that a given type was either a "plain"
1270    integral type or an explicitly "signed" integral type.  Unfortunately,
1271    we can't always do this, because GCC may already have thrown away the
1272    information about the precise way in which the type was originally
1273    specified, as in:
1274
1275         typedef signed int my_type;
1276
1277         struct s { my_type f; };
1278
1279    Since we may be stuck here without enought information to do exactly
1280    what is called for in the Dwarf draft specification, we do the best
1281    that we can under the circumstances and always use the "plain" integral
1282    fundamental type codes for int, short, and long types.  That's probably
1283    good enough.  The additional accuracy called for in the current DWARF
1284    draft specification is probably never even useful in practice.  */
1285
1286 static int
1287 fundamental_type_code (type)
1288      register tree type;
1289 {
1290   if (TREE_CODE (type) == ERROR_MARK)
1291     return 0;
1292
1293   switch (TREE_CODE (type))
1294     {
1295       case ERROR_MARK:
1296         return FT_void;
1297
1298       case VOID_TYPE:
1299         return FT_void;
1300
1301       case INTEGER_TYPE:
1302         /* Carefully distinguish all the standard types of C,
1303            without messing up if the language is not C.
1304            Note that we check only for the names that contain spaces;
1305            other names might occur by coincidence in other languages.  */
1306         if (TYPE_NAME (type) != 0
1307             && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1308             && DECL_NAME (TYPE_NAME (type)) != 0
1309             && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
1310           {
1311             char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
1312
1313             if (!strcmp (name, "unsigned char"))
1314               return FT_unsigned_char;
1315             if (!strcmp (name, "signed char"))
1316               return FT_signed_char;
1317             if (!strcmp (name, "unsigned int"))
1318               return FT_unsigned_integer;
1319             if (!strcmp (name, "short int"))
1320               return FT_short;
1321             if (!strcmp (name, "short unsigned int"))
1322               return FT_unsigned_short;
1323             if (!strcmp (name, "long int"))
1324               return FT_long;
1325             if (!strcmp (name, "long unsigned int"))
1326               return FT_unsigned_long;
1327             if (!strcmp (name, "long long int"))
1328               return FT_long_long;              /* Not grok'ed by svr4 SDB */
1329             if (!strcmp (name, "long long unsigned int"))
1330               return FT_unsigned_long_long;     /* Not grok'ed by svr4 SDB */
1331           }
1332
1333         /* Most integer types will be sorted out above, however, for the
1334            sake of special `array index' integer types, the following code
1335            is also provided.  */
1336
1337         if (TYPE_PRECISION (type) == INT_TYPE_SIZE)
1338           return (TREE_UNSIGNED (type) ? FT_unsigned_integer : FT_integer);
1339
1340         if (TYPE_PRECISION (type) == LONG_TYPE_SIZE)
1341           return (TREE_UNSIGNED (type) ? FT_unsigned_long : FT_long);
1342
1343         if (TYPE_PRECISION (type) == LONG_LONG_TYPE_SIZE)
1344           return (TREE_UNSIGNED (type) ? FT_unsigned_long_long : FT_long_long);
1345
1346         if (TYPE_PRECISION (type) == SHORT_TYPE_SIZE)
1347           return (TREE_UNSIGNED (type) ? FT_unsigned_short : FT_short);
1348
1349         if (TYPE_PRECISION (type) == CHAR_TYPE_SIZE)
1350           return (TREE_UNSIGNED (type) ? FT_unsigned_char : FT_char);
1351
1352         abort ();
1353
1354       case REAL_TYPE:
1355         /* Carefully distinguish all the standard types of C,
1356            without messing up if the language is not C.  */
1357         if (TYPE_NAME (type) != 0
1358             && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1359             && DECL_NAME (TYPE_NAME (type)) != 0
1360             && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
1361           {
1362             char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
1363
1364             /* Note that here we can run afowl of a serious bug in "classic"
1365                svr4 SDB debuggers.  They don't seem to understand the
1366                FT_ext_prec_float type (even though they should).  */
1367
1368             if (!strcmp (name, "long double"))
1369               return FT_ext_prec_float;
1370           }
1371
1372         if (TYPE_PRECISION (type) == DOUBLE_TYPE_SIZE)
1373           return FT_dbl_prec_float;
1374         if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
1375           return FT_float;
1376
1377         /* Note that here we can run afowl of a serious bug in "classic"
1378            svr4 SDB debuggers.  They don't seem to understand the
1379            FT_ext_prec_float type (even though they should).  */
1380
1381         if (TYPE_PRECISION (type) == LONG_DOUBLE_TYPE_SIZE)
1382           return FT_ext_prec_float;
1383         abort ();
1384
1385       case COMPLEX_TYPE:
1386         return FT_complex;      /* GNU FORTRAN COMPLEX type.  */
1387
1388       case CHAR_TYPE:
1389         return FT_char;         /* GNU Pascal CHAR type.  Not used in C.  */
1390
1391       case BOOLEAN_TYPE:
1392         return FT_boolean;      /* GNU FORTRAN BOOLEAN type.  */
1393
1394       default:
1395         abort ();       /* No other TREE_CODEs are Dwarf fundamental types.  */
1396     }
1397   return 0;
1398 }
1399 \f
1400 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
1401    the Dwarf "root" type for the given input type.  The Dwarf "root" type
1402    of a given type is generally the same as the given type, except that if
1403    the  given type is a pointer or reference type, then the root type of
1404    the given type is the root type of the "basis" type for the pointer or
1405    reference type.  (This definition of the "root" type is recursive.)
1406    Also, the root type of a `const' qualified type or a `volatile'
1407    qualified type is the root type of the given type without the
1408    qualifiers.  */
1409
1410 static tree
1411 root_type (type)
1412      register tree type;
1413 {
1414   if (TREE_CODE (type) == ERROR_MARK)
1415     return error_mark_node;
1416
1417   switch (TREE_CODE (type))
1418     {
1419       case ERROR_MARK:
1420         return error_mark_node;
1421
1422       case POINTER_TYPE:
1423       case REFERENCE_TYPE:
1424         return type_main_variant (root_type (TREE_TYPE (type)));
1425
1426       default:
1427         return type_main_variant (type);
1428     }
1429 }
1430
1431 /* Given a pointer to an arbitrary ..._TYPE tree node, write out a sequence
1432    of zero or more Dwarf "type-modifier" bytes applicable to the type.  */
1433
1434 static void
1435 write_modifier_bytes (type, decl_const, decl_volatile)
1436      register tree type;
1437      register int decl_const;
1438      register int decl_volatile;
1439 {
1440   if (TREE_CODE (type) == ERROR_MARK)
1441     return;
1442
1443   if (TYPE_READONLY (type) || decl_const)
1444     ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_const);
1445   if (TYPE_VOLATILE (type) || decl_volatile)
1446     ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_volatile);
1447   switch (TREE_CODE (type))
1448     {
1449       case POINTER_TYPE:
1450         ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_pointer_to);
1451         write_modifier_bytes (TREE_TYPE (type), 0, 0);
1452         return;
1453
1454       case REFERENCE_TYPE:
1455         ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_reference_to);
1456         write_modifier_bytes (TREE_TYPE (type), 0, 0);
1457         return;
1458
1459       case ERROR_MARK:
1460       default:
1461         return;
1462     }
1463 }
1464 \f
1465 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
1466    given input type is a Dwarf "fundamental" type.  Otherwise return zero.  */
1467
1468 static inline int
1469 type_is_fundamental (type)
1470      register tree type;
1471 {
1472   switch (TREE_CODE (type))
1473     {
1474       case ERROR_MARK:
1475       case VOID_TYPE:
1476       case INTEGER_TYPE:
1477       case REAL_TYPE:
1478       case COMPLEX_TYPE:
1479       case BOOLEAN_TYPE:
1480       case CHAR_TYPE:
1481         return 1;
1482
1483       case SET_TYPE:
1484       case ARRAY_TYPE:
1485       case RECORD_TYPE:
1486       case UNION_TYPE:
1487       case QUAL_UNION_TYPE:
1488       case ENUMERAL_TYPE:
1489       case FUNCTION_TYPE:
1490       case METHOD_TYPE:
1491       case POINTER_TYPE:
1492       case REFERENCE_TYPE:
1493       case FILE_TYPE:
1494       case OFFSET_TYPE:
1495       case LANG_TYPE:
1496         return 0;
1497
1498       default:
1499         abort ();
1500     }
1501   return 0;
1502 }
1503
1504 /* Given a pointer to some ..._DECL tree node, generate an assembly language
1505    equate directive which will associate a symbolic name with the current DIE.
1506
1507    The name used is an artificial label generated from the DECL_UID number
1508    associated with the given decl node.  The name it gets equated to is the
1509    symbolic label that we (previously) output at the start of the DIE that
1510    we are currently generating.
1511
1512    Calling this function while generating some "decl related" form of DIE
1513    makes it possible to later refer to the DIE which represents the given
1514    decl simply by re-generating the symbolic name from the ..._DECL node's
1515    UID number.  */
1516
1517 static void
1518 equate_decl_number_to_die_number (decl)
1519      register tree decl;
1520 {
1521   /* In the case where we are generating a DIE for some ..._DECL node
1522      which represents either some inline function declaration or some
1523      entity declared within an inline function declaration/definition,
1524      setup a symbolic name for the current DIE so that we have a name
1525      for this DIE that we can easily refer to later on within
1526      AT_abstract_origin attributes.  */
1527
1528   char decl_label[MAX_ARTIFICIAL_LABEL_BYTES];
1529   char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
1530
1531   sprintf (decl_label, DECL_NAME_FMT, DECL_UID (decl));
1532   sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum);
1533   ASM_OUTPUT_DEF (asm_out_file, decl_label, die_label);
1534 }
1535
1536 /* Given a pointer to some ..._TYPE tree node, generate an assembly language
1537    equate directive which will associate a symbolic name with the current DIE.
1538
1539    The name used is an artificial label generated from the TYPE_UID number
1540    associated with the given type node.  The name it gets equated to is the
1541    symbolic label that we (previously) output at the start of the DIE that
1542    we are currently generating.
1543
1544    Calling this function while generating some "type related" form of DIE
1545    makes it easy to later refer to the DIE which represents the given type
1546    simply by re-generating the alternative name from the ..._TYPE node's
1547    UID number.  */
1548
1549 static inline void
1550 equate_type_number_to_die_number (type)
1551      register tree type;
1552 {
1553   char type_label[MAX_ARTIFICIAL_LABEL_BYTES];
1554   char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
1555
1556   /* We are generating a DIE to represent the main variant of this type
1557      (i.e the type without any const or volatile qualifiers) so in order
1558      to get the equate to come out right, we need to get the main variant
1559      itself here.  */
1560
1561   type = type_main_variant (type);
1562
1563   sprintf (type_label, TYPE_NAME_FMT, TYPE_UID (type));
1564   sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum);
1565   ASM_OUTPUT_DEF (asm_out_file, type_label, die_label);
1566 }
1567
1568 static void
1569 output_reg_number (rtl)
1570      register rtx rtl;
1571 {
1572   register unsigned regno = REGNO (rtl);
1573
1574   if (regno >= FIRST_PSEUDO_REGISTER)
1575     {
1576       warning_with_decl (dwarf_last_decl, "internal regno botch: regno = %d\n",
1577                          regno);
1578       regno = 0;
1579     }
1580   fprintf (asm_out_file, "\t%s\t0x%x",
1581            UNALIGNED_INT_ASM_OP, DBX_REGISTER_NUMBER (regno));
1582   if (flag_debug_asm)
1583     {
1584       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
1585       PRINT_REG (rtl, 0, asm_out_file);
1586     }
1587   fputc ('\n', asm_out_file);
1588 }
1589
1590 /* The following routine is a nice and simple transducer.  It converts the
1591    RTL for a variable or parameter (resident in memory) into an equivalent
1592    Dwarf representation of a mechanism for getting the address of that same
1593    variable onto the top of a hypothetical "address evaluation" stack.
1594
1595    When creating memory location descriptors, we are effectively trans-
1596    forming the RTL for a memory-resident object into its Dwarf postfix
1597    expression equivalent.  This routine just recursively descends an
1598    RTL tree, turning it into Dwarf postfix code as it goes.  */
1599
1600 static void
1601 output_mem_loc_descriptor (rtl)
1602       register rtx rtl;
1603 {
1604   /* Note that for a dynamically sized array, the location we will
1605      generate a description of here will be the lowest numbered location
1606      which is actually within the array.  That's *not* necessarily the
1607      same as the zeroth element of the array.  */
1608
1609   switch (GET_CODE (rtl))
1610     {
1611       case SUBREG:
1612
1613         /* The case of a subreg may arise when we have a local (register)
1614            variable or a formal (register) parameter which doesn't quite
1615            fill up an entire register.  For now, just assume that it is
1616            legitimate to make the Dwarf info refer to the whole register
1617            which contains the given subreg.  */
1618
1619         rtl = XEXP (rtl, 0);
1620         /* Drop thru.  */
1621
1622       case REG:
1623
1624         /* Whenever a register number forms a part of the description of
1625            the method for calculating the (dynamic) address of a memory
1626            resident object, DWARF rules require the register number to
1627            be referred to as a "base register".  This distinction is not
1628            based in any way upon what category of register the hardware
1629            believes the given register belongs to.  This is strictly
1630            DWARF terminology we're dealing with here.
1631
1632            Note that in cases where the location of a memory-resident data
1633            object could be expressed as:
1634
1635                     OP_ADD (OP_BASEREG (basereg), OP_CONST (0))
1636
1637            the actual DWARF location descriptor that we generate may just
1638            be OP_BASEREG (basereg).  This may look deceptively like the
1639            object in question was allocated to a register (rather than
1640            in memory) so DWARF consumers need to be aware of the subtle
1641            distinction between OP_REG and OP_BASEREG.  */
1642
1643         ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_BASEREG);
1644         output_reg_number (rtl);
1645         break;
1646
1647       case MEM:
1648         output_mem_loc_descriptor (XEXP (rtl, 0));
1649         ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_DEREF4);
1650         break;
1651
1652       case CONST:
1653       case SYMBOL_REF:
1654         ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADDR);
1655         ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl);
1656         break;
1657
1658       case PLUS:
1659         output_mem_loc_descriptor (XEXP (rtl, 0));
1660         output_mem_loc_descriptor (XEXP (rtl, 1));
1661         ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD);
1662         break;
1663
1664       case CONST_INT:
1665         ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST);
1666         ASM_OUTPUT_DWARF_DATA4 (asm_out_file, INTVAL (rtl));
1667         break;
1668
1669       default:
1670         abort ();
1671     }
1672 }
1673
1674 /* Output a proper Dwarf location descriptor for a variable or parameter
1675    which is either allocated in a register or in a memory location.  For
1676    a register, we just generate an OP_REG and the register number.  For a
1677    memory location we provide a Dwarf postfix expression describing how to
1678    generate the (dynamic) address of the object onto the address stack.  */
1679
1680 static void
1681 output_loc_descriptor (rtl)
1682      register rtx rtl;
1683 {
1684   switch (GET_CODE (rtl))
1685     {
1686     case SUBREG:
1687
1688         /* The case of a subreg may arise when we have a local (register)
1689            variable or a formal (register) parameter which doesn't quite
1690            fill up an entire register.  For now, just assume that it is
1691            legitimate to make the Dwarf info refer to the whole register
1692            which contains the given subreg.  */
1693
1694         rtl = XEXP (rtl, 0);
1695         /* Drop thru.  */
1696
1697     case REG:
1698         ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_REG);
1699         output_reg_number (rtl);
1700         break;
1701
1702     case MEM:
1703       output_mem_loc_descriptor (XEXP (rtl, 0));
1704       break;
1705
1706     default:
1707       abort ();         /* Should never happen */
1708     }
1709 }
1710
1711 /* Given a tree node describing an array bound (either lower or upper)
1712    output a representation for that bound.  */
1713
1714 static void
1715 output_bound_representation (bound, dim_num, u_or_l)
1716      register tree bound;
1717      register unsigned dim_num; /* For multi-dimensional arrays.  */
1718      register char u_or_l;      /* Designates upper or lower bound.  */
1719 {
1720   switch (TREE_CODE (bound))
1721     {
1722
1723     case ERROR_MARK:
1724       return;
1725
1726       /* All fixed-bounds are represented by INTEGER_CST nodes.  */
1727
1728     case INTEGER_CST:
1729       ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
1730                               (unsigned) TREE_INT_CST_LOW (bound));
1731       break;
1732
1733     default:
1734
1735       /* Dynamic bounds may be represented by NOP_EXPR nodes containing
1736          SAVE_EXPR nodes, in which case we can do something, or as
1737          an expression, which we cannot represent.  */
1738       {
1739         char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
1740         char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
1741
1742         sprintf (begin_label, BOUND_BEGIN_LABEL_FMT,
1743                  current_dienum, dim_num, u_or_l);
1744
1745         sprintf (end_label, BOUND_END_LABEL_FMT,
1746                  current_dienum, dim_num, u_or_l);
1747
1748         ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
1749         ASM_OUTPUT_LABEL (asm_out_file, begin_label);
1750
1751         /* If optimization is turned on, the SAVE_EXPRs that describe
1752            how to access the upper bound values are essentially bogus.
1753            They only describe (at best) how to get at these values at
1754            the points in the generated code right after they have just
1755            been computed.  Worse yet, in the typical case, the upper
1756            bound values will not even *be* computed in the optimized
1757            code, so these SAVE_EXPRs are entirely bogus.
1758
1759            In order to compensate for this fact, we check here to see
1760            if optimization is enabled, and if so, we effectively create
1761            an empty location description for the (unknown and unknowable)
1762            upper bound.
1763
1764            This should not cause too much trouble for existing (stupid?)
1765            debuggers because they have to deal with empty upper bounds
1766            location descriptions anyway in order to be able to deal with
1767            incomplete array types.
1768
1769            Of course an intelligent debugger (GDB?) should be able to
1770            comprehend that a missing upper bound specification in a
1771            array type used for a storage class `auto' local array variable
1772            indicates that the upper bound is both unknown (at compile-
1773            time) and unknowable (at run-time) due to optimization. */
1774
1775         if (! optimize)
1776           {
1777             while (TREE_CODE (bound) == NOP_EXPR
1778                    || TREE_CODE (bound) == CONVERT_EXPR)
1779               bound = TREE_OPERAND (bound, 0);
1780
1781             if (TREE_CODE (bound) == SAVE_EXPR)
1782               output_loc_descriptor
1783                 (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
1784           }
1785
1786         ASM_OUTPUT_LABEL (asm_out_file, end_label);
1787       }
1788       break;
1789
1790     }
1791 }
1792
1793 /* Recursive function to output a sequence of value/name pairs for
1794    enumeration constants in reversed order.  This is called from
1795    enumeration_type_die.  */
1796
1797 static void
1798 output_enumeral_list (link)
1799      register tree link;
1800 {
1801   if (link)
1802     {
1803       output_enumeral_list (TREE_CHAIN (link));
1804       ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
1805                               (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
1806       ASM_OUTPUT_DWARF_STRING (asm_out_file,
1807                                IDENTIFIER_POINTER (TREE_PURPOSE (link)));
1808     }
1809 }
1810
1811 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
1812    which is not less than the value itself.  */
1813
1814 static inline unsigned
1815 ceiling (value, boundary)
1816      register unsigned value;
1817      register unsigned boundary;
1818 {
1819   return (((value + boundary - 1) / boundary) * boundary);
1820 }
1821
1822 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
1823    pointer to the declared type for the relevant field variable, or return
1824    `integer_type_node' if the given node turns out to be an ERROR_MARK node.  */
1825
1826 static inline tree
1827 field_type (decl)
1828      register tree decl;
1829 {
1830   register tree type;
1831
1832   if (TREE_CODE (decl) == ERROR_MARK)
1833     return integer_type_node;
1834
1835   type = DECL_BIT_FIELD_TYPE (decl);
1836   if (type == NULL)
1837     type = TREE_TYPE (decl);
1838   return type;
1839 }
1840
1841 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
1842    node, return the alignment in bits for the type, or else return
1843    BITS_PER_WORD if the node actually turns out to be an ERROR_MARK node.  */
1844
1845 static inline unsigned
1846 simple_type_align_in_bits (type)
1847      register tree type;
1848 {
1849   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
1850 }
1851
1852 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
1853    node, return the size in bits for the type if it is a constant, or
1854    else return the alignment for the type if the type's size is not
1855    constant, or else return BITS_PER_WORD if the type actually turns out
1856    to be an ERROR_MARK node.  */
1857
1858 static inline unsigned
1859 simple_type_size_in_bits (type)
1860      register tree type;
1861 {
1862   if (TREE_CODE (type) == ERROR_MARK)
1863     return BITS_PER_WORD;
1864   else
1865     {
1866       register tree type_size_tree = TYPE_SIZE (type);
1867
1868       if (TREE_CODE (type_size_tree) != INTEGER_CST)
1869         return TYPE_ALIGN (type);
1870
1871       return (unsigned) TREE_INT_CST_LOW (type_size_tree);
1872     }
1873 }
1874
1875 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
1876    return the byte offset of the lowest addressed byte of the "containing
1877    object" for the given FIELD_DECL, or return 0 if we are unable to deter-
1878    mine what that offset is, either because the argument turns out to be a
1879    pointer to an ERROR_MARK node, or because the offset is actually variable.
1880    (We can't handle the latter case just yet.)  */
1881
1882 static unsigned
1883 field_byte_offset (decl)
1884      register tree decl;
1885 {
1886   register unsigned type_align_in_bytes;
1887   register unsigned type_align_in_bits;
1888   register unsigned type_size_in_bits;
1889   register unsigned object_offset_in_align_units;
1890   register unsigned object_offset_in_bits;
1891   register unsigned object_offset_in_bytes;
1892   register tree type;
1893   register tree bitpos_tree;
1894   register tree field_size_tree;
1895   register unsigned bitpos_int;
1896   register unsigned deepest_bitpos;
1897   register unsigned field_size_in_bits;
1898
1899   if (TREE_CODE (decl) == ERROR_MARK)
1900     return 0;
1901
1902   if (TREE_CODE (decl) != FIELD_DECL)
1903     abort ();
1904
1905   type = field_type (decl);
1906
1907   bitpos_tree = DECL_FIELD_BITPOS (decl);
1908   field_size_tree = DECL_SIZE (decl);
1909
1910   /* We cannot yet cope with fields whose positions or sizes are variable,
1911      so for now, when we see such things, we simply return 0.  Someday,
1912      we may be able to handle such cases, but it will be damn difficult.  */
1913
1914   if (TREE_CODE (bitpos_tree) != INTEGER_CST)
1915     return 0;
1916   bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
1917
1918   if (TREE_CODE (field_size_tree) != INTEGER_CST)
1919     return 0;
1920   field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
1921
1922   type_size_in_bits = simple_type_size_in_bits (type);
1923
1924   type_align_in_bits = simple_type_align_in_bits (type);
1925   type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
1926
1927   /* Note that the GCC front-end doesn't make any attempt to keep track
1928      of the starting bit offset (relative to the start of the containing
1929      structure type) of the hypothetical "containing object" for a bit-
1930      field.  Thus, when computing the byte offset value for the start of
1931      the "containing object" of a bit-field, we must deduce this infor-
1932      mation on our own.
1933
1934      This can be rather tricky to do in some cases.  For example, handling
1935      the following structure type definition when compiling for an i386/i486
1936      target (which only aligns long long's to 32-bit boundaries) can be very
1937      tricky:
1938
1939                 struct S {
1940                         int             field1;
1941                         long long       field2:31;
1942                 };
1943
1944      Fortunately, there is a simple rule-of-thumb which can be used in such
1945      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for
1946      the structure shown above.  It decides to do this based upon one simple
1947      rule for bit-field allocation.  Quite simply, GCC allocates each "con-
1948      taining object" for each bit-field at the first (i.e. lowest addressed)
1949      legitimate alignment boundary (based upon the required minimum alignment
1950      for the declared type of the field) which it can possibly use, subject
1951      to the condition that there is still enough available space remaining
1952      in the containing object (when allocated at the selected point) to
1953      fully accommodate all of the bits of the bit-field itself.
1954
1955      This simple rule makes it obvious why GCC allocates 8 bytes for each
1956      object of the structure type shown above.  When looking for a place to
1957      allocate the "containing object" for `field2', the compiler simply tries
1958      to allocate a 64-bit "containing object" at each successive 32-bit
1959      boundary (starting at zero) until it finds a place to allocate that 64-
1960      bit field such that at least 31 contiguous (and previously unallocated)
1961      bits remain within that selected 64 bit field.  (As it turns out, for
1962      the example above, the compiler finds that it is OK to allocate the
1963      "containing object" 64-bit field at bit-offset zero within the
1964      structure type.)
1965
1966      Here we attempt to work backwards from the limited set of facts we're
1967      given, and we try to deduce from those facts, where GCC must have
1968      believed that the containing object started (within the structure type).
1969
1970      The value we deduce is then used (by the callers of this routine) to
1971      generate AT_location and AT_bit_offset attributes for fields (both
1972      bit-fields and, in the case of AT_location, regular fields as well).
1973   */
1974
1975   /* Figure out the bit-distance from the start of the structure to the
1976      "deepest" bit of the bit-field.  */
1977   deepest_bitpos = bitpos_int + field_size_in_bits;
1978
1979   /* This is the tricky part.  Use some fancy footwork to deduce where the
1980      lowest addressed bit of the containing object must be.  */
1981   object_offset_in_bits
1982     = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
1983
1984   /* Compute the offset of the containing object in "alignment units".  */
1985   object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
1986
1987   /* Compute the offset of the containing object in bytes.  */
1988   object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
1989
1990   return object_offset_in_bytes;
1991 }
1992
1993 /****************************** attributes *********************************/
1994
1995 /* The following routines are responsible for writing out the various types
1996    of Dwarf attributes (and any following data bytes associated with them).
1997    These routines are listed in order based on the numerical codes of their
1998    associated attributes.  */
1999
2000 /* Generate an AT_sibling attribute.  */
2001
2002 static inline void
2003 sibling_attribute ()
2004 {
2005   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2006
2007   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sibling);
2008   sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM);
2009   ASM_OUTPUT_DWARF_REF (asm_out_file, label);
2010 }
2011
2012 /* Output the form of location attributes suitable for whole variables and
2013    whole parameters.  Note that the location attributes for struct fields
2014    are generated by the routine `data_member_location_attribute' below.  */
2015
2016 static void
2017 location_attribute (rtl)
2018      register rtx rtl;
2019 {
2020   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2021   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2022
2023   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location);
2024   sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
2025   sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
2026   ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2027   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2028
2029   /* Handle a special case.  If we are about to output a location descriptor
2030      for a variable or parameter which has been optimized out of existence,
2031      don't do that.  Instead we output a zero-length location descriptor
2032      value as part of the location attribute.
2033
2034      A variable which has been optimized out of existence will have a
2035      DECL_RTL value which denotes a pseudo-reg.
2036
2037      Currently, in some rare cases, variables can have DECL_RTL values
2038      which look like (MEM (REG pseudo-reg#)).  These cases are due to
2039      bugs elsewhere in the compiler.  We treat such cases
2040      as if the variable(s) in question had been optimized out of existence.
2041
2042      Note that in all cases where we wish to express the fact that a
2043      variable has been optimized out of existence, we do not simply
2044      suppress the generation of the entire location attribute because
2045      the absence of a location attribute in certain kinds of DIEs is
2046      used to indicate something else entirely... i.e. that the DIE
2047      represents an object declaration, but not a definition.  So saith
2048      the PLSIG.
2049   */
2050
2051   if (! is_pseudo_reg (rtl)
2052       && (GET_CODE (rtl) != MEM || ! is_pseudo_reg (XEXP (rtl, 0))))
2053     output_loc_descriptor (eliminate_regs (rtl, 0, NULL_RTX));
2054
2055   ASM_OUTPUT_LABEL (asm_out_file, end_label);
2056 }
2057
2058 /* Output the specialized form of location attribute used for data members
2059    of struct and union types.
2060
2061    In the special case of a FIELD_DECL node which represents a bit-field,
2062    the "offset" part of this special location descriptor must indicate the
2063    distance in bytes from the lowest-addressed byte of the containing
2064    struct or union type to the lowest-addressed byte of the "containing
2065    object" for the bit-field.  (See the `field_byte_offset' function above.)
2066
2067    For any given bit-field, the "containing object" is a hypothetical
2068    object (of some integral or enum type) within which the given bit-field
2069    lives.  The type of this hypothetical "containing object" is always the
2070    same as the declared type of the individual bit-field itself (for GCC
2071    anyway... the DWARF spec doesn't actually mandate this).
2072
2073    Note that it is the size (in bytes) of the hypothetical "containing
2074    object" which will be given in the AT_byte_size attribute for this
2075    bit-field.  (See the `byte_size_attribute' function below.)  It is
2076    also used when calculating the value of the AT_bit_offset attribute.
2077    (See the `bit_offset_attribute' function below.)  */
2078
2079 static void
2080 data_member_location_attribute (decl)
2081      register tree decl;
2082 {
2083   register unsigned object_offset_in_bytes = field_byte_offset (decl);
2084   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2085   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2086
2087   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location);
2088   sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
2089   sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
2090   ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2091   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2092   ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST);
2093   ASM_OUTPUT_DWARF_DATA4 (asm_out_file, object_offset_in_bytes);
2094   ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD);
2095   ASM_OUTPUT_LABEL (asm_out_file, end_label);
2096 }
2097
2098 /* Output an AT_const_value attribute for a variable or a parameter which
2099    does not have a "location" either in memory or in a register.  These
2100    things can arise in GNU C when a constant is passed as an actual
2101    parameter to an inlined function.  They can also arise in C++ where
2102    declared constants do not necessarily get memory "homes".  */
2103
2104 static void
2105 const_value_attribute (rtl)
2106      register rtx rtl;
2107 {
2108   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2109   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2110
2111   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_const_value_block4);
2112   sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
2113   sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
2114   ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
2115   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2116
2117   switch (GET_CODE (rtl))
2118     {
2119       case CONST_INT:
2120         /* Note that a CONST_INT rtx could represent either an integer or
2121            a floating-point constant.  A CONST_INT is used whenever the
2122            constant will fit into a single word.  In all such cases, the
2123            original mode of the constant value is wiped out, and the
2124            CONST_INT rtx is assigned VOIDmode.  Since we no longer have
2125            precise mode information for these constants, we always just
2126            output them using 4 bytes.  */
2127
2128         ASM_OUTPUT_DWARF_DATA4 (asm_out_file, (unsigned) INTVAL (rtl));
2129         break;
2130
2131       case CONST_DOUBLE:
2132         /* Note that a CONST_DOUBLE rtx could represent either an integer
2133            or a floating-point constant.  A CONST_DOUBLE is used whenever
2134            the constant requires more than one word in order to be adequately
2135            represented.  In all such cases, the original mode of the constant
2136            value is preserved as the mode of the CONST_DOUBLE rtx, but for
2137            simplicity we always just output CONST_DOUBLEs using 8 bytes.  */
2138
2139         ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
2140                                 (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (rtl),
2141                                 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (rtl));
2142         break;
2143
2144       case CONST_STRING:
2145         ASM_OUTPUT_DWARF_STRING (asm_out_file, XSTR (rtl, 0));
2146         break;
2147
2148       case SYMBOL_REF:
2149       case LABEL_REF:
2150       case CONST:
2151         ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl);
2152         break;
2153
2154       case PLUS:
2155         /* In cases where an inlined instance of an inline function is passed
2156            the address of an `auto' variable (which is local to the caller)
2157            we can get a situation where the DECL_RTL of the artificial
2158            local variable (for the inlining) which acts as a stand-in for
2159            the corresponding formal parameter (of the inline function)
2160            will look like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).
2161            This is not exactly a compile-time constant expression, but it
2162            isn't the address of the (artificial) local variable either.
2163            Rather, it represents the *value* which the artificial local
2164            variable always has during its lifetime.  We currently have no
2165            way to represent such quasi-constant values in Dwarf, so for now
2166            we just punt and generate an AT_const_value attribute with form
2167            FORM_BLOCK4 and a length of zero.  */
2168         break;
2169
2170       default:
2171         abort ();  /* No other kinds of rtx should be possible here.  */
2172     }
2173
2174   ASM_OUTPUT_LABEL (asm_out_file, end_label);
2175 }
2176
2177 /* Generate *either* an AT_location attribute or else an AT_const_value
2178    data attribute for a variable or a parameter.  We generate the
2179    AT_const_value attribute only in those cases where the given
2180    variable or parameter does not have a true "location" either in
2181    memory or in a register.  This can happen (for example) when a
2182    constant is passed as an actual argument in a call to an inline
2183    function.  (It's possible that these things can crop up in other
2184    ways also.)  Note that one type of constant value which can be
2185    passed into an inlined function is a constant pointer.  This can
2186    happen for example if an actual argument in an inlined function
2187    call evaluates to a compile-time constant address.  */
2188
2189 static void
2190 location_or_const_value_attribute (decl)
2191      register tree decl;
2192 {
2193   register rtx rtl;
2194
2195   if (TREE_CODE (decl) == ERROR_MARK)
2196     return;
2197
2198   if ((TREE_CODE (decl) != VAR_DECL) && (TREE_CODE (decl) != PARM_DECL))
2199     {
2200       /* Should never happen.  */
2201       abort ();
2202       return;
2203     }
2204
2205   /* Here we have to decide where we are going to say the parameter "lives"
2206      (as far as the debugger is concerned).  We only have a couple of choices.
2207      GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.  DECL_RTL
2208      normally indicates where the parameter lives during most of the activa-
2209      tion of the function.  If optimization is enabled however, this could
2210      be either NULL or else a pseudo-reg.  Both of those cases indicate that
2211      the parameter doesn't really live anywhere (as far as the code generation
2212      parts of GCC are concerned) during most of the function's activation.
2213      That will happen (for example) if the parameter is never referenced
2214      within the function.
2215
2216      We could just generate a location descriptor here for all non-NULL
2217      non-pseudo values of DECL_RTL and ignore all of the rest, but we can
2218      be a little nicer than that if we also consider DECL_INCOMING_RTL in
2219      cases where DECL_RTL is NULL or is a pseudo-reg.
2220
2221      Note however that we can only get away with using DECL_INCOMING_RTL as
2222      a backup substitute for DECL_RTL in certain limited cases.  In cases
2223      where DECL_ARG_TYPE(decl) indicates the same type as TREE_TYPE(decl)
2224      we can be sure that the parameter was passed using the same type as it
2225      is declared to have within the function, and that its DECL_INCOMING_RTL
2226      points us to a place where a value of that type is passed.  In cases
2227      where DECL_ARG_TYPE(decl) and TREE_TYPE(decl) are different types
2228      however, we cannot (in general) use DECL_INCOMING_RTL as a backup
2229      substitute for DECL_RTL because in these cases, DECL_INCOMING_RTL
2230      points us to a value of some type which is *different* from the type
2231      of the parameter itself.  Thus, if we tried to use DECL_INCOMING_RTL
2232      to generate a location attribute in such cases, the debugger would
2233      end up (for example) trying to fetch a `float' from a place which
2234      actually contains the first part of a `double'.  That would lead to
2235      really incorrect and confusing output at debug-time, and we don't
2236      want that now do we?
2237
2238      So in general, we DO NOT use DECL_INCOMING_RTL as a backup for DECL_RTL
2239      in cases where DECL_ARG_TYPE(decl) != TREE_TYPE(decl).  There are a
2240      couple of cute exceptions however.  On little-endian machines we can
2241      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE(decl) is
2242      not the same as TREE_TYPE(decl) but only when DECL_ARG_TYPE(decl) is
2243      an integral type which is smaller than TREE_TYPE(decl).  These cases
2244      arise when (on a little-endian machine) a non-prototyped function has
2245      a parameter declared to be of type `short' or `char'.  In such cases,
2246      TREE_TYPE(decl) will be `short' or `char', DECL_ARG_TYPE(decl) will be
2247      `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
2248      passed `int' value.  If the debugger then uses that address to fetch a
2249      `short' or a `char' (on a little-endian machine) the result will be the
2250      correct data, so we allow for such exceptional cases below.
2251
2252      Note that our goal here is to describe the place where the given formal
2253      parameter lives during most of the function's activation (i.e. between
2254      the end of the prologue and the start of the epilogue).  We'll do that
2255      as best as we can.  Note however that if the given formal parameter is
2256      modified sometime during the execution of the function, then a stack
2257      backtrace (at debug-time) will show the function as having been called
2258      with the *new* value rather than the value which was originally passed
2259      in.  This happens rarely enough that it is not a major problem, but it
2260      *is* a problem, and I'd like to fix it.  A future version of dwarfout.c
2261      may generate two additional attributes for any given TAG_formal_parameter
2262      DIE which will describe the "passed type" and the "passed location" for
2263      the given formal parameter in addition to the attributes we now generate
2264      to indicate the "declared type" and the "active location" for each
2265      parameter.  This additional set of attributes could be used by debuggers
2266      for stack backtraces.
2267
2268      Separately, note that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL
2269      can be NULL also.  This happens (for example) for inlined-instances of
2270      inline function formal parameters which are never referenced.  This really
2271      shouldn't be happening.  All PARM_DECL nodes should get valid non-NULL
2272      DECL_INCOMING_RTL values, but integrate.c doesn't currently generate
2273      these values for inlined instances of inline function parameters, so
2274      when we see such cases, we are just SOL (shit-out-of-luck) for the time
2275      being (until integrate.c gets fixed).
2276   */
2277
2278   /* Use DECL_RTL as the "location" unless we find something better.  */
2279   rtl = DECL_RTL (decl);
2280
2281   if (TREE_CODE (decl) == PARM_DECL)
2282     if (rtl == NULL_RTX || is_pseudo_reg (rtl))
2283       {
2284         /* This decl represents a formal parameter which was optimized out.  */
2285         register tree declared_type = type_main_variant (TREE_TYPE (decl));
2286         register tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
2287
2288         /* Note that DECL_INCOMING_RTL may be NULL in here, but we handle
2289            *all* cases where (rtl == NULL_RTX) just below.  */
2290
2291         if (declared_type == passed_type)
2292           rtl = DECL_INCOMING_RTL (decl);
2293         else if (! BYTES_BIG_ENDIAN)
2294           if (TREE_CODE (declared_type) == INTEGER_TYPE)
2295             if (TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
2296               rtl = DECL_INCOMING_RTL (decl);
2297       }
2298
2299   if (rtl == NULL_RTX)
2300     return;
2301
2302   switch (GET_CODE (rtl))
2303     {
2304     case CONST_INT:
2305     case CONST_DOUBLE:
2306     case CONST_STRING:
2307     case SYMBOL_REF:
2308     case LABEL_REF:
2309     case CONST:
2310     case PLUS:  /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
2311       const_value_attribute (rtl);
2312       break;
2313
2314     case MEM:
2315     case REG:
2316     case SUBREG:
2317       location_attribute (rtl);
2318       break;
2319
2320     default:
2321       abort ();         /* Should never happen.  */
2322     }
2323 }
2324
2325 /* Generate an AT_name attribute given some string value to be included as
2326    the value of the attribute.  */
2327
2328 static inline void
2329 name_attribute (name_string)
2330      register char *name_string;
2331 {
2332   if (name_string && *name_string)
2333     {
2334       ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_name);
2335       ASM_OUTPUT_DWARF_STRING (asm_out_file, name_string);
2336     }
2337 }
2338
2339 static inline void
2340 fund_type_attribute (ft_code)
2341      register unsigned ft_code;
2342 {
2343   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_fund_type);
2344   ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ft_code);
2345 }
2346
2347 static void
2348 mod_fund_type_attribute (type, decl_const, decl_volatile)
2349      register tree type;
2350      register int decl_const;
2351      register int decl_volatile;
2352 {
2353   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2354   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2355
2356   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_fund_type);
2357   sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum);
2358   sprintf (end_label, MT_END_LABEL_FMT, current_dienum);
2359   ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2360   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2361   write_modifier_bytes (type, decl_const, decl_volatile);
2362   ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file,
2363                               fundamental_type_code (root_type (type)));
2364   ASM_OUTPUT_LABEL (asm_out_file, end_label);
2365 }
2366
2367 static inline void
2368 user_def_type_attribute (type)
2369      register tree type;
2370 {
2371   char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
2372
2373   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_user_def_type);
2374   sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (type));
2375   ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name);
2376 }
2377
2378 static void
2379 mod_u_d_type_attribute (type, decl_const, decl_volatile)
2380      register tree type;
2381      register int decl_const;
2382      register int decl_volatile;
2383 {
2384   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2385   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2386   char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
2387
2388   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_u_d_type);
2389   sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum);
2390   sprintf (end_label, MT_END_LABEL_FMT, current_dienum);
2391   ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2392   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2393   write_modifier_bytes (type, decl_const, decl_volatile);
2394   sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (root_type (type)));
2395   ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name);
2396   ASM_OUTPUT_LABEL (asm_out_file, end_label);
2397 }
2398
2399 #ifdef USE_ORDERING_ATTRIBUTE
2400 static inline void
2401 ordering_attribute (ordering)
2402      register unsigned ordering;
2403 {
2404   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_ordering);
2405   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ordering);
2406 }
2407 #endif /* defined(USE_ORDERING_ATTRIBUTE) */
2408
2409 /* Note that the block of subscript information for an array type also
2410    includes information about the element type of type given array type.  */
2411
2412 static void
2413 subscript_data_attribute (type)
2414      register tree type;
2415 {
2416   register unsigned dimension_number;
2417   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2418   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2419
2420   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_subscr_data);
2421   sprintf (begin_label, SS_BEGIN_LABEL_FMT, current_dienum);
2422   sprintf (end_label, SS_END_LABEL_FMT, current_dienum);
2423   ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2424   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2425
2426   /* The GNU compilers represent multidimensional array types as sequences
2427      of one dimensional array types whose element types are themselves array
2428      types.  Here we squish that down, so that each multidimensional array
2429      type gets only one array_type DIE in the Dwarf debugging info.  The
2430      draft Dwarf specification say that we are allowed to do this kind
2431      of compression in C (because there is no difference between an
2432      array or arrays and a multidimensional array in C) but for other
2433      source languages (e.g. Ada) we probably shouldn't do this.  */
2434
2435   for (dimension_number = 0;
2436         TREE_CODE (type) == ARRAY_TYPE;
2437         type = TREE_TYPE (type), dimension_number++)
2438     {
2439       register tree domain = TYPE_DOMAIN (type);
2440
2441       /* Arrays come in three flavors.  Unspecified bounds, fixed
2442          bounds, and (in GNU C only) variable bounds.  Handle all
2443          three forms here.  */
2444
2445       if (domain)
2446         {
2447           /* We have an array type with specified bounds.  */
2448
2449           register tree lower = TYPE_MIN_VALUE (domain);
2450           register tree upper = TYPE_MAX_VALUE (domain);
2451
2452           /* Handle only fundamental types as index types for now.  */
2453
2454           if (! type_is_fundamental (domain))
2455             abort ();
2456
2457           /* Output the representation format byte for this dimension.  */
2458
2459           ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file,
2460                                   FMT_CODE (1,
2461                                             TREE_CODE (lower) == INTEGER_CST,
2462                                             TREE_CODE (upper) == INTEGER_CST));
2463
2464           /* Output the index type for this dimension.  */
2465
2466           ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file,
2467                                       fundamental_type_code (domain));
2468
2469           /* Output the representation for the lower bound.  */
2470
2471           output_bound_representation (lower, dimension_number, 'l');
2472
2473           /* Output the representation for the upper bound.  */
2474
2475           output_bound_representation (upper, dimension_number, 'u');
2476         }
2477       else
2478         {
2479           /* We have an array type with an unspecified length.  For C and
2480              C++ we can assume that this really means that (a) the index
2481              type is an integral type, and (b) the lower bound is zero.
2482              Note that Dwarf defines the representation of an unspecified
2483              (upper) bound as being a zero-length location description.  */
2484
2485           /* Output the array-bounds format byte.  */
2486
2487           ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_FT_C_X);
2488
2489           /* Output the (assumed) index type.  */
2490
2491           ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, FT_integer);
2492
2493           /* Output the (assumed) lower bound (constant) value.  */
2494
2495           ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
2496
2497           /* Output the (empty) location description for the upper bound.  */
2498
2499           ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0);
2500         }
2501     }
2502
2503   /* Output the prefix byte that says that the element type is coming up.  */
2504
2505   ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_ET);
2506
2507   /* Output a representation of the type of the elements of this array type.  */
2508
2509   type_attribute (type, 0, 0);
2510
2511   ASM_OUTPUT_LABEL (asm_out_file, end_label);
2512 }
2513
2514 static void
2515 byte_size_attribute (tree_node)
2516      register tree tree_node;
2517 {
2518   register unsigned size;
2519
2520   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_byte_size);
2521   switch (TREE_CODE (tree_node))
2522     {
2523       case ERROR_MARK:
2524         size = 0;
2525         break;
2526
2527       case ENUMERAL_TYPE:
2528       case RECORD_TYPE:
2529       case UNION_TYPE:
2530       case QUAL_UNION_TYPE:
2531         size = int_size_in_bytes (tree_node);
2532         break;
2533
2534       case FIELD_DECL:
2535         /* For a data member of a struct or union, the AT_byte_size is
2536            generally given as the number of bytes normally allocated for
2537            an object of the *declared* type of the member itself.  This
2538            is true even for bit-fields.  */
2539         size = simple_type_size_in_bits (field_type (tree_node))
2540                / BITS_PER_UNIT;
2541         break;
2542
2543       default:
2544         abort ();
2545     }
2546
2547   /* Note that `size' might be -1 when we get to this point.  If it
2548      is, that indicates that the byte size of the entity in question
2549      is variable.  We have no good way of expressing this fact in Dwarf
2550      at the present time, so just let the -1 pass on through.  */
2551
2552   ASM_OUTPUT_DWARF_DATA4 (asm_out_file, size);
2553 }
2554
2555 /* For a FIELD_DECL node which represents a bit-field, output an attribute
2556    which specifies the distance in bits from the highest order bit of the
2557    "containing object" for the bit-field to the highest order bit of the
2558    bit-field itself.
2559
2560    For any given bit-field, the "containing object" is a hypothetical
2561    object (of some integral or enum type) within which the given bit-field
2562    lives.  The type of this hypothetical "containing object" is always the
2563    same as the declared type of the individual bit-field itself.
2564
2565    The determination of the exact location of the "containing object" for
2566    a bit-field is rather complicated.  It's handled by the `field_byte_offset'
2567    function (above).
2568
2569    Note that it is the size (in bytes) of the hypothetical "containing
2570    object" which will be given in the AT_byte_size attribute for this
2571    bit-field.  (See `byte_size_attribute' above.) */
2572
2573 static inline void
2574 bit_offset_attribute (decl)
2575     register tree decl;
2576 {
2577   register unsigned object_offset_in_bytes = field_byte_offset (decl);
2578   register tree type = DECL_BIT_FIELD_TYPE (decl);
2579   register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
2580   register unsigned bitpos_int;
2581   register unsigned highest_order_object_bit_offset;
2582   register unsigned highest_order_field_bit_offset;
2583   register unsigned bit_offset;
2584
2585   assert (TREE_CODE (decl) == FIELD_DECL);      /* Must be a field.  */
2586   assert (type);                                /* Must be a bit field.  */
2587
2588   /* We can't yet handle bit-fields whose offsets are variable, so if we
2589      encounter such things, just return without generating any attribute
2590      whatsoever.  */
2591
2592   if (TREE_CODE (bitpos_tree) != INTEGER_CST)
2593     return;
2594   bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
2595
2596   /* Note that the bit offset is always the distance (in bits) from the
2597      highest-order bit of the "containing object" to the highest-order
2598      bit of the bit-field itself.  Since the "high-order end" of any
2599      object or field is different on big-endian and little-endian machines,
2600      the computation below must take account of these differences.  */
2601
2602   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
2603   highest_order_field_bit_offset = bitpos_int;
2604
2605   if (! BYTES_BIG_ENDIAN)
2606     {
2607       highest_order_field_bit_offset
2608         += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
2609
2610       highest_order_object_bit_offset += simple_type_size_in_bits (type);
2611     }
2612
2613   bit_offset =
2614     (! BYTES_BIG_ENDIAN
2615      ? highest_order_object_bit_offset - highest_order_field_bit_offset
2616      : highest_order_field_bit_offset - highest_order_object_bit_offset);
2617
2618   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_offset);
2619   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, bit_offset);
2620 }
2621
2622 /* For a FIELD_DECL node which represents a bit field, output an attribute
2623    which specifies the length in bits of the given field.  */
2624
2625 static inline void
2626 bit_size_attribute (decl)
2627     register tree decl;
2628 {
2629   assert (TREE_CODE (decl) == FIELD_DECL);      /* Must be a field.  */
2630   assert (DECL_BIT_FIELD_TYPE (decl));          /* Must be a bit field.  */
2631
2632   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_size);
2633   ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
2634                           (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
2635 }
2636
2637 /* The following routine outputs the `element_list' attribute for enumeration
2638    type DIEs.  The element_lits attribute includes the names and values of
2639    all of the enumeration constants associated with the given enumeration
2640    type.  */
2641
2642 static inline void
2643 element_list_attribute (element)
2644      register tree element;
2645 {
2646   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2647   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2648
2649   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_element_list);
2650   sprintf (begin_label, EE_BEGIN_LABEL_FMT, current_dienum);
2651   sprintf (end_label, EE_END_LABEL_FMT, current_dienum);
2652   ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
2653   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2654
2655   /* Here we output a list of value/name pairs for each enumeration constant
2656      defined for this enumeration type (as required), but we do it in REVERSE
2657      order.  The order is the one required by the draft #5 Dwarf specification
2658      published by the UI/PLSIG.  */
2659
2660   output_enumeral_list (element);   /* Recursively output the whole list.  */
2661
2662   ASM_OUTPUT_LABEL (asm_out_file, end_label);
2663 }
2664
2665 /* Generate an AT_stmt_list attribute.  These are normally present only in
2666    DIEs with a TAG_compile_unit tag.  */
2667
2668 static inline void
2669 stmt_list_attribute (label)
2670     register char *label;
2671 {
2672   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list);
2673   /* Don't use ASM_OUTPUT_DWARF_DATA4 here.  */
2674   ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
2675 }
2676
2677 /* Generate an AT_low_pc attribute for a label DIE, a lexical_block DIE or
2678    for a subroutine DIE.  */
2679
2680 static inline void
2681 low_pc_attribute (asm_low_label)
2682      register char *asm_low_label;
2683 {
2684   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc);
2685   ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label);
2686 }
2687
2688 /* Generate an AT_high_pc attribute for a lexical_block DIE or for a
2689    subroutine DIE.  */
2690
2691 static inline void
2692 high_pc_attribute (asm_high_label)
2693     register char *asm_high_label;
2694 {
2695   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc);
2696   ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label);
2697 }
2698
2699 /* Generate an AT_body_begin attribute for a subroutine DIE.  */
2700
2701 static inline void
2702 body_begin_attribute (asm_begin_label)
2703      register char *asm_begin_label;
2704 {
2705   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_begin);
2706   ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_begin_label);
2707 }
2708
2709 /* Generate an AT_body_end attribute for a subroutine DIE.  */
2710
2711 static inline void
2712 body_end_attribute (asm_end_label)
2713      register char *asm_end_label;
2714 {
2715   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_end);
2716   ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_end_label);
2717 }
2718
2719 /* Generate an AT_language attribute given a LANG value.  These attributes
2720    are used only within TAG_compile_unit DIEs.  */
2721
2722 static inline void
2723 language_attribute (language_code)
2724      register unsigned language_code;
2725 {
2726   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_language);
2727   ASM_OUTPUT_DWARF_DATA4 (asm_out_file, language_code);
2728 }
2729
2730 static inline void
2731 member_attribute (context)
2732     register tree context;
2733 {
2734   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2735
2736   /* Generate this attribute only for members in C++.  */
2737
2738   if (context != NULL && is_tagged_type (context))
2739     {
2740       ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_member);
2741       sprintf (label, TYPE_NAME_FMT, TYPE_UID (context));
2742       ASM_OUTPUT_DWARF_REF (asm_out_file, label);
2743     }
2744 }
2745
2746 static inline void
2747 string_length_attribute (upper_bound)
2748      register tree upper_bound;
2749 {
2750   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2751   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2752
2753   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_string_length);
2754   sprintf (begin_label, SL_BEGIN_LABEL_FMT, current_dienum);
2755   sprintf (end_label, SL_END_LABEL_FMT, current_dienum);
2756   ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2757   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2758   output_bound_representation (upper_bound, 0, 'u');
2759   ASM_OUTPUT_LABEL (asm_out_file, end_label);
2760 }
2761
2762 static inline void
2763 comp_dir_attribute (dirname)
2764      register char *dirname;
2765 {
2766   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir);
2767   ASM_OUTPUT_DWARF_STRING (asm_out_file, dirname);
2768 }
2769
2770 static inline void
2771 sf_names_attribute (sf_names_start_label)
2772      register char *sf_names_start_label;
2773 {
2774   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names);
2775   /* Don't use ASM_OUTPUT_DWARF_DATA4 here.  */
2776   ASM_OUTPUT_DWARF_ADDR (asm_out_file, sf_names_start_label);
2777 }
2778
2779 static inline void
2780 src_info_attribute (src_info_start_label)
2781      register char *src_info_start_label;
2782 {
2783   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info);
2784   /* Don't use ASM_OUTPUT_DWARF_DATA4 here.  */
2785   ASM_OUTPUT_DWARF_ADDR (asm_out_file, src_info_start_label);
2786 }
2787
2788 static inline void
2789 mac_info_attribute (mac_info_start_label)
2790      register char *mac_info_start_label;
2791 {
2792   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info);
2793   /* Don't use ASM_OUTPUT_DWARF_DATA4 here.  */
2794   ASM_OUTPUT_DWARF_ADDR (asm_out_file, mac_info_start_label);
2795 }
2796
2797 static inline void
2798 prototyped_attribute (func_type)
2799      register tree func_type;
2800 {
2801   if ((strcmp (language_string, "GNU C") == 0)
2802       && (TYPE_ARG_TYPES (func_type) != NULL))
2803     {
2804       ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_prototyped);
2805       ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
2806     }
2807 }
2808
2809 static inline void
2810 producer_attribute (producer)
2811      register char *producer;
2812 {
2813   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer);
2814   ASM_OUTPUT_DWARF_STRING (asm_out_file, producer);
2815 }
2816
2817 static inline void
2818 inline_attribute (decl)
2819      register tree decl;
2820 {
2821   if (DECL_INLINE (decl))
2822     {
2823       ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_inline);
2824       ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
2825     }
2826 }
2827
2828 static inline void
2829 containing_type_attribute (containing_type)
2830      register tree containing_type;
2831 {
2832   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2833
2834   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_containing_type);
2835   sprintf (label, TYPE_NAME_FMT, TYPE_UID (containing_type));
2836   ASM_OUTPUT_DWARF_REF (asm_out_file, label);
2837 }
2838
2839 static inline void
2840 abstract_origin_attribute (origin)
2841      register tree origin;
2842 {
2843   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2844
2845   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_abstract_origin);
2846   switch (TREE_CODE_CLASS (TREE_CODE (origin)))
2847     {
2848     case 'd':
2849       sprintf (label, DECL_NAME_FMT, DECL_UID (origin));
2850       break;
2851
2852     case 't':
2853       sprintf (label, TYPE_NAME_FMT, TYPE_UID (origin));
2854       break;
2855
2856     default:
2857       abort ();         /* Should never happen.  */
2858
2859     }
2860   ASM_OUTPUT_DWARF_REF (asm_out_file, label);
2861 }
2862
2863 #ifdef DWARF_DECL_COORDINATES
2864 static inline void
2865 src_coords_attribute (src_fileno, src_lineno)
2866      register unsigned src_fileno;
2867      register unsigned src_lineno;
2868 {
2869   ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_coords);
2870   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_fileno);
2871   ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_lineno);
2872 }
2873 #endif /* defined(DWARF_DECL_COORDINATES) */
2874
2875 static inline void
2876 pure_or_virtual_attribute (func_decl)
2877      register tree func_decl;
2878 {
2879   if (DECL_VIRTUAL_P (func_decl))
2880     {
2881 #if 0 /* DECL_ABSTRACT_VIRTUAL_P is C++-specific.  */
2882       if (DECL_ABSTRACT_VIRTUAL_P (func_decl))
2883         ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_pure_virtual);
2884       else
2885 #endif
2886         ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_virtual);
2887       ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
2888     }
2889 }
2890
2891 /************************* end of attributes *****************************/
2892
2893 /********************* utility routines for DIEs *************************/
2894
2895 /* Output an AT_name attribute and an AT_src_coords attribute for the
2896    given decl, but only if it actually has a name.  */
2897
2898 static void
2899 name_and_src_coords_attributes (decl)
2900     register tree decl;
2901 {
2902   register tree decl_name = DECL_NAME (decl);
2903
2904   if (decl_name && IDENTIFIER_POINTER (decl_name))
2905     {
2906       name_attribute (IDENTIFIER_POINTER (decl_name));
2907 #ifdef DWARF_DECL_COORDINATES
2908       {
2909         register unsigned file_index;
2910
2911         /* This is annoying, but we have to pop out of the .debug section
2912            for a moment while we call `lookup_filename' because calling it
2913            may cause a temporary switch into the .debug_sfnames section and
2914            most svr4 assemblers are not smart enough be be able to nest
2915            section switches to any depth greater than one.  Note that we
2916            also can't skirt this issue by delaying all output to the
2917            .debug_sfnames section unit the end of compilation because that
2918            would cause us to have inter-section forward references and
2919            Fred Fish sez that m68k/svr4 assemblers botch those.  */
2920
2921         ASM_OUTPUT_POP_SECTION (asm_out_file);
2922         file_index = lookup_filename (DECL_SOURCE_FILE (decl));
2923         ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
2924
2925         src_coords_attribute (file_index, DECL_SOURCE_LINE (decl));
2926       }
2927 #endif /* defined(DWARF_DECL_COORDINATES) */
2928     }
2929 }
2930
2931 /* Many forms of DIEs contain a "type description" part.  The following
2932    routine writes out these "type descriptor" parts.  */
2933
2934 static void
2935 type_attribute (type, decl_const, decl_volatile)
2936      register tree type;
2937      register int decl_const;
2938      register int decl_volatile;
2939 {
2940   register enum tree_code code = TREE_CODE (type);
2941   register int root_type_modified;
2942
2943   if (TREE_CODE (type) == ERROR_MARK)
2944     return;
2945
2946   /* Handle a special case.  For functions whose return type is void,
2947      we generate *no* type attribute.  (Note that no object may have
2948      type `void', so this only applies to function return types.  */
2949
2950   if (TREE_CODE (type) == VOID_TYPE)
2951     return;
2952
2953   root_type_modified = (code == POINTER_TYPE || code == REFERENCE_TYPE
2954                         || decl_const || decl_volatile
2955                         || TYPE_READONLY (type) || TYPE_VOLATILE (type));
2956
2957   if (type_is_fundamental (root_type (type)))
2958     if (root_type_modified)
2959         mod_fund_type_attribute (type, decl_const, decl_volatile);
2960     else
2961         fund_type_attribute (fundamental_type_code (type));
2962   else
2963     if (root_type_modified)
2964         mod_u_d_type_attribute (type, decl_const, decl_volatile);
2965     else
2966         /* We have to get the type_main_variant here (and pass that to the
2967            `user_def_type_attribute' routine) because the ..._TYPE node we
2968            have might simply be a *copy* of some original type node (where
2969            the copy was created to help us keep track of typedef names)
2970            and that copy might have a different TYPE_UID from the original
2971            ..._TYPE node.  (Note that when `equate_type_number_to_die_number'
2972            is labeling a given type DIE for future reference, it always and
2973            only creates labels for DIEs representing *main variants*, and it
2974            never even knows about non-main-variants.)  */
2975         user_def_type_attribute (type_main_variant (type));
2976 }
2977
2978 /* Given a tree pointer to a struct, class, union, or enum type node, return
2979    a pointer to the (string) tag name for the given type, or zero if the
2980    type was declared without a tag.  */
2981
2982 static char *
2983 type_tag (type)
2984      register tree type;
2985 {
2986   register char *name = 0;
2987
2988   if (TYPE_NAME (type) != 0)
2989     {
2990       register tree t = 0;
2991
2992       /* Find the IDENTIFIER_NODE for the type name.  */
2993       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
2994         t = TYPE_NAME (type);
2995
2996       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
2997          a TYPE_DECL node, regardless of whether or not a `typedef' was
2998          involved.  */
2999       else
3000         if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
3001           t = DECL_NAME (TYPE_NAME (type));
3002
3003       /* Now get the name as a string, or invent one.  */
3004       if (t != 0)
3005         name = IDENTIFIER_POINTER (t);
3006     }
3007
3008   return (name == 0 || *name == '\0') ? 0 : name;
3009 }
3010
3011 static inline void
3012 dienum_push ()
3013 {
3014   /* Start by checking if the pending_sibling_stack needs to be expanded.
3015      If necessary, expand it.  */
3016
3017   if (pending_siblings == pending_siblings_allocated)
3018     {
3019       pending_siblings_allocated += PENDING_SIBLINGS_INCREMENT;
3020       pending_sibling_stack
3021         = (unsigned *) xrealloc (pending_sibling_stack,
3022                                  pending_siblings_allocated * sizeof(unsigned));
3023     }
3024
3025   pending_siblings++;
3026   NEXT_DIE_NUM = next_unused_dienum++;
3027 }
3028
3029 /* Pop the sibling stack so that the most recently pushed DIEnum becomes the
3030    NEXT_DIE_NUM.  */
3031
3032 static inline void
3033 dienum_pop ()
3034 {
3035   pending_siblings--;
3036 }
3037
3038 static inline tree
3039 member_declared_type (member)
3040      register tree member;
3041 {
3042   return (DECL_BIT_FIELD_TYPE (member))
3043            ? DECL_BIT_FIELD_TYPE (member)
3044            : TREE_TYPE (member);
3045 }
3046
3047 /* Get the function's label, as described by its RTL.
3048    This may be different from the DECL_NAME name used
3049    in the source file.  */
3050
3051 static char *
3052 function_start_label (decl)
3053     register tree decl;
3054 {
3055   rtx x;
3056   char *fnname;
3057
3058   x = DECL_RTL (decl);
3059   if (GET_CODE (x) != MEM)
3060     abort ();
3061   x = XEXP (x, 0);
3062   if (GET_CODE (x) != SYMBOL_REF)
3063                abort ();
3064   fnname = XSTR (x, 0);
3065   return fnname;
3066 }
3067
3068
3069 /******************************* DIEs ************************************/
3070
3071 /* Output routines for individual types of DIEs.  */
3072
3073 /* Note that every type of DIE (except a null DIE) gets a sibling.  */
3074
3075 static void
3076 output_array_type_die (arg)
3077      register void *arg;
3078 {
3079   register tree type = arg;
3080
3081   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_array_type);
3082   sibling_attribute ();
3083   equate_type_number_to_die_number (type);
3084   member_attribute (TYPE_CONTEXT (type));
3085
3086   /* I believe that we can default the array ordering.  SDB will probably
3087      do the right things even if AT_ordering is not present.  It's not
3088      even an issue until we start to get into multidimensional arrays
3089      anyway.  If SDB is ever caught doing the Wrong Thing for multi-
3090      dimensional arrays, then we'll have to put the AT_ordering attribute
3091      back in.  (But if and when we find out that we need to put these in,
3092      we will only do so for multidimensional arrays.  After all, we don't
3093      want to waste space in the .debug section now do we?)  */
3094
3095 #ifdef USE_ORDERING_ATTRIBUTE
3096   ordering_attribute (ORD_row_major);
3097 #endif /* defined(USE_ORDERING_ATTRIBUTE) */
3098
3099   subscript_data_attribute (type);
3100 }
3101
3102 static void
3103 output_set_type_die (arg)
3104      register void *arg;
3105 {
3106   register tree type = arg;
3107
3108   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_set_type);
3109   sibling_attribute ();
3110   equate_type_number_to_die_number (type);
3111   member_attribute (TYPE_CONTEXT (type));
3112   type_attribute (TREE_TYPE (type), 0, 0);
3113 }
3114
3115 #if 0
3116 /* Implement this when there is a GNU FORTRAN or GNU Ada front end.  */
3117
3118 static void
3119 output_entry_point_die (arg)
3120      register void *arg;
3121 {
3122   register tree decl = arg;
3123   register tree origin = decl_ultimate_origin (decl);
3124
3125   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_entry_point);
3126   sibling_attribute ();
3127   dienum_push ();
3128   if (origin != NULL)
3129     abstract_origin_attribute (origin);
3130   else
3131     {
3132       name_and_src_coords_attributes (decl);
3133       member_attribute (DECL_CONTEXT (decl));
3134       type_attribute (TREE_TYPE (TREE_TYPE (decl)), 0, 0);
3135     }
3136   if (DECL_ABSTRACT (decl))
3137     equate_decl_number_to_die_number (decl);
3138   else
3139     low_pc_attribute (function_start_label (decl));
3140 }
3141 #endif
3142
3143 /* Output a DIE to represent an inlined instance of an enumeration type.  */
3144
3145 static void
3146 output_inlined_enumeration_type_die (arg)
3147      register void *arg;
3148 {
3149   register tree type = arg;
3150
3151   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
3152   sibling_attribute ();
3153   assert (TREE_ASM_WRITTEN (type));
3154   abstract_origin_attribute (type);
3155 }
3156
3157 /* Output a DIE to represent an inlined instance of a structure type.  */
3158
3159 static void
3160 output_inlined_structure_type_die (arg)
3161      register void *arg;
3162 {
3163   register tree type = arg;
3164
3165   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
3166   sibling_attribute ();
3167   assert (TREE_ASM_WRITTEN (type));
3168   abstract_origin_attribute (type);
3169 }
3170
3171 /* Output a DIE to represent an inlined instance of a union type.  */
3172
3173 static void
3174 output_inlined_union_type_die (arg)
3175      register void *arg;
3176 {
3177   register tree type = arg;
3178
3179   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
3180   sibling_attribute ();
3181   assert (TREE_ASM_WRITTEN (type));
3182   abstract_origin_attribute (type);
3183 }
3184
3185 /* Output a DIE to represent an enumeration type.  Note that these DIEs
3186    include all of the information about the enumeration values also.
3187    This information is encoded into the element_list attribute.  */
3188
3189 static void
3190 output_enumeration_type_die (arg)
3191      register void *arg;
3192 {
3193   register tree type = arg;
3194
3195   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
3196   sibling_attribute ();
3197   equate_type_number_to_die_number (type);
3198   name_attribute (type_tag (type));
3199   member_attribute (TYPE_CONTEXT (type));
3200
3201   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
3202      given enum type is incomplete, do not generate the AT_byte_size
3203      attribute or the AT_element_list attribute.  */
3204
3205   if (TYPE_SIZE (type))
3206     {
3207       byte_size_attribute (type);
3208       element_list_attribute (TYPE_FIELDS (type));
3209     }
3210 }
3211
3212 /* Output a DIE to represent either a real live formal parameter decl or
3213    to represent just the type of some formal parameter position in some
3214    function type.
3215
3216    Note that this routine is a bit unusual because its argument may be
3217    a ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
3218    represents an inlining of some PARM_DECL) or else some sort of a
3219    ..._TYPE node.  If it's the former then this function is being called
3220    to output a DIE to represent a formal parameter object (or some inlining
3221    thereof).  If it's the latter, then this function is only being called
3222    to output a TAG_formal_parameter DIE to stand as a placeholder for some
3223    formal argument type of some subprogram type.  */
3224
3225 static void
3226 output_formal_parameter_die (arg)
3227      register void *arg;
3228 {
3229   register tree node = arg;
3230
3231   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_formal_parameter);
3232   sibling_attribute ();
3233
3234   switch (TREE_CODE_CLASS (TREE_CODE (node)))
3235     {
3236     case 'd':   /* We were called with some kind of a ..._DECL node.  */
3237       {
3238         register tree origin = decl_ultimate_origin (node);
3239
3240         if (origin != NULL)
3241           abstract_origin_attribute (origin);
3242         else
3243           {
3244             name_and_src_coords_attributes (node);
3245             type_attribute (TREE_TYPE (node),
3246                             TREE_READONLY (node), TREE_THIS_VOLATILE (node));
3247           }
3248         if (DECL_ABSTRACT (node))
3249           equate_decl_number_to_die_number (node);
3250         else
3251           location_or_const_value_attribute (node);
3252       }
3253       break;
3254
3255     case 't':   /* We were called with some kind of a ..._TYPE node.  */
3256       type_attribute (node, 0, 0);
3257       break;
3258
3259     default:
3260       abort (); /* Should never happen.  */
3261     }
3262 }
3263
3264 /* Output a DIE to represent a declared function (either file-scope
3265    or block-local) which has "external linkage" (according to ANSI-C).  */
3266
3267 static void
3268 output_global_subroutine_die (arg)
3269      register void *arg;
3270 {
3271   register tree decl = arg;
3272   register tree origin = decl_ultimate_origin (decl);
3273
3274   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_subroutine);
3275   sibling_attribute ();
3276   dienum_push ();
3277   if (origin != NULL)
3278     abstract_origin_attribute (origin);
3279   else
3280     {
3281       register tree type = TREE_TYPE (decl);
3282
3283       name_and_src_coords_attributes (decl);
3284       inline_attribute (decl);
3285       prototyped_attribute (type);
3286       member_attribute (DECL_CONTEXT (decl));
3287       type_attribute (TREE_TYPE (type), 0, 0);
3288       pure_or_virtual_attribute (decl);
3289     }
3290   if (DECL_ABSTRACT (decl))
3291     equate_decl_number_to_die_number (decl);
3292   else
3293     {
3294       if (! DECL_EXTERNAL (decl))
3295         {
3296           char label[MAX_ARTIFICIAL_LABEL_BYTES];
3297
3298           low_pc_attribute (function_start_label (decl));
3299           sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
3300           high_pc_attribute (label);
3301           sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
3302           body_begin_attribute (label);
3303           sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
3304           body_end_attribute (label);
3305         }
3306     }
3307 }
3308
3309 /* Output a DIE to represent a declared data object (either file-scope
3310    or block-local) which has "external linkage" (according to ANSI-C).  */
3311
3312 static void
3313 output_global_variable_die (arg)
3314      register void *arg;
3315 {
3316   register tree decl = arg;
3317   register tree origin = decl_ultimate_origin (decl);
3318
3319   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_variable);
3320   sibling_attribute ();
3321   if (origin != NULL)
3322     abstract_origin_attribute (origin);
3323   else
3324     {
3325       name_and_src_coords_attributes (decl);
3326       member_attribute (DECL_CONTEXT (decl));
3327       type_attribute (TREE_TYPE (decl),
3328                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
3329     }
3330   if (DECL_ABSTRACT (decl))
3331     equate_decl_number_to_die_number (decl);
3332   else
3333     {
3334       if (!DECL_EXTERNAL (decl))
3335         location_or_const_value_attribute (decl);
3336     }
3337 }
3338
3339 static void
3340 output_label_die (arg)
3341      register void *arg;
3342 {
3343   register tree decl = arg;
3344   register tree origin = decl_ultimate_origin (decl);
3345
3346   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_label);
3347   sibling_attribute ();
3348   if (origin != NULL)
3349     abstract_origin_attribute (origin);
3350   else
3351     name_and_src_coords_attributes (decl);
3352   if (DECL_ABSTRACT (decl))
3353     equate_decl_number_to_die_number (decl);
3354   else
3355     {
3356       register rtx insn = DECL_RTL (decl);
3357
3358       if (GET_CODE (insn) == CODE_LABEL)
3359         {
3360           char label[MAX_ARTIFICIAL_LABEL_BYTES];
3361
3362           /* When optimization is enabled (via -O) some parts of the compiler
3363              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
3364              represent source-level labels which were explicitly declared by
3365              the user.  This really shouldn't be happening though, so catch
3366              it if it ever does happen.  */
3367
3368           if (INSN_DELETED_P (insn))
3369             abort ();   /* Should never happen.  */
3370
3371           sprintf (label, INSN_LABEL_FMT, current_funcdef_number,
3372                                           (unsigned) INSN_UID (insn));
3373           low_pc_attribute (label);
3374         }
3375     }
3376 }
3377
3378 static void
3379 output_lexical_block_die (arg)
3380      register void *arg;
3381 {
3382   register tree stmt = arg;
3383
3384   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_lexical_block);
3385   sibling_attribute ();
3386   dienum_push ();
3387   if (! BLOCK_ABSTRACT (stmt))
3388     {
3389       char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
3390       char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3391
3392       sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
3393       low_pc_attribute (begin_label);
3394       sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number);
3395       high_pc_attribute (end_label);
3396     }
3397 }
3398
3399 static void
3400 output_inlined_subroutine_die (arg)
3401      register void *arg;
3402 {
3403   register tree stmt = arg;
3404
3405   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inlined_subroutine);
3406   sibling_attribute ();
3407   dienum_push ();
3408   abstract_origin_attribute (block_ultimate_origin (stmt));
3409   if (! BLOCK_ABSTRACT (stmt))
3410     {
3411       char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
3412       char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3413
3414       sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
3415       low_pc_attribute (begin_label);
3416       sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number);
3417       high_pc_attribute (end_label);
3418     }
3419 }
3420
3421 /* Output a DIE to represent a declared data object (either file-scope
3422    or block-local) which has "internal linkage" (according to ANSI-C).  */
3423
3424 static void
3425 output_local_variable_die (arg)
3426      register void *arg;
3427 {
3428   register tree decl = arg;
3429   register tree origin = decl_ultimate_origin (decl);
3430
3431   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_local_variable);
3432   sibling_attribute ();
3433   if (origin != NULL)
3434     abstract_origin_attribute (origin);
3435   else
3436     {
3437       name_and_src_coords_attributes (decl);
3438       member_attribute (DECL_CONTEXT (decl));
3439       type_attribute (TREE_TYPE (decl),
3440                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
3441     }
3442   if (DECL_ABSTRACT (decl))
3443     equate_decl_number_to_die_number (decl);
3444   else
3445     location_or_const_value_attribute (decl);
3446 }
3447
3448 static void
3449 output_member_die (arg)
3450      register void *arg;
3451 {
3452   register tree decl = arg;
3453
3454   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_member);
3455   sibling_attribute ();
3456   name_and_src_coords_attributes (decl);
3457   member_attribute (DECL_CONTEXT (decl));
3458   type_attribute (member_declared_type (decl),
3459                   TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
3460   if (DECL_BIT_FIELD_TYPE (decl))       /* If this is a bit field...  */
3461     {
3462       byte_size_attribute (decl);
3463       bit_size_attribute (decl);
3464       bit_offset_attribute (decl);
3465     }
3466   data_member_location_attribute (decl);
3467 }
3468
3469 #if 0
3470 /* Don't generate either pointer_type DIEs or reference_type DIEs.  Use
3471    modified types instead.
3472
3473    We keep this code here just in case these types of DIEs may be
3474    needed to represent certain things in other languages (e.g. Pascal)
3475    someday.  */
3476
3477 static void
3478 output_pointer_type_die (arg)
3479      register void *arg;
3480 {
3481   register tree type = arg;
3482
3483   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_pointer_type);
3484   sibling_attribute ();
3485   equate_type_number_to_die_number (type);
3486   member_attribute (TYPE_CONTEXT (type));
3487   type_attribute (TREE_TYPE (type), 0, 0);
3488 }
3489
3490 static void
3491 output_reference_type_die (arg)
3492      register void *arg;
3493 {
3494   register tree type = arg;
3495
3496   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_reference_type);
3497   sibling_attribute ();
3498   equate_type_number_to_die_number (type);
3499   member_attribute (TYPE_CONTEXT (type));
3500   type_attribute (TREE_TYPE (type), 0, 0);
3501 }
3502 #endif
3503
3504 static void
3505 output_ptr_to_mbr_type_die (arg)
3506      register void *arg;
3507 {
3508   register tree type = arg;
3509
3510   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_ptr_to_member_type);
3511   sibling_attribute ();
3512   equate_type_number_to_die_number (type);
3513   member_attribute (TYPE_CONTEXT (type));
3514   containing_type_attribute (TYPE_OFFSET_BASETYPE (type));
3515   type_attribute (TREE_TYPE (type), 0, 0);
3516 }
3517
3518 static void
3519 output_compile_unit_die (arg)
3520      register void *arg;
3521 {
3522   register char *main_input_filename = arg;
3523
3524   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_compile_unit);
3525   sibling_attribute ();
3526   dienum_push ();
3527   name_attribute (main_input_filename);
3528
3529   {
3530     char producer[250];
3531
3532     sprintf (producer, "%s %s", language_string, version_string);
3533     producer_attribute (producer);
3534   }
3535
3536   if (strcmp (language_string, "GNU C++") == 0)
3537     language_attribute (LANG_C_PLUS_PLUS);
3538   else if (strcmp (language_string, "GNU Ada") == 0)
3539     language_attribute (LANG_ADA83);
3540   else if (strcmp (language_string, "GNU F77") == 0)
3541     language_attribute (LANG_FORTRAN77);
3542   else if (flag_traditional)
3543     language_attribute (LANG_C);
3544   else
3545     language_attribute (LANG_C89);
3546   low_pc_attribute (TEXT_BEGIN_LABEL);
3547   high_pc_attribute (TEXT_END_LABEL);
3548   if (debug_info_level >= DINFO_LEVEL_NORMAL)
3549     stmt_list_attribute (LINE_BEGIN_LABEL);
3550   last_filename = xstrdup (main_input_filename);
3551
3552   {
3553     char *wd = getpwd ();
3554     if (wd)
3555       comp_dir_attribute (wd);
3556   }
3557
3558   if (debug_info_level >= DINFO_LEVEL_NORMAL)
3559     {
3560       sf_names_attribute (SFNAMES_BEGIN_LABEL);
3561       src_info_attribute (SRCINFO_BEGIN_LABEL);
3562       if (debug_info_level >= DINFO_LEVEL_VERBOSE)
3563         mac_info_attribute (MACINFO_BEGIN_LABEL);
3564     }
3565 }
3566
3567 static void
3568 output_string_type_die (arg)
3569      register void *arg;
3570 {
3571   register tree type = arg;
3572
3573   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_string_type);
3574   sibling_attribute ();
3575   member_attribute (TYPE_CONTEXT (type));
3576
3577   /* Fudge the string length attribute for now.  */
3578
3579   string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
3580 }
3581
3582 static void
3583 output_structure_type_die (arg)
3584      register void *arg;
3585 {
3586   register tree type = arg;
3587
3588   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
3589   sibling_attribute ();
3590   equate_type_number_to_die_number (type);
3591   name_attribute (type_tag (type));
3592   member_attribute (TYPE_CONTEXT (type));
3593
3594   /* If this type has been completed, then give it a byte_size attribute
3595      and prepare to give a list of members.  Otherwise, don't do either of
3596      these things.  In the latter case, we will not be generating a list
3597      of members (since we don't have any idea what they might be for an
3598      incomplete type).  */
3599
3600   if (TYPE_SIZE (type))
3601     {
3602       dienum_push ();
3603       byte_size_attribute (type);
3604     }
3605 }
3606
3607 /* Output a DIE to represent a declared function (either file-scope
3608    or block-local) which has "internal linkage" (according to ANSI-C).  */
3609
3610 static void
3611 output_local_subroutine_die (arg)
3612      register void *arg;
3613 {
3614   register tree decl = arg;
3615   register tree origin = decl_ultimate_origin (decl);
3616
3617   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine);
3618   sibling_attribute ();
3619   dienum_push ();
3620   if (origin != NULL)
3621     abstract_origin_attribute (origin);
3622   else
3623     {
3624       register tree type = TREE_TYPE (decl);
3625
3626       name_and_src_coords_attributes (decl);
3627       inline_attribute (decl);
3628       prototyped_attribute (type);
3629       member_attribute (DECL_CONTEXT (decl));
3630       type_attribute (TREE_TYPE (type), 0, 0);
3631       pure_or_virtual_attribute (decl);
3632     }
3633   if (DECL_ABSTRACT (decl))
3634     equate_decl_number_to_die_number (decl);
3635   else
3636     {
3637       /* Avoid getting screwed up in cases where a function was declared
3638          static but where no definition was ever given for it.  */
3639
3640       if (TREE_ASM_WRITTEN (decl))
3641         {
3642           char label[MAX_ARTIFICIAL_LABEL_BYTES];
3643           low_pc_attribute (function_start_label (decl));
3644           sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
3645           high_pc_attribute (label);
3646           sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
3647           body_begin_attribute (label);
3648           sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
3649           body_end_attribute (label);
3650         }
3651     }
3652 }
3653
3654 static void
3655 output_subroutine_type_die (arg)
3656      register void *arg;
3657 {
3658   register tree type = arg;
3659   register tree return_type = TREE_TYPE (type);
3660
3661   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine_type);
3662   sibling_attribute ();
3663   dienum_push ();
3664   equate_type_number_to_die_number (type);
3665   prototyped_attribute (type);
3666   member_attribute (TYPE_CONTEXT (type));
3667   type_attribute (return_type, 0, 0);
3668 }
3669
3670 static void
3671 output_typedef_die (arg)
3672      register void *arg;
3673 {
3674   register tree decl = arg;
3675   register tree origin = decl_ultimate_origin (decl);
3676
3677   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_typedef);
3678   sibling_attribute ();
3679   if (origin != NULL)
3680     abstract_origin_attribute (origin);
3681   else
3682     {
3683       name_and_src_coords_attributes (decl);
3684       member_attribute (DECL_CONTEXT (decl));
3685       type_attribute (TREE_TYPE (decl),
3686                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
3687     }
3688   if (DECL_ABSTRACT (decl))
3689     equate_decl_number_to_die_number (decl);
3690 }
3691
3692 static void
3693 output_union_type_die (arg)
3694      register void *arg;
3695 {
3696   register tree type = arg;
3697
3698   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
3699   sibling_attribute ();
3700   equate_type_number_to_die_number (type);
3701   name_attribute (type_tag (type));
3702   member_attribute (TYPE_CONTEXT (type));
3703
3704   /* If this type has been completed, then give it a byte_size attribute
3705      and prepare to give a list of members.  Otherwise, don't do either of
3706      these things.  In the latter case, we will not be generating a list
3707      of members (since we don't have any idea what they might be for an
3708      incomplete type).  */
3709
3710   if (TYPE_SIZE (type))
3711     {
3712       dienum_push ();
3713       byte_size_attribute (type);
3714     }
3715 }
3716
3717 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
3718    at the end of an (ANSI prototyped) formal parameters list.  */
3719
3720 static void
3721 output_unspecified_parameters_die (arg)
3722      register void *arg;
3723 {
3724   register tree decl_or_type = arg;
3725
3726   ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_unspecified_parameters);
3727   sibling_attribute ();
3728
3729   /* This kludge is here only for the sake of being compatible with what
3730      the USL CI5 C compiler does.  The specification of Dwarf Version 1
3731      doesn't say that TAG_unspecified_parameters DIEs should contain any
3732      attributes other than the AT_sibling attribute, but they are certainly
3733      allowed to contain additional attributes, and the CI5 compiler
3734      generates AT_name, AT_fund_type, and AT_location attributes within
3735      TAG_unspecified_parameters DIEs which appear in the child lists for
3736      DIEs representing function definitions, so we do likewise here.  */
3737
3738   if (TREE_CODE (decl_or_type) == FUNCTION_DECL && DECL_INITIAL (decl_or_type))
3739     {
3740       name_attribute ("...");
3741       fund_type_attribute (FT_pointer);
3742       /* location_attribute (?); */
3743     }
3744 }
3745
3746 static void
3747 output_padded_null_die (arg)
3748      register void *arg;
3749 {
3750   ASM_OUTPUT_ALIGN (asm_out_file, 2);   /* 2**2 == 4 */
3751 }
3752
3753 /*************************** end of DIEs *********************************/
3754
3755 /* Generate some type of DIE.  This routine generates the generic outer
3756    wrapper stuff which goes around all types of DIE's (regardless of their
3757    TAGs.  All forms of DIEs start with a DIE-specific label, followed by a
3758    DIE-length word, followed by the guts of the DIE itself.  After the guts
3759    of the DIE, there must always be a terminator label for the DIE.  */
3760
3761 static void
3762 output_die (die_specific_output_function, param)
3763      register void (*die_specific_output_function)();
3764      register void *param;
3765 {
3766   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
3767   char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3768
3769   current_dienum = NEXT_DIE_NUM;
3770   NEXT_DIE_NUM = next_unused_dienum;
3771
3772   sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum);
3773   sprintf (end_label, DIE_END_LABEL_FMT, current_dienum);
3774
3775   /* Write a label which will act as the name for the start of this DIE.  */
3776
3777   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
3778
3779   /* Write the DIE-length word.  */
3780
3781   ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
3782
3783   /* Fill in the guts of the DIE.  */
3784
3785   next_unused_dienum++;
3786   die_specific_output_function (param);
3787
3788   /* Write a label which will act as the name for the end of this DIE.  */
3789
3790   ASM_OUTPUT_LABEL (asm_out_file, end_label);
3791 }
3792
3793 static void
3794 end_sibling_chain ()
3795 {
3796   char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
3797
3798   current_dienum = NEXT_DIE_NUM;
3799   NEXT_DIE_NUM = next_unused_dienum;
3800
3801   sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum);
3802
3803   /* Write a label which will act as the name for the start of this DIE.  */
3804
3805   ASM_OUTPUT_LABEL (asm_out_file, begin_label);
3806
3807   /* Write the DIE-length word.  */
3808
3809   ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
3810
3811   dienum_pop ();
3812 }
3813 \f
3814 /* Generate a list of nameless TAG_formal_parameter DIEs (and perhaps a
3815    TAG_unspecified_parameters DIE) to represent the types of the formal
3816    parameters as specified in some function type specification (except
3817    for those which appear as part of a function *definition*).
3818
3819    Note that we must be careful here to output all of the parameter
3820    DIEs *before* we output any DIEs needed to represent the types of
3821    the formal parameters.  This keeps svr4 SDB happy because it
3822    (incorrectly) thinks that the first non-parameter DIE it sees ends
3823    the formal parameter list.  */
3824
3825 static void
3826 output_formal_types (function_or_method_type)
3827      register tree function_or_method_type;
3828 {
3829   register tree link;
3830   register tree formal_type = NULL;
3831   register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
3832
3833   /* In the case where we are generating a formal types list for a C++
3834      non-static member function type, skip over the first thing on the
3835      TYPE_ARG_TYPES list because it only represents the type of the
3836      hidden `this pointer'.  The debugger should be able to figure
3837      out (without being explicitly told) that this non-static member
3838      function type takes a `this pointer' and should be able to figure
3839      what the type of that hidden parameter is from the AT_member
3840      attribute of the parent TAG_subroutine_type DIE.  */
3841
3842   if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
3843     first_parm_type = TREE_CHAIN (first_parm_type);
3844
3845   /* Make our first pass over the list of formal parameter types and output
3846      a TAG_formal_parameter DIE for each one.  */
3847
3848   for (link = first_parm_type; link; link = TREE_CHAIN (link))
3849     {
3850       formal_type = TREE_VALUE (link);
3851       if (formal_type == void_type_node)
3852         break;
3853
3854       /* Output a (nameless) DIE to represent the formal parameter itself.  */
3855
3856       output_die (output_formal_parameter_die, formal_type);
3857     }
3858
3859   /* If this function type has an ellipsis, add a TAG_unspecified_parameters
3860      DIE to the end of the parameter list.  */
3861
3862   if (formal_type != void_type_node)
3863     output_die (output_unspecified_parameters_die, function_or_method_type);
3864
3865   /* Make our second (and final) pass over the list of formal parameter types
3866      and output DIEs to represent those types (as necessary).  */
3867
3868   for (link = TYPE_ARG_TYPES (function_or_method_type);
3869        link;
3870        link = TREE_CHAIN (link))
3871     {
3872       formal_type = TREE_VALUE (link);
3873       if (formal_type == void_type_node)
3874         break;
3875
3876       output_type (formal_type, function_or_method_type);
3877     }
3878 }
3879 \f
3880 /* Remember a type in the pending_types_list.  */
3881
3882 static void
3883 pend_type (type)
3884      register tree type;
3885 {
3886   if (pending_types == pending_types_allocated)
3887     {
3888       pending_types_allocated += PENDING_TYPES_INCREMENT;
3889       pending_types_list
3890         = (tree *) xrealloc (pending_types_list,
3891                              sizeof (tree) * pending_types_allocated);
3892     }
3893   pending_types_list[pending_types++] = type;
3894
3895   /* Mark the pending type as having been output already (even though
3896      it hasn't been).  This prevents the type from being added to the
3897      pending_types_list more than once.  */
3898
3899   TREE_ASM_WRITTEN (type) = 1;
3900 }
3901
3902 /* Return non-zero if it is legitimate to output DIEs to represent a
3903    given type while we are generating the list of child DIEs for some
3904    DIE (e.g. a function or lexical block DIE) associated with a given scope.
3905
3906    See the comments within the function for a description of when it is
3907    considered legitimate to output DIEs for various kinds of types.
3908
3909    Note that TYPE_CONTEXT(type) may be NULL (to indicate global scope)
3910    or it may point to a BLOCK node (for types local to a block), or to a
3911    FUNCTION_DECL node (for types local to the heading of some function
3912    definition), or to a FUNCTION_TYPE node (for types local to the
3913    prototyped parameter list of a function type specification), or to a
3914    RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node
3915    (in the case of C++ nested types).
3916
3917    The `scope' parameter should likewise be NULL or should point to a
3918    BLOCK node, a FUNCTION_DECL node, a FUNCTION_TYPE node, a RECORD_TYPE
3919    node, a UNION_TYPE node, or a QUAL_UNION_TYPE node.
3920
3921    This function is used only for deciding when to "pend" and when to
3922    "un-pend" types to/from the pending_types_list.
3923
3924    Note that we sometimes make use of this "type pending" feature in a
3925    rather twisted way to temporarily delay the production of DIEs for the
3926    types of formal parameters.  (We do this just to make svr4 SDB happy.)
3927    It order to delay the production of DIEs representing types of formal
3928    parameters, callers of this function supply `fake_containing_scope' as
3929    the `scope' parameter to this function.  Given that fake_containing_scope
3930    is a tagged type which is *not* the containing scope for *any* other type,
3931    the desired effect is achieved, i.e. output of DIEs representing types
3932    is temporarily suspended, and any type DIEs which would have otherwise
3933    been output are instead placed onto the pending_types_list.  Later on,
3934    we force these (temporarily pended) types to be output simply by calling
3935    `output_pending_types_for_scope' with an actual argument equal to the
3936    true scope of the types we temporarily pended.  */
3937
3938 static inline int
3939 type_ok_for_scope (type, scope)
3940     register tree type;
3941     register tree scope;
3942 {
3943   /* Tagged types (i.e. struct, union, and enum types) must always be
3944      output only in the scopes where they actually belong (or else the
3945      scoping of their own tag names and the scoping of their member
3946      names will be incorrect).  Non-tagged-types on the other hand can
3947      generally be output anywhere, except that svr4 SDB really doesn't
3948      want to see them nested within struct or union types, so here we
3949      say it is always OK to immediately output any such a (non-tagged)
3950      type, so long as we are not within such a context.  Note that the
3951      only kinds of non-tagged types which we will be dealing with here
3952      (for C and C++ anyway) will be array types and function types.  */
3953
3954   return is_tagged_type (type)
3955          ? (TYPE_CONTEXT (type) == scope)
3956          : (scope == NULL_TREE || ! is_tagged_type (scope));
3957 }
3958
3959 /* Output any pending types (from the pending_types list) which we can output
3960    now (taking into account the scope that we are working on now).
3961
3962    For each type output, remove the given type from the pending_types_list
3963    *before* we try to output it.
3964
3965    Note that we have to process the list in beginning-to-end order,
3966    because the call made here to output_type may cause yet more types
3967    to be added to the end of the list, and we may have to output some
3968    of them too.  */
3969
3970 static void
3971 output_pending_types_for_scope (containing_scope)
3972      register tree containing_scope;
3973 {
3974   register unsigned i;
3975
3976   for (i = 0; i < pending_types; )
3977     {
3978       register tree type = pending_types_list[i];
3979
3980       if (type_ok_for_scope (type, containing_scope))
3981         {
3982           register tree *mover;
3983           register tree *limit;
3984
3985           pending_types--;
3986           limit = &pending_types_list[pending_types];
3987           for (mover = &pending_types_list[i]; mover < limit; mover++)
3988             *mover = *(mover+1);
3989
3990           /* Un-mark the type as having been output already (because it
3991              hasn't been, really).  Then call output_type to generate a
3992              Dwarf representation of it.  */
3993
3994           TREE_ASM_WRITTEN (type) = 0;
3995           output_type (type, containing_scope);
3996
3997           /* Don't increment the loop counter in this case because we
3998              have shifted all of the subsequent pending types down one
3999              element in the pending_types_list array.  */
4000         }
4001       else
4002         i++;
4003     }
4004 }
4005
4006 static void
4007 output_type (type, containing_scope)
4008      register tree type;
4009      register tree containing_scope;
4010 {
4011   if (type == 0 || type == error_mark_node)
4012     return;
4013
4014   /* We are going to output a DIE to represent the unqualified version of
4015      of this type (i.e. without any const or volatile qualifiers) so get
4016      the main variant (i.e. the unqualified version) of this type now.  */
4017
4018   type = type_main_variant (type);
4019
4020   if (TREE_ASM_WRITTEN (type))
4021     return;
4022
4023   /* Don't generate any DIEs for this type now unless it is OK to do so
4024      (based upon what `type_ok_for_scope' tells us).  */
4025
4026   if (! type_ok_for_scope (type, containing_scope))
4027     {
4028       pend_type (type);
4029       return;
4030     }
4031
4032   switch (TREE_CODE (type))
4033     {
4034       case ERROR_MARK:
4035         break;
4036
4037       case POINTER_TYPE:
4038       case REFERENCE_TYPE:
4039         /* For these types, all that is required is that we output a DIE
4040            (or a set of DIEs) to represent the "basis" type.  */
4041         output_type (TREE_TYPE (type), containing_scope);
4042         break;
4043
4044       case OFFSET_TYPE:
4045         /* This code is used for C++ pointer-to-data-member types.  */
4046         /* Output a description of the relevant class type.  */
4047         output_type (TYPE_OFFSET_BASETYPE (type), containing_scope);
4048         /* Output a description of the type of the object pointed to.  */
4049         output_type (TREE_TYPE (type), containing_scope);
4050         /* Now output a DIE to represent this pointer-to-data-member type
4051            itself.  */
4052         output_die (output_ptr_to_mbr_type_die, type);
4053         break;
4054
4055       case SET_TYPE:
4056         output_type (TYPE_DOMAIN (type), containing_scope);
4057         output_die (output_set_type_die, type);
4058         break;
4059
4060       case FILE_TYPE:
4061         output_type (TREE_TYPE (type), containing_scope);
4062         abort ();       /* No way to represent these in Dwarf yet!  */
4063         break;
4064
4065       case FUNCTION_TYPE:
4066         /* Force out return type (in case it wasn't forced out already).  */
4067         output_type (TREE_TYPE (type), containing_scope);
4068         output_die (output_subroutine_type_die, type);
4069         output_formal_types (type);
4070         end_sibling_chain ();
4071         break;
4072
4073       case METHOD_TYPE:
4074         /* Force out return type (in case it wasn't forced out already).  */
4075         output_type (TREE_TYPE (type), containing_scope);
4076         output_die (output_subroutine_type_die, type);
4077         output_formal_types (type);
4078         end_sibling_chain ();
4079         break;
4080
4081       case ARRAY_TYPE:
4082         if (TYPE_STRING_FLAG (type) && TREE_CODE(TREE_TYPE(type)) == CHAR_TYPE)
4083           {
4084             output_type (TREE_TYPE (type), containing_scope);
4085             output_die (output_string_type_die, type);
4086           }
4087         else
4088           {
4089             register tree element_type;
4090
4091             element_type = TREE_TYPE (type);
4092             while (TREE_CODE (element_type) == ARRAY_TYPE)
4093               element_type = TREE_TYPE (element_type);
4094
4095             output_type (element_type, containing_scope);
4096             output_die (output_array_type_die, type);
4097           }
4098         break;
4099
4100       case ENUMERAL_TYPE:
4101       case RECORD_TYPE:
4102       case UNION_TYPE:
4103       case QUAL_UNION_TYPE:
4104
4105         /* For a non-file-scope tagged type, we can always go ahead and
4106            output a Dwarf description of this type right now, even if
4107            the type in question is still incomplete, because if this
4108            local type *was* ever completed anywhere within its scope,
4109            that complete definition would already have been attached to
4110            this RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
4111            node by the time we reach this point.  That's true because of the
4112            way the front-end does its processing of file-scope declarations (of
4113            functions and class types) within which other types might be
4114            nested.  The C and C++ front-ends always gobble up such "local
4115            scope" things en-mass before they try to output *any* debugging
4116            information for any of the stuff contained inside them and thus,
4117            we get the benefit here of what is (in effect) a pre-resolution
4118            of forward references to tagged types in local scopes.
4119
4120            Note however that for file-scope tagged types we cannot assume
4121            that such pre-resolution of forward references has taken place.
4122            A given file-scope tagged type may appear to be incomplete when
4123            we reach this point, but it may yet be given a full definition
4124            (at file-scope) later on during compilation.  In order to avoid
4125            generating a premature (and possibly incorrect) set of Dwarf
4126            DIEs for such (as yet incomplete) file-scope tagged types, we
4127            generate nothing at all for as-yet incomplete file-scope tagged
4128            types here unless we are making our special "finalization" pass
4129            for file-scope things at the very end of compilation.  At that
4130            time, we will certainly know as much about each file-scope tagged
4131            type as we are ever going to know, so at that point in time, we
4132            can safely generate correct Dwarf descriptions for these file-
4133            scope tagged types.
4134
4135            This loses for C++ nested types that are defined after their
4136            containing class, but I don't see a good way to fix it.  I doubt
4137            many people will be using DWARF 1 for C++ in any case.  */
4138
4139         if (TYPE_SIZE (type) == 0 && TYPE_CONTEXT (type) == NULL && !finalizing)
4140           return;       /* EARLY EXIT!  Avoid setting TREE_ASM_WRITTEN.  */
4141
4142         /* Prevent infinite recursion in cases where the type of some
4143            member of this type is expressed in terms of this type itself.  */
4144
4145         TREE_ASM_WRITTEN (type) = 1;
4146
4147         /* Output a DIE to represent the tagged type itself.  */
4148
4149         switch (TREE_CODE (type))
4150           {
4151           case ENUMERAL_TYPE:
4152             output_die (output_enumeration_type_die, type);
4153             return;  /* a special case -- nothing left to do so just return */
4154
4155           case RECORD_TYPE:
4156             output_die (output_structure_type_die, type);
4157             break;
4158
4159           case UNION_TYPE:
4160           case QUAL_UNION_TYPE:
4161             output_die (output_union_type_die, type);
4162             break;
4163
4164           default:
4165             abort ();   /* Should never happen.  */
4166           }
4167
4168         /* If this is not an incomplete type, output descriptions of
4169            each of its members.
4170
4171            Note that as we output the DIEs necessary to represent the
4172            members of this record or union type, we will also be trying
4173            to output DIEs to represent the *types* of those members.
4174            However the `output_type' function (above) will specifically
4175            avoid generating type DIEs for member types *within* the list
4176            of member DIEs for this (containing) type execpt for those
4177            types (of members) which are explicitly marked as also being
4178            members of this (containing) type themselves.  The g++ front-
4179            end can force any given type to be treated as a member of some
4180            other (containing) type by setting the TYPE_CONTEXT of the
4181            given (member) type to point to the TREE node representing the
4182            appropriate (containing) type.
4183         */
4184
4185         if (TYPE_SIZE (type))
4186           {
4187             {
4188               register tree normal_member;
4189
4190               /* First output info about the data members and type members.  */
4191
4192               for (normal_member = TYPE_FIELDS (type);
4193                    normal_member;
4194                    normal_member = TREE_CHAIN (normal_member))
4195                 output_decl (normal_member, type);
4196             }
4197
4198             {
4199               register tree func_member;
4200
4201               /* Now output info about the function members (if any).  */
4202
4203               for (func_member = TYPE_METHODS (type);
4204                    func_member;
4205                    func_member = TREE_CHAIN (func_member))
4206                 output_decl (func_member, type);
4207             }
4208
4209             /* RECORD_TYPEs, UNION_TYPEs, and QUAL_UNION_TYPEs are themselves
4210                scopes (at least in C++) so we must now output any nested
4211                pending types which are local just to this type.  */
4212
4213             output_pending_types_for_scope (type);
4214
4215             end_sibling_chain ();       /* Terminate member chain.  */
4216           }
4217
4218         break;
4219
4220       case VOID_TYPE:
4221       case INTEGER_TYPE:
4222       case REAL_TYPE:
4223       case COMPLEX_TYPE:
4224       case BOOLEAN_TYPE:
4225       case CHAR_TYPE:
4226         break;          /* No DIEs needed for fundamental types.  */
4227
4228       case LANG_TYPE:   /* No Dwarf representation currently defined.  */
4229         break;
4230
4231       default:
4232         abort ();
4233     }
4234
4235   TREE_ASM_WRITTEN (type) = 1;
4236 }
4237
4238 static void
4239 output_tagged_type_instantiation (type)
4240      register tree type;
4241 {
4242   if (type == 0 || type == error_mark_node)
4243     return;
4244
4245   /* We are going to output a DIE to represent the unqualified version of
4246      of this type (i.e. without any const or volatile qualifiers) so make
4247      sure that we have the main variant (i.e. the unqualified version) of
4248      this type now.  */
4249
4250   assert (type == type_main_variant (type));
4251
4252   assert (TREE_ASM_WRITTEN (type));
4253
4254   switch (TREE_CODE (type))
4255     {
4256       case ERROR_MARK:
4257         break;
4258
4259       case ENUMERAL_TYPE:
4260         output_die (output_inlined_enumeration_type_die, type);
4261         break;
4262
4263       case RECORD_TYPE:
4264         output_die (output_inlined_structure_type_die, type);
4265         break;
4266
4267       case UNION_TYPE:
4268       case QUAL_UNION_TYPE:
4269         output_die (output_inlined_union_type_die, type);
4270         break;
4271
4272       default:
4273         abort ();       /* Should never happen.  */
4274     }
4275 }
4276 \f
4277 /* Output a TAG_lexical_block DIE followed by DIEs to represent all of
4278    the things which are local to the given block.  */
4279
4280 static void
4281 output_block (stmt, depth)
4282     register tree stmt;
4283     int depth;
4284 {
4285   register int must_output_die = 0;
4286   register tree origin;
4287   register enum tree_code origin_code;
4288
4289   /* Ignore blocks never really used to make RTL.  */
4290
4291   if (! stmt || ! TREE_USED (stmt))
4292     return;
4293
4294   /* Determine the "ultimate origin" of this block.  This block may be an
4295      inlined instance of an inlined instance of inline function, so we
4296      have to trace all of the way back through the origin chain to find
4297      out what sort of node actually served as the original seed for the
4298      creation of the current block.  */
4299
4300   origin = block_ultimate_origin (stmt);
4301   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
4302
4303   /* Determine if we need to output any Dwarf DIEs at all to represent this
4304      block.  */
4305
4306   if (origin_code == FUNCTION_DECL)
4307     /* The outer scopes for inlinings *must* always be represented.  We
4308        generate TAG_inlined_subroutine DIEs for them.  (See below.)  */
4309     must_output_die = 1;
4310   else
4311     {
4312       /* In the case where the current block represents an inlining of the
4313          "body block" of an inline function, we must *NOT* output any DIE
4314          for this block because we have already output a DIE to represent
4315          the whole inlined function scope and the "body block" of any
4316          function doesn't really represent a different scope according to
4317          ANSI C rules.  So we check here to make sure that this block does
4318          not represent a "body block inlining" before trying to set the
4319          `must_output_die' flag.  */
4320
4321       if (! is_body_block (origin ? origin : stmt))
4322         {
4323           /* Determine if this block directly contains any "significant"
4324              local declarations which we will need to output DIEs for.  */
4325
4326           if (debug_info_level > DINFO_LEVEL_TERSE)
4327             /* We are not in terse mode so *any* local declaration counts
4328                as being a "significant" one.  */
4329             must_output_die = (BLOCK_VARS (stmt) != NULL);
4330           else
4331             {
4332               register tree decl;
4333
4334               /* We are in terse mode, so only local (nested) function
4335                  definitions count as "significant" local declarations.  */
4336
4337               for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl))
4338                 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4339                   {
4340                     must_output_die = 1;
4341                     break;
4342                   }
4343             }
4344         }
4345     }
4346
4347   /* It would be a waste of space to generate a Dwarf TAG_lexical_block
4348      DIE for any block which contains no significant local declarations
4349      at all.  Rather, in such cases we just call `output_decls_for_scope'
4350      so that any needed Dwarf info for any sub-blocks will get properly
4351      generated.  Note that in terse mode, our definition of what constitutes
4352      a "significant" local declaration gets restricted to include only
4353      inlined function instances and local (nested) function definitions.  */
4354
4355   if (origin_code == FUNCTION_DECL && BLOCK_ABSTRACT (stmt))
4356     /* We don't care about an abstract inlined subroutine.  */;
4357   else if (must_output_die)
4358     {
4359       output_die ((origin_code == FUNCTION_DECL)
4360                     ? output_inlined_subroutine_die
4361                     : output_lexical_block_die,
4362                   stmt);
4363       output_decls_for_scope (stmt, depth);
4364       end_sibling_chain ();
4365     }
4366   else
4367     output_decls_for_scope (stmt, depth);
4368 }
4369
4370 /* Output all of the decls declared within a given scope (also called
4371    a `binding contour') and (recursively) all of it's sub-blocks.  */
4372
4373 static void
4374 output_decls_for_scope (stmt, depth)
4375      register tree stmt;
4376      int depth;
4377 {
4378   /* Ignore blocks never really used to make RTL.  */
4379
4380   if (! stmt || ! TREE_USED (stmt))
4381     return;
4382
4383   if (! BLOCK_ABSTRACT (stmt) && depth > 0)
4384     next_block_number++;
4385
4386   /* Output the DIEs to represent all of the data objects, functions,
4387      typedefs, and tagged types declared directly within this block
4388      but not within any nested sub-blocks.  */
4389
4390   {
4391     register tree decl;
4392
4393     for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl))
4394       output_decl (decl, stmt);
4395   }
4396
4397   output_pending_types_for_scope (stmt);
4398
4399   /* Output the DIEs to represent all sub-blocks (and the items declared
4400      therein) of this block.     */
4401
4402   {
4403     register tree subblocks;
4404
4405     for (subblocks = BLOCK_SUBBLOCKS (stmt);
4406          subblocks;
4407          subblocks = BLOCK_CHAIN (subblocks))
4408       output_block (subblocks, depth + 1);
4409   }
4410 }
4411
4412 /* Output Dwarf .debug information for a decl described by DECL.  */
4413
4414 static void
4415 output_decl (decl, containing_scope)
4416      register tree decl;
4417      register tree containing_scope;
4418 {
4419   /* Make a note of the decl node we are going to be working on.  We may
4420      need to give the user the source coordinates of where it appeared in
4421      case we notice (later on) that something about it looks screwy.  */
4422
4423   dwarf_last_decl = decl;
4424
4425   if (TREE_CODE (decl) == ERROR_MARK)
4426     return;
4427
4428   /* If a structure is declared within an initialization, e.g. as the
4429      operand of a sizeof, then it will not have a name.  We don't want
4430      to output a DIE for it, as the tree nodes are in the temporary obstack */
4431
4432   if ((TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4433        || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
4434       && ((DECL_NAME (decl) == 0 && TYPE_NAME (TREE_TYPE (decl)) == 0)
4435           || (TYPE_FIELDS (TREE_TYPE (decl))
4436               && (TREE_CODE (TYPE_FIELDS (TREE_TYPE (decl))) == ERROR_MARK))))
4437     return;
4438
4439   /* If this ..._DECL node is marked to be ignored, then ignore it.
4440      But don't ignore a function definition, since that would screw
4441      up our count of blocks, and that it turn will completely screw up the
4442      the labels we will reference in subsequent AT_low_pc and AT_high_pc
4443      attributes (for subsequent blocks).  */
4444
4445   if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
4446     return;
4447
4448   switch (TREE_CODE (decl))
4449     {
4450     case CONST_DECL:
4451       /* The individual enumerators of an enum type get output when we
4452          output the Dwarf representation of the relevant enum type itself.  */
4453       break;
4454
4455     case FUNCTION_DECL:
4456       /* If we are in terse mode, don't output any DIEs to represent
4457          mere function declarations.  Also, if we are conforming
4458          to the DWARF version 1 specification, don't output DIEs for
4459          mere function declarations.  */
4460
4461       if (DECL_INITIAL (decl) == NULL_TREE)
4462 #if (DWARF_VERSION > 1)
4463         if (debug_info_level <= DINFO_LEVEL_TERSE)
4464 #endif
4465           break;
4466
4467       /* Before we describe the FUNCTION_DECL itself, make sure that we
4468          have described its return type.  */
4469
4470       output_type (TREE_TYPE (TREE_TYPE (decl)), containing_scope);
4471
4472       /* If the following DIE will represent a function definition for a
4473          function with "extern" linkage, output a special "pubnames" DIE
4474          label just ahead of the actual DIE.  A reference to this label
4475          was already generated in the .debug_pubnames section sub-entry
4476          for this function definition.  */
4477
4478       if (TREE_PUBLIC (decl))
4479         {
4480           char label[MAX_ARTIFICIAL_LABEL_BYTES];
4481
4482           sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++);
4483           ASM_OUTPUT_LABEL (asm_out_file, label);
4484         }
4485
4486       /* Now output a DIE to represent the function itself.  */
4487
4488       output_die (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)
4489                                 ? output_global_subroutine_die
4490                                 : output_local_subroutine_die,
4491                   decl);
4492
4493       /* Now output descriptions of the arguments for this function.
4494          This gets (unnecessarily?) complex because of the fact that
4495          the DECL_ARGUMENT list for a FUNCTION_DECL doesn't indicate
4496          cases where there was a trailing `...' at the end of the formal
4497          parameter list.  In order to find out if there was a trailing
4498          ellipsis or not, we must instead look at the type associated
4499          with the FUNCTION_DECL.  This will be a node of type FUNCTION_TYPE.
4500          If the chain of type nodes hanging off of this FUNCTION_TYPE node
4501          ends with a void_type_node then there should *not* be an ellipsis
4502          at the end.  */
4503
4504       /* In the case where we are describing a mere function declaration, all
4505          we need to do here (and all we *can* do here) is to describe
4506          the *types* of its formal parameters.  */
4507
4508       if (DECL_INITIAL (decl) == NULL_TREE)
4509         output_formal_types (TREE_TYPE (decl));
4510       else
4511         {
4512           /* Generate DIEs to represent all known formal parameters */
4513
4514           register tree arg_decls = DECL_ARGUMENTS (decl);
4515           register tree parm;
4516
4517           /* WARNING!  Kludge zone ahead!  Here we have a special
4518              hack for svr4 SDB compatibility.  Instead of passing the
4519              current FUNCTION_DECL node as the second parameter (i.e.
4520              the `containing_scope' parameter) to `output_decl' (as
4521              we ought to) we instead pass a pointer to our own private
4522              fake_containing_scope node.  That node is a RECORD_TYPE
4523              node which NO OTHER TYPE may ever actually be a member of.
4524
4525              This pointer will ultimately get passed into `output_type'
4526              as its `containing_scope' parameter.  `Output_type' will
4527              then perform its part in the hack... i.e. it will pend
4528              the type of the formal parameter onto the pending_types
4529              list.  Later on, when we are done generating the whole
4530              sequence of formal parameter DIEs for this function
4531              definition, we will un-pend all previously pended types
4532              of formal parameters for this function definition.
4533
4534              This whole kludge prevents any type DIEs from being
4535              mixed in with the formal parameter DIEs.  That's good
4536              because svr4 SDB believes that the list of formal
4537              parameter DIEs for a function ends wherever the first
4538              non-formal-parameter DIE appears.  Thus, we have to
4539              keep the formal parameter DIEs segregated.  They must
4540              all appear (consecutively) at the start of the list of
4541              children for the DIE representing the function definition.
4542              Then (and only then) may we output any additional DIEs
4543              needed to represent the types of these formal parameters.
4544           */
4545
4546           /*
4547              When generating DIEs, generate the unspecified_parameters
4548              DIE instead if we come across the arg "__builtin_va_alist"
4549           */
4550
4551           for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
4552             if (TREE_CODE (parm) == PARM_DECL)
4553               {
4554                 if (DECL_NAME(parm) &&
4555                     !strcmp(IDENTIFIER_POINTER(DECL_NAME(parm)),
4556                             "__builtin_va_alist") )
4557                   output_die (output_unspecified_parameters_die, decl);
4558                 else
4559                   output_decl (parm, fake_containing_scope);
4560               }
4561
4562           /*
4563              Now that we have finished generating all of the DIEs to
4564              represent the formal parameters themselves, force out
4565              any DIEs needed to represent their types.  We do this
4566              simply by un-pending all previously pended types which
4567              can legitimately go into the chain of children DIEs for
4568              the current FUNCTION_DECL.
4569           */
4570
4571           output_pending_types_for_scope (decl);
4572
4573           /*
4574             Decide whether we need a unspecified_parameters DIE at the end.
4575             There are 2 more cases to do this for:
4576             1) the ansi ... declaration - this is detectable when the end
4577                 of the arg list is not a void_type_node
4578             2) an unprototyped function declaration (not a definition).  This
4579                 just means that we have no info about the parameters at all.
4580           */
4581
4582           {
4583             register tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
4584
4585             if (fn_arg_types)
4586               {
4587               /* this is the prototyped case, check for ...  */
4588               if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
4589                 output_die (output_unspecified_parameters_die, decl);
4590               }
4591             else
4592               {
4593               /* this is unprototyped, check for undefined (just declaration) */
4594               if (!DECL_INITIAL (decl))
4595                 output_die (output_unspecified_parameters_die, decl);
4596               }
4597           }
4598         }
4599
4600       /* Output Dwarf info for all of the stuff within the body of the
4601          function (if it has one - it may be just a declaration).  */
4602
4603       {
4604         register tree outer_scope = DECL_INITIAL (decl);
4605
4606         if (outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
4607           {
4608             /* Note that here, `outer_scope' is a pointer to the outermost
4609                BLOCK node created to represent a function.
4610                This outermost BLOCK actually represents the outermost
4611                binding contour for the function, i.e. the contour in which
4612                the function's formal parameters and labels get declared.
4613
4614                Curiously, it appears that the front end doesn't actually
4615                put the PARM_DECL nodes for the current function onto the
4616                BLOCK_VARS list for this outer scope.  (They are strung
4617                off of the DECL_ARGUMENTS list for the function instead.)
4618                The BLOCK_VARS list for the `outer_scope' does provide us
4619                with a list of the LABEL_DECL nodes for the function however,
4620                and we output DWARF info for those here.
4621
4622                Just within the `outer_scope' there will be a BLOCK node
4623                representing the function's outermost pair of curly braces,
4624                and any blocks used for the base and member initializers of
4625                a C++ constructor function.  */
4626
4627             output_decls_for_scope (outer_scope, 0);
4628
4629             /* Finally, force out any pending types which are local to the
4630                outermost block of this function definition.  These will
4631                all have a TYPE_CONTEXT which points to the FUNCTION_DECL
4632                node itself.  */
4633
4634             output_pending_types_for_scope (decl);
4635           }
4636       }
4637
4638       /* Generate a terminator for the list of stuff `owned' by this
4639          function.  */
4640
4641       end_sibling_chain ();
4642
4643       break;
4644
4645     case TYPE_DECL:
4646       /* If we are in terse mode, don't generate any DIEs to represent
4647          any actual typedefs.  Note that even when we are in terse mode,
4648          we must still output DIEs to represent those tagged types which
4649          are used (directly or indirectly) in the specification of either
4650          a return type or a formal parameter type of some function.  */
4651
4652       if (debug_info_level <= DINFO_LEVEL_TERSE)
4653         if (DECL_NAME (decl) != NULL
4654             || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)))
4655           return;
4656
4657       /* In the special case of a null-named TYPE_DECL node (representing
4658          the declaration of some type tag), if the given TYPE_DECL is
4659          marked as having been instantiated from some other (original)
4660          TYPE_DECL node (e.g. one which was generated within the original
4661          definition of an inline function) we have to generate a special
4662          (abbreviated) TAG_structure_type, TAG_union_type, or
4663          TAG_enumeration-type DIE here.  */
4664
4665       if (! DECL_NAME (decl) && DECL_ABSTRACT_ORIGIN (decl))
4666         {
4667           output_tagged_type_instantiation (TREE_TYPE (decl));
4668           return;
4669         }
4670
4671       output_type (TREE_TYPE (decl), containing_scope);
4672
4673       /* Note that unlike the gcc front end (which generates a NULL named
4674          TYPE_DECL node for each complete tagged type, each array type,
4675          and each function type node created) the g++ front end generates
4676          a *named* TYPE_DECL node for each tagged type node created.
4677          These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
4678          generate a DW_TAG_typedef DIE for them.  */
4679       if (DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
4680         /* Output a DIE to represent the typedef itself.  */
4681         output_die (output_typedef_die, decl);
4682       break;
4683
4684     case LABEL_DECL:
4685       if (debug_info_level >= DINFO_LEVEL_NORMAL)
4686         output_die (output_label_die, decl);
4687       break;
4688
4689     case VAR_DECL:
4690       /* If we are conforming to the DWARF version 1 specification, don't
4691          generated any DIEs to represent mere external object declarations.  */
4692
4693 #if (DWARF_VERSION <= 1)
4694       if (DECL_EXTERNAL (decl) && ! TREE_PUBLIC (decl))
4695         break;
4696 #endif
4697
4698       /* If we are in terse mode, don't generate any DIEs to represent
4699          any variable declarations or definitions.  */
4700
4701       if (debug_info_level <= DINFO_LEVEL_TERSE)
4702         break;
4703
4704       /* Output any DIEs that are needed to specify the type of this data
4705          object.  */
4706
4707       output_type (TREE_TYPE (decl), containing_scope);
4708
4709       /* If the following DIE will represent a data object definition for a
4710          data object with "extern" linkage, output a special "pubnames" DIE
4711          label just ahead of the actual DIE.  A reference to this label
4712          was already generated in the .debug_pubnames section sub-entry
4713          for this data object definition.  */
4714
4715       if (TREE_PUBLIC (decl) && ! DECL_ABSTRACT (decl))
4716         {
4717           char label[MAX_ARTIFICIAL_LABEL_BYTES];
4718
4719           sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++);
4720           ASM_OUTPUT_LABEL (asm_out_file, label);
4721         }
4722
4723       /* Now output the DIE to represent the data object itself.  This gets
4724          complicated because of the possibility that the VAR_DECL really
4725          represents an inlined instance of a formal parameter for an inline
4726          function.  */
4727
4728       {
4729         register void (*func) ();
4730         register tree origin = decl_ultimate_origin (decl);
4731
4732         if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
4733           func = output_formal_parameter_die;
4734         else
4735           {
4736             if (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
4737               func = output_global_variable_die;
4738             else
4739               func = output_local_variable_die;
4740           }
4741         output_die (func, decl);
4742       }
4743       break;
4744
4745     case FIELD_DECL:
4746       /* Ignore the nameless fields that are used to skip bits.  */
4747       if (DECL_NAME (decl) != 0)
4748         {
4749           output_type (member_declared_type (decl), containing_scope);
4750           output_die (output_member_die, decl);
4751         }
4752       break;
4753
4754     case PARM_DECL:
4755      /* Force out the type of this formal, if it was not forced out yet.
4756         Note that here we can run afowl of a bug in "classic" svr4 SDB.
4757         It should be able to grok the presence of type DIEs within a list
4758         of TAG_formal_parameter DIEs, but it doesn't.  */
4759
4760       output_type (TREE_TYPE (decl), containing_scope);
4761       output_die (output_formal_parameter_die, decl);
4762       break;
4763
4764     default:
4765       abort ();
4766     }
4767 }
4768 \f
4769 void
4770 dwarfout_file_scope_decl (decl, set_finalizing)
4771      register tree decl;
4772      register int set_finalizing;
4773 {
4774   if (TREE_CODE (decl) == ERROR_MARK)
4775     return;
4776
4777   /* If this ..._DECL node is marked to be ignored, then ignore it.  We
4778      gotta hope that the node in question doesn't represent a function
4779      definition.  If it does, then totally ignoring it is bound to screw
4780      up our count of blocks, and that it turn will completely screw up the
4781      the labels we will reference in subsequent AT_low_pc and AT_high_pc
4782      attributes (for subsequent blocks).  (It's too bad that BLOCK nodes
4783      don't carry their own sequence numbers with them!)  */
4784
4785   if (DECL_IGNORED_P (decl))
4786     {
4787       if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL)
4788         abort ();
4789       return;
4790     }
4791
4792   switch (TREE_CODE (decl))
4793     {
4794     case FUNCTION_DECL:
4795
4796       /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of
4797          a builtin function.  Explicit programmer-supplied declarations of
4798          these same functions should NOT be ignored however.  */
4799
4800       if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
4801         return;
4802
4803       /* What we would really like to do here is to filter out all mere
4804          file-scope declarations of file-scope functions which are never
4805          referenced later within this translation unit (and keep all of
4806          ones that *are* referenced later on) but we aren't clairvoyant,
4807          so we have no idea which functions will be referenced in the
4808          future (i.e. later on within the current translation unit).
4809          So here we just ignore all file-scope function declarations
4810          which are not also definitions.  If and when the debugger needs
4811          to know something about these functions, it wil have to hunt
4812          around and find the DWARF information associated with the
4813          *definition* of the function.
4814
4815          Note that we can't just check `DECL_EXTERNAL' to find out which
4816          FUNCTION_DECL nodes represent definitions and which ones represent
4817          mere declarations.  We have to check `DECL_INITIAL' instead.  That's
4818          because the C front-end supports some weird semantics for "extern
4819          inline" function definitions.  These can get inlined within the
4820          current translation unit (an thus, we need to generate DWARF info
4821          for their abstract instances so that the DWARF info for the
4822          concrete inlined instances can have something to refer to) but
4823          the compiler never generates any out-of-lines instances of such
4824          things (despite the fact that they *are* definitions).  The
4825          important point is that the C front-end marks these "extern inline"
4826          functions as DECL_EXTERNAL, but we need to generate DWARF for them
4827          anyway.
4828
4829          Note that the C++ front-end also plays some similar games for inline
4830          function definitions appearing within include files which also
4831          contain `#pragma interface' pragmas.  */
4832
4833       if (DECL_INITIAL (decl) == NULL_TREE)
4834         return;
4835
4836       if (TREE_PUBLIC (decl)
4837           && ! DECL_EXTERNAL (decl)
4838           && ! DECL_ABSTRACT (decl))
4839         {
4840           char label[MAX_ARTIFICIAL_LABEL_BYTES];
4841
4842           /* Output a .debug_pubnames entry for a public function
4843              defined in this compilation unit.  */
4844
4845           fputc ('\n', asm_out_file);
4846           ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION);
4847           sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number);
4848           ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
4849           ASM_OUTPUT_DWARF_STRING (asm_out_file,
4850                                    IDENTIFIER_POINTER (DECL_NAME (decl)));
4851           ASM_OUTPUT_POP_SECTION (asm_out_file);
4852         }
4853
4854       break;
4855
4856     case VAR_DECL:
4857
4858       /* Ignore this VAR_DECL if it refers to a file-scope extern data
4859          object declaration and if the declaration was never even
4860          referenced from within this entire compilation unit.  We
4861          suppress these DIEs in order to save space in the .debug section
4862          (by eliminating entries which are probably useless).  Note that
4863          we must not suppress block-local extern declarations (whether
4864          used or not) because that would screw-up the debugger's name
4865          lookup mechanism and cause it to miss things which really ought
4866          to be in scope at a given point.  */
4867
4868       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
4869         return;
4870
4871       if (TREE_PUBLIC (decl)
4872           && ! DECL_EXTERNAL (decl)
4873           && GET_CODE (DECL_RTL (decl)) == MEM
4874           && ! DECL_ABSTRACT (decl))
4875         {
4876           char label[MAX_ARTIFICIAL_LABEL_BYTES];
4877
4878           if (debug_info_level >= DINFO_LEVEL_NORMAL)
4879             {
4880               /* Output a .debug_pubnames entry for a public variable
4881                  defined in this compilation unit.  */
4882
4883               fputc ('\n', asm_out_file);
4884               ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION);
4885               sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number);
4886               ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
4887               ASM_OUTPUT_DWARF_STRING (asm_out_file,
4888                                        IDENTIFIER_POINTER (DECL_NAME (decl)));
4889               ASM_OUTPUT_POP_SECTION (asm_out_file);
4890             }
4891
4892           if (DECL_INITIAL (decl) == NULL)
4893             {
4894               /* Output a .debug_aranges entry for a public variable
4895                  which is tentatively defined in this compilation unit.  */
4896
4897               fputc ('\n', asm_out_file);
4898               ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION);
4899               ASM_OUTPUT_DWARF_ADDR (asm_out_file,
4900                               IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4901               ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
4902                         (unsigned) int_size_in_bytes (TREE_TYPE (decl)));
4903               ASM_OUTPUT_POP_SECTION (asm_out_file);
4904             }
4905         }
4906
4907       /* If we are in terse mode, don't generate any DIEs to represent
4908          any variable declarations or definitions.  */
4909
4910       if (debug_info_level <= DINFO_LEVEL_TERSE)
4911         return;
4912
4913       break;
4914
4915     case TYPE_DECL:
4916       /* Don't bother trying to generate any DIEs to represent any of the
4917          normal built-in types for the language we are compiling, except
4918          in cases where the types in question are *not* DWARF fundamental
4919          types.  We make an exception in the case of non-fundamental types
4920          for the sake of objective C (and perhaps C++) because the GNU
4921          front-ends for these languages may in fact create certain "built-in"
4922          types which are (for example) RECORD_TYPEs.  In such cases, we
4923          really need to output these (non-fundamental) types because other
4924          DIEs may contain references to them.  */
4925
4926       if (DECL_SOURCE_LINE (decl) == 0
4927           && type_is_fundamental (TREE_TYPE (decl)))
4928         return;
4929
4930       /* If we are in terse mode, don't generate any DIEs to represent
4931          any actual typedefs.  Note that even when we are in terse mode,
4932          we must still output DIEs to represent those tagged types which
4933          are used (directly or indirectly) in the specification of either
4934          a return type or a formal parameter type of some function.  */
4935
4936       if (debug_info_level <= DINFO_LEVEL_TERSE)
4937         if (DECL_NAME (decl) != NULL
4938             || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)))
4939           return;
4940
4941       break;
4942
4943     default:
4944       return;
4945     }
4946
4947   fputc ('\n', asm_out_file);
4948   ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
4949   finalizing = set_finalizing;
4950   output_decl (decl, NULL_TREE);
4951
4952   /* NOTE:  The call above to `output_decl' may have caused one or more
4953      file-scope named types (i.e. tagged types) to be placed onto the
4954      pending_types_list.  We have to get those types off of that list
4955      at some point, and this is the perfect time to do it.  If we didn't
4956      take them off now, they might still be on the list when cc1 finally
4957      exits.  That might be OK if it weren't for the fact that when we put
4958      types onto the pending_types_list, we set the TREE_ASM_WRITTEN flag
4959      for these types, and that causes them never to be output unless
4960      `output_pending_types_for_scope' takes them off of the list and un-sets
4961      their TREE_ASM_WRITTEN flags.  */
4962
4963   output_pending_types_for_scope (NULL_TREE);
4964
4965   /* The above call should have totally emptied the pending_types_list.  */
4966
4967   assert (pending_types == 0);
4968
4969   ASM_OUTPUT_POP_SECTION (asm_out_file);
4970
4971   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL)
4972     current_funcdef_number++;
4973 }
4974 \f
4975 /* Output a marker (i.e. a label) for the beginning of the generated code
4976    for a lexical block.  */
4977
4978 void
4979 dwarfout_begin_block (blocknum)
4980      register unsigned blocknum;
4981 {
4982   char label[MAX_ARTIFICIAL_LABEL_BYTES];
4983
4984   function_section (current_function_decl);
4985   sprintf (label, BLOCK_BEGIN_LABEL_FMT, blocknum);
4986   ASM_OUTPUT_LABEL (asm_out_file, label);
4987 }
4988
4989 /* Output a marker (i.e. a label) for the end of the generated code
4990    for a lexical block.  */
4991
4992 void
4993 dwarfout_end_block (blocknum)
4994      register unsigned blocknum;
4995 {
4996   char label[MAX_ARTIFICIAL_LABEL_BYTES];
4997
4998   function_section (current_function_decl);
4999   sprintf (label, BLOCK_END_LABEL_FMT, blocknum);
5000   ASM_OUTPUT_LABEL (asm_out_file, label);
5001 }
5002
5003 /* Output a marker (i.e. a label) at a point in the assembly code which
5004    corresponds to a given source level label.  */
5005
5006 void
5007 dwarfout_label (insn)
5008      register rtx insn;
5009 {
5010   if (debug_info_level >= DINFO_LEVEL_NORMAL)
5011     {
5012       char label[MAX_ARTIFICIAL_LABEL_BYTES];
5013
5014       function_section (current_function_decl);
5015       sprintf (label, INSN_LABEL_FMT, current_funcdef_number,
5016                                       (unsigned) INSN_UID (insn));
5017       ASM_OUTPUT_LABEL (asm_out_file, label);
5018     }
5019 }
5020
5021 /* Output a marker (i.e. a label) for the point in the generated code where
5022    the real body of the function begins (after parameters have been moved
5023    to their home locations).  */
5024
5025 void
5026 dwarfout_begin_function ()
5027 {
5028   char label[MAX_ARTIFICIAL_LABEL_BYTES];
5029
5030   function_section (current_function_decl);
5031   sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
5032   ASM_OUTPUT_LABEL (asm_out_file, label);
5033 }
5034
5035 /* Output a marker (i.e. a label) for the point in the generated code where
5036    the real body of the function ends (just before the epilogue code).  */
5037
5038 void
5039 dwarfout_end_function ()
5040 {
5041   char label[MAX_ARTIFICIAL_LABEL_BYTES];
5042
5043   function_section (current_function_decl);
5044   sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
5045   ASM_OUTPUT_LABEL (asm_out_file, label);
5046 }
5047
5048 /* Output a marker (i.e. a label) for the absolute end of the generated code
5049    for a function definition.  This gets called *after* the epilogue code
5050    has been generated.  */
5051
5052 void
5053 dwarfout_end_epilogue ()
5054 {
5055   char label[MAX_ARTIFICIAL_LABEL_BYTES];
5056
5057   /* Output a label to mark the endpoint of the code generated for this
5058      function.  */
5059
5060   sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
5061   ASM_OUTPUT_LABEL (asm_out_file, label);
5062 }
5063
5064 static void
5065 shuffle_filename_entry (new_zeroth)
5066      register filename_entry *new_zeroth;
5067 {
5068   filename_entry temp_entry;
5069   register filename_entry *limit_p;
5070   register filename_entry *move_p;
5071
5072   if (new_zeroth == &filename_table[0])
5073     return;
5074
5075   temp_entry = *new_zeroth;
5076
5077   /* Shift entries up in the table to make room at [0].  */
5078
5079   limit_p = &filename_table[0];
5080   for (move_p = new_zeroth; move_p > limit_p; move_p--)
5081     *move_p = *(move_p-1);
5082
5083   /* Install the found entry at [0].  */
5084
5085   filename_table[0] = temp_entry;
5086 }
5087
5088 /* Create a new (string) entry for the .debug_sfnames section.  */
5089
5090 static void
5091 generate_new_sfname_entry ()
5092 {
5093   char label[MAX_ARTIFICIAL_LABEL_BYTES];
5094
5095   fputc ('\n', asm_out_file);
5096   ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION);
5097   sprintf (label, SFNAMES_ENTRY_LABEL_FMT, filename_table[0].number);
5098   ASM_OUTPUT_LABEL (asm_out_file, label);
5099   ASM_OUTPUT_DWARF_STRING (asm_out_file,
5100                            filename_table[0].name
5101                              ? filename_table[0].name
5102                              : "");
5103   ASM_OUTPUT_POP_SECTION (asm_out_file);
5104 }
5105
5106 /* Lookup a filename (in the list of filenames that we know about here in
5107    dwarfout.c) and return its "index".  The index of each (known) filename
5108    is just a unique number which is associated with only that one filename.
5109    We need such numbers for the sake of generating labels (in the
5110    .debug_sfnames section) and references to those unique labels (in the
5111    .debug_srcinfo and .debug_macinfo sections).
5112
5113    If the filename given as an argument is not found in our current list,
5114    add it to the list and assign it the next available unique index number.
5115
5116    Whatever we do (i.e. whether we find a pre-existing filename or add a new
5117    one), we shuffle the filename found (or added) up to the zeroth entry of
5118    our list of filenames (which is always searched linearly).  We do this so
5119    as to optimize the most common case for these filename lookups within
5120    dwarfout.c.  The most common case by far is the case where we call
5121    lookup_filename to lookup the very same filename that we did a lookup
5122    on the last time we called lookup_filename.  We make sure that this
5123    common case is fast because such cases will constitute 99.9% of the
5124    lookups we ever do (in practice).
5125
5126    If we add a new filename entry to our table, we go ahead and generate
5127    the corresponding entry in the .debug_sfnames section right away.
5128    Doing so allows us to avoid tickling an assembler bug (present in some
5129    m68k assemblers) which yields assembly-time errors in cases where the
5130    difference of two label addresses is taken and where the two labels
5131    are in a section *other* than the one where the difference is being
5132    calculated, and where at least one of the two symbol references is a
5133    forward reference.  (This bug could be tickled by our .debug_srcinfo
5134    entries if we don't output their corresponding .debug_sfnames entries
5135    before them.) */
5136
5137 static unsigned
5138 lookup_filename (file_name)
5139      char *file_name;
5140 {
5141   register filename_entry *search_p;
5142   register filename_entry *limit_p = &filename_table[ft_entries];
5143
5144   for (search_p = filename_table; search_p < limit_p; search_p++)
5145     if (!strcmp (file_name, search_p->name))
5146       {
5147         /* When we get here, we have found the filename that we were
5148            looking for in the filename_table.  Now we want to make sure
5149            that it gets moved to the zero'th entry in the table (if it
5150            is not already there) so that subsequent attempts to find the
5151            same filename will find it as quickly as possible.  */
5152
5153         shuffle_filename_entry (search_p);
5154         return filename_table[0].number;
5155       }
5156
5157   /* We come here whenever we have a new filename which is not registered
5158      in the current table.  Here we add it to the table.  */
5159
5160   /* Prepare to add a new table entry by making sure there is enough space
5161      in the table to do so.  If not, expand the current table.  */
5162
5163   if (ft_entries == ft_entries_allocated)
5164     {
5165       ft_entries_allocated += FT_ENTRIES_INCREMENT;
5166       filename_table
5167         = (filename_entry *)
5168           xrealloc (filename_table,
5169                     ft_entries_allocated * sizeof (filename_entry));
5170     }
5171
5172   /* Initially, add the new entry at the end of the filename table.  */
5173
5174   filename_table[ft_entries].number = ft_entries;
5175   filename_table[ft_entries].name = xstrdup (file_name);
5176
5177   /* Shuffle the new entry into filename_table[0].  */
5178
5179   shuffle_filename_entry (&filename_table[ft_entries]);
5180
5181   if (debug_info_level >= DINFO_LEVEL_NORMAL)
5182     generate_new_sfname_entry ();
5183
5184   ft_entries++;
5185   return filename_table[0].number;
5186 }
5187
5188 static void
5189 generate_srcinfo_entry (line_entry_num, files_entry_num)
5190      unsigned line_entry_num;
5191      unsigned files_entry_num;
5192 {
5193   char label[MAX_ARTIFICIAL_LABEL_BYTES];
5194
5195   fputc ('\n', asm_out_file);
5196   ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
5197   sprintf (label, LINE_ENTRY_LABEL_FMT, line_entry_num);
5198   ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, LINE_BEGIN_LABEL);
5199   sprintf (label, SFNAMES_ENTRY_LABEL_FMT, files_entry_num);
5200   ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, SFNAMES_BEGIN_LABEL);
5201   ASM_OUTPUT_POP_SECTION (asm_out_file);
5202 }
5203
5204 void
5205 dwarfout_line (filename, line)
5206      register char *filename;
5207      register unsigned line;
5208 {
5209   if (debug_info_level >= DINFO_LEVEL_NORMAL)
5210     {
5211       char label[MAX_ARTIFICIAL_LABEL_BYTES];
5212       static unsigned last_line_entry_num = 0;
5213       static unsigned prev_file_entry_num = (unsigned) -1;
5214       register unsigned this_file_entry_num = lookup_filename (filename);
5215
5216       function_section (current_function_decl);
5217       sprintf (label, LINE_CODE_LABEL_FMT, ++last_line_entry_num);
5218       ASM_OUTPUT_LABEL (asm_out_file, label);
5219
5220       fputc ('\n', asm_out_file);
5221       ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
5222
5223       if (this_file_entry_num != prev_file_entry_num)
5224         {
5225           char line_entry_label[MAX_ARTIFICIAL_LABEL_BYTES];
5226
5227           sprintf (line_entry_label, LINE_ENTRY_LABEL_FMT, last_line_entry_num);
5228           ASM_OUTPUT_LABEL (asm_out_file, line_entry_label);
5229         }
5230
5231       {
5232         register char *tail = rindex (filename, '/');
5233
5234         if (tail != NULL)
5235           filename = tail;
5236       }
5237
5238       fprintf (asm_out_file, "\t%s\t%u\t%s %s:%u\n",
5239                UNALIGNED_INT_ASM_OP, line, ASM_COMMENT_START,
5240                filename, line);
5241       ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff);
5242       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, TEXT_BEGIN_LABEL);
5243       ASM_OUTPUT_POP_SECTION (asm_out_file);
5244
5245       if (this_file_entry_num != prev_file_entry_num)
5246         generate_srcinfo_entry (last_line_entry_num, this_file_entry_num);
5247       prev_file_entry_num = this_file_entry_num;
5248     }
5249 }
5250
5251 /* Generate an entry in the .debug_macinfo section.  */
5252
5253 static void
5254 generate_macinfo_entry (type_and_offset, string)
5255      register char *type_and_offset;
5256      register char *string;
5257 {
5258   fputc ('\n', asm_out_file);
5259   ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION);
5260   fprintf (asm_out_file, "\t%s\t%s\n", UNALIGNED_INT_ASM_OP, type_and_offset);
5261   ASM_OUTPUT_DWARF_STRING (asm_out_file, string);
5262   ASM_OUTPUT_POP_SECTION (asm_out_file);
5263 }
5264
5265 void
5266 dwarfout_start_new_source_file (filename)
5267      register char *filename;
5268 {
5269   char label[MAX_ARTIFICIAL_LABEL_BYTES];
5270   char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*3];
5271
5272   sprintf (label, SFNAMES_ENTRY_LABEL_FMT, lookup_filename (filename));
5273   sprintf (type_and_offset, "0x%08x+%s-%s",
5274            ((unsigned) MACINFO_start << 24), label, SFNAMES_BEGIN_LABEL);
5275   generate_macinfo_entry (type_and_offset, "");
5276 }
5277
5278 void
5279 dwarfout_resume_previous_source_file (lineno)
5280      register unsigned lineno;
5281 {
5282   char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
5283
5284   sprintf (type_and_offset, "0x%08x+%u",
5285            ((unsigned) MACINFO_resume << 24), lineno);
5286   generate_macinfo_entry (type_and_offset, "");
5287 }
5288
5289 /* Called from check_newline in c-parse.y.  The `buffer' parameter
5290    contains the tail part of the directive line, i.e. the part which
5291    is past the initial whitespace, #, whitespace, directive-name,
5292    whitespace part.  */
5293
5294 void
5295 dwarfout_define (lineno, buffer)
5296      register unsigned lineno;
5297      register char *buffer;
5298 {
5299   static int initialized = 0;
5300   char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
5301
5302   if (!initialized)
5303     {
5304       dwarfout_start_new_source_file (primary_filename);
5305       initialized = 1;
5306     }
5307   sprintf (type_and_offset, "0x%08x+%u",
5308            ((unsigned) MACINFO_define << 24), lineno);
5309   generate_macinfo_entry (type_and_offset, buffer);
5310 }
5311
5312 /* Called from check_newline in c-parse.y.  The `buffer' parameter
5313    contains the tail part of the directive line, i.e. the part which
5314    is past the initial whitespace, #, whitespace, directive-name,
5315    whitespace part.  */
5316
5317 void
5318 dwarfout_undef (lineno, buffer)
5319      register unsigned lineno;
5320      register char *buffer;
5321 {
5322   char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
5323
5324   sprintf (type_and_offset, "0x%08x+%u",
5325            ((unsigned) MACINFO_undef << 24), lineno);
5326   generate_macinfo_entry (type_and_offset, buffer);
5327 }
5328
5329 /* Set up for Dwarf output at the start of compilation.  */
5330
5331 void
5332 dwarfout_init (asm_out_file, main_input_filename)
5333      register FILE *asm_out_file;
5334      register char *main_input_filename;
5335 {
5336   /* Remember the name of the primary input file.  */
5337
5338   primary_filename = main_input_filename;
5339
5340   /* Allocate the initial hunk of the pending_sibling_stack.  */
5341
5342   pending_sibling_stack
5343     = (unsigned *)
5344         xmalloc (PENDING_SIBLINGS_INCREMENT * sizeof (unsigned));
5345   pending_siblings_allocated = PENDING_SIBLINGS_INCREMENT;
5346   pending_siblings = 1;
5347
5348   /* Allocate the initial hunk of the filename_table.  */
5349
5350   filename_table
5351     = (filename_entry *)
5352         xmalloc (FT_ENTRIES_INCREMENT * sizeof (filename_entry));
5353   ft_entries_allocated = FT_ENTRIES_INCREMENT;
5354   ft_entries = 0;
5355
5356   /* Allocate the initial hunk of the pending_types_list.  */
5357
5358   pending_types_list
5359     = (tree *) xmalloc (PENDING_TYPES_INCREMENT * sizeof (tree));
5360   pending_types_allocated = PENDING_TYPES_INCREMENT;
5361   pending_types = 0;
5362
5363   /* Create an artificial RECORD_TYPE node which we can use in our hack
5364      to get the DIEs representing types of formal parameters to come out
5365      only *after* the DIEs for the formal parameters themselves.  */
5366
5367   fake_containing_scope = make_node (RECORD_TYPE);
5368
5369   /* Output a starting label for the .text section.  */
5370
5371   fputc ('\n', asm_out_file);
5372   ASM_OUTPUT_PUSH_SECTION (asm_out_file, TEXT_SECTION);
5373   ASM_OUTPUT_LABEL (asm_out_file, TEXT_BEGIN_LABEL);
5374   ASM_OUTPUT_POP_SECTION (asm_out_file);
5375
5376   /* Output a starting label for the .data section.  */
5377
5378   fputc ('\n', asm_out_file);
5379   ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA_SECTION);
5380   ASM_OUTPUT_LABEL (asm_out_file, DATA_BEGIN_LABEL);
5381   ASM_OUTPUT_POP_SECTION (asm_out_file);
5382
5383 #if 0 /* GNU C doesn't currently use .data1.  */
5384   /* Output a starting label for the .data1 section.  */
5385
5386   fputc ('\n', asm_out_file);
5387   ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA1_SECTION);
5388   ASM_OUTPUT_LABEL (asm_out_file, DATA1_BEGIN_LABEL);
5389   ASM_OUTPUT_POP_SECTION (asm_out_file);
5390 #endif
5391
5392   /* Output a starting label for the .rodata section.  */
5393
5394   fputc ('\n', asm_out_file);
5395   ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA_SECTION);
5396   ASM_OUTPUT_LABEL (asm_out_file, RODATA_BEGIN_LABEL);
5397   ASM_OUTPUT_POP_SECTION (asm_out_file);
5398
5399 #if 0 /* GNU C doesn't currently use .rodata1.  */
5400   /* Output a starting label for the .rodata1 section.  */
5401
5402   fputc ('\n', asm_out_file);
5403   ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA1_SECTION);
5404   ASM_OUTPUT_LABEL (asm_out_file, RODATA1_BEGIN_LABEL);
5405   ASM_OUTPUT_POP_SECTION (asm_out_file);
5406 #endif
5407
5408   /* Output a starting label for the .bss section.  */
5409
5410   fputc ('\n', asm_out_file);
5411   ASM_OUTPUT_PUSH_SECTION (asm_out_file, BSS_SECTION);
5412   ASM_OUTPUT_LABEL (asm_out_file, BSS_BEGIN_LABEL);
5413   ASM_OUTPUT_POP_SECTION (asm_out_file);
5414
5415   if (debug_info_level >= DINFO_LEVEL_NORMAL)
5416     {
5417       /* Output a starting label and an initial (compilation directory)
5418          entry for the .debug_sfnames section.  The starting label will be
5419          referenced by the initial entry in the .debug_srcinfo section.  */
5420
5421       fputc ('\n', asm_out_file);
5422       ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION);
5423       ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL);
5424       {
5425         register char *pwd;
5426         register unsigned len;
5427         register char *dirname;
5428
5429         pwd = getpwd ();
5430         if (!pwd)
5431           pfatal_with_name ("getpwd");
5432         len = strlen (pwd);
5433         dirname = (char *) xmalloc (len + 2);
5434
5435         strcpy (dirname, pwd);
5436         strcpy (dirname + len, "/");
5437         ASM_OUTPUT_DWARF_STRING (asm_out_file, dirname);
5438         free (dirname);
5439       }
5440       ASM_OUTPUT_POP_SECTION (asm_out_file);
5441
5442       if (debug_info_level >= DINFO_LEVEL_VERBOSE)
5443         {
5444           /* Output a starting label for the .debug_macinfo section.  This
5445              label will be referenced by the AT_mac_info attribute in the
5446              TAG_compile_unit DIE.  */
5447
5448           fputc ('\n', asm_out_file);
5449           ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION);
5450           ASM_OUTPUT_LABEL (asm_out_file, MACINFO_BEGIN_LABEL);
5451           ASM_OUTPUT_POP_SECTION (asm_out_file);
5452         }
5453
5454       /* Generate the initial entry for the .line section.  */
5455
5456       fputc ('\n', asm_out_file);
5457       ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
5458       ASM_OUTPUT_LABEL (asm_out_file, LINE_BEGIN_LABEL);
5459       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, LINE_END_LABEL, LINE_BEGIN_LABEL);
5460       ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
5461       ASM_OUTPUT_POP_SECTION (asm_out_file);
5462
5463       /* Generate the initial entry for the .debug_srcinfo section.  */
5464
5465       fputc ('\n', asm_out_file);
5466       ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
5467       ASM_OUTPUT_LABEL (asm_out_file, SRCINFO_BEGIN_LABEL);
5468       ASM_OUTPUT_DWARF_ADDR (asm_out_file, LINE_BEGIN_LABEL);
5469       ASM_OUTPUT_DWARF_ADDR (asm_out_file, SFNAMES_BEGIN_LABEL);
5470       ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
5471       ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_END_LABEL);
5472 #ifdef DWARF_TIMESTAMPS
5473       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, time (NULL));
5474 #else
5475       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
5476 #endif
5477       ASM_OUTPUT_POP_SECTION (asm_out_file);
5478
5479       /* Generate the initial entry for the .debug_pubnames section.  */
5480
5481       fputc ('\n', asm_out_file);
5482       ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION);
5483       ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL);
5484       ASM_OUTPUT_POP_SECTION (asm_out_file);
5485
5486       /* Generate the initial entry for the .debug_aranges section.  */
5487
5488       fputc ('\n', asm_out_file);
5489       ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION);
5490       ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL);
5491       ASM_OUTPUT_POP_SECTION (asm_out_file);
5492     }
5493
5494   /* Setup first DIE number == 1.  */
5495   NEXT_DIE_NUM = next_unused_dienum++;
5496
5497   /* Generate the initial DIE for the .debug section.  Note that the
5498      (string) value given in the AT_name attribute of the TAG_compile_unit
5499      DIE will (typically) be a relative pathname and that this pathname
5500      should be taken as being relative to the directory from which the
5501      compiler was invoked when the given (base) source file was compiled.  */
5502
5503   fputc ('\n', asm_out_file);
5504   ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
5505   ASM_OUTPUT_LABEL (asm_out_file, DEBUG_BEGIN_LABEL);
5506   output_die (output_compile_unit_die, main_input_filename);
5507   ASM_OUTPUT_POP_SECTION (asm_out_file);
5508
5509   fputc ('\n', asm_out_file);
5510 }
5511
5512 /* Output stuff that dwarf requires at the end of every file.  */
5513
5514 void
5515 dwarfout_finish ()
5516 {
5517   char label[MAX_ARTIFICIAL_LABEL_BYTES];
5518
5519   fputc ('\n', asm_out_file);
5520   ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
5521
5522   /* Mark the end of the chain of siblings which represent all file-scope
5523      declarations in this compilation unit.  */
5524
5525   /* The (null) DIE which represents the terminator for the (sibling linked)
5526      list of file-scope items is *special*.  Normally, we would just call
5527      end_sibling_chain at this point in order to output a word with the
5528      value `4' and that word would act as the terminator for the list of
5529      DIEs describing file-scope items.  Unfortunately, if we were to simply
5530      do that, the label that would follow this DIE in the .debug section
5531      (i.e. `..D2') would *not* be properly aligned (as it must be on some
5532      machines) to a 4 byte boundary.
5533
5534      In order to force the label `..D2' to get aligned to a 4 byte boundary,
5535      the trick used is to insert extra (otherwise useless) padding bytes
5536      into the (null) DIE that we know must precede the ..D2 label in the
5537      .debug section.  The amount of padding required can be anywhere between
5538      0 and 3 bytes.  The length word at the start of this DIE (i.e. the one
5539      with the padding) would normally contain the value 4, but now it will
5540      also have to include the padding bytes, so it will instead have some
5541      value in the range 4..7.
5542
5543      Fortunately, the rules of Dwarf say that any DIE whose length word
5544      contains *any* value less than 8 should be treated as a null DIE, so
5545      this trick works out nicely.  Clever, eh?  Don't give me any credit
5546      (or blame).  I didn't think of this scheme.  I just conformed to it.
5547   */
5548
5549   output_die (output_padded_null_die, (void *) 0);
5550   dienum_pop ();
5551
5552   sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM);
5553   ASM_OUTPUT_LABEL (asm_out_file, label);       /* should be ..D2 */
5554   ASM_OUTPUT_POP_SECTION (asm_out_file);
5555
5556   /* Output a terminator label for the .text section.  */
5557
5558   fputc ('\n', asm_out_file);
5559   ASM_OUTPUT_PUSH_SECTION (asm_out_file, TEXT_SECTION);
5560   ASM_OUTPUT_LABEL (asm_out_file, TEXT_END_LABEL);
5561   ASM_OUTPUT_POP_SECTION (asm_out_file);
5562
5563   /* Output a terminator label for the .data section.  */
5564
5565   fputc ('\n', asm_out_file);
5566   ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA_SECTION);
5567   ASM_OUTPUT_LABEL (asm_out_file, DATA_END_LABEL);
5568   ASM_OUTPUT_POP_SECTION (asm_out_file);
5569
5570 #if 0 /* GNU C doesn't currently use .data1.  */
5571   /* Output a terminator label for the .data1 section.  */
5572
5573   fputc ('\n', asm_out_file);
5574   ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA1_SECTION);
5575   ASM_OUTPUT_LABEL (asm_out_file, DATA1_END_LABEL);
5576   ASM_OUTPUT_POP_SECTION (asm_out_file);
5577 #endif
5578
5579   /* Output a terminator label for the .rodata section.  */
5580
5581   fputc ('\n', asm_out_file);
5582   ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA_SECTION);
5583   ASM_OUTPUT_LABEL (asm_out_file, RODATA_END_LABEL);
5584   ASM_OUTPUT_POP_SECTION (asm_out_file);
5585
5586 #if 0 /* GNU C doesn't currently use .rodata1.  */
5587   /* Output a terminator label for the .rodata1 section.  */
5588
5589   fputc ('\n', asm_out_file);
5590   ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA1_SECTION);
5591   ASM_OUTPUT_LABEL (asm_out_file, RODATA1_END_LABEL);
5592   ASM_OUTPUT_POP_SECTION (asm_out_file);
5593 #endif
5594
5595   /* Output a terminator label for the .bss section.  */
5596
5597   fputc ('\n', asm_out_file);
5598   ASM_OUTPUT_PUSH_SECTION (asm_out_file, BSS_SECTION);
5599   ASM_OUTPUT_LABEL (asm_out_file, BSS_END_LABEL);
5600   ASM_OUTPUT_POP_SECTION (asm_out_file);
5601
5602   if (debug_info_level >= DINFO_LEVEL_NORMAL)
5603     {
5604       /* Output a terminating entry for the .line section.  */
5605
5606       fputc ('\n', asm_out_file);
5607       ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
5608       ASM_OUTPUT_LABEL (asm_out_file, LINE_LAST_ENTRY_LABEL);
5609       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5610       ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff);
5611       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL);
5612       ASM_OUTPUT_LABEL (asm_out_file, LINE_END_LABEL);
5613       ASM_OUTPUT_POP_SECTION (asm_out_file);
5614
5615       /* Output a terminating entry for the .debug_srcinfo section.  */
5616
5617       fputc ('\n', asm_out_file);
5618       ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
5619       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
5620                                LINE_LAST_ENTRY_LABEL, LINE_BEGIN_LABEL);
5621       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
5622       ASM_OUTPUT_POP_SECTION (asm_out_file);
5623
5624       if (debug_info_level >= DINFO_LEVEL_VERBOSE)
5625         {
5626           /* Output terminating entries for the .debug_macinfo section.  */
5627
5628           dwarfout_resume_previous_source_file (0);
5629
5630           fputc ('\n', asm_out_file);
5631           ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION);
5632           ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5633           ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
5634           ASM_OUTPUT_POP_SECTION (asm_out_file);
5635         }
5636
5637       /* Generate the terminating entry for the .debug_pubnames section.  */
5638
5639       fputc ('\n', asm_out_file);
5640       ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION);
5641       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5642       ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
5643       ASM_OUTPUT_POP_SECTION (asm_out_file);
5644
5645       /* Generate the terminating entries for the .debug_aranges section.
5646
5647          Note that we want to do this only *after* we have output the end
5648          labels (for the various program sections) which we are going to
5649          refer to here.  This allows us to work around a bug in the m68k
5650          svr4 assembler.  That assembler gives bogus assembly-time errors
5651          if (within any given section) you try to take the difference of
5652          two relocatable symbols, both of which are located within some
5653          other section, and if one (or both?) of the symbols involved is
5654          being forward-referenced.  By generating the .debug_aranges
5655          entries at this late point in the assembly output, we skirt the
5656          issue simply by avoiding forward-references.
5657       */
5658
5659       fputc ('\n', asm_out_file);
5660       ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION);
5661
5662       ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
5663       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL);
5664
5665       ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA_BEGIN_LABEL);
5666       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA_END_LABEL, DATA_BEGIN_LABEL);
5667
5668 #if 0 /* GNU C doesn't currently use .data1.  */
5669       ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA1_BEGIN_LABEL);
5670       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA1_END_LABEL,
5671                                              DATA1_BEGIN_LABEL);
5672 #endif
5673
5674       ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA_BEGIN_LABEL);
5675       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA_END_LABEL,
5676                                              RODATA_BEGIN_LABEL);
5677
5678 #if 0 /* GNU C doesn't currently use .rodata1.  */
5679       ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA1_BEGIN_LABEL);
5680       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA1_END_LABEL,
5681                                              RODATA1_BEGIN_LABEL);
5682 #endif
5683
5684       ASM_OUTPUT_DWARF_ADDR (asm_out_file, BSS_BEGIN_LABEL);
5685       ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, BSS_END_LABEL, BSS_BEGIN_LABEL);
5686
5687       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5688       ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5689
5690       ASM_OUTPUT_POP_SECTION (asm_out_file);
5691     }
5692 }
5693
5694 #endif /* DWARF_DEBUGGING_INFO && DWARF_VERSION != 2 */