gcc/dwarf2out.c

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