gcc/dwarf2out.c

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