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