gcc/dwarf2out.c

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