gcc/dwarf2out.c

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