gcc/dwarf2out.c

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