gcc/dwarf2out.c

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