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