gcc/dwarf2out.c

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