gcc/dwarf2out.c

   1 /* Output Dwarf2 format symbol table information from GCC.
   2    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005, 2006 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 GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 2, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING.  If not, write to the Free
  22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  23 02110-1301, USA.  */
  24
  25 /* TODO: Emit .debug_line header even when there are no functions, since
  26            the file numbers are used by .debug_info.  Alternately, leave
  27            out locations for types and decls.
  28          Avoid talking about ctors and op= for PODs.
  29          Factor out common prologue sequences into multiple CIEs.  */
  30
  31 /* The first part of this file deals with the DWARF 2 frame unwind
  32    information, which is also used by the GCC efficient exception handling
  33    mechanism.  The second part, controlled only by an #ifdef
  34    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
  35    information.  */
  36
  37 #include "config.h"
  38 #include "system.h"
  39 #include "coretypes.h"
  40 #include "tm.h"
  41 #include "tree.h"
  42 #include "version.h"
  43 #include "flags.h"
  44 #include "real.h"
  45 #include "rtl.h"
  46 #include "hard-reg-set.h"
  47 #include "regs.h"
  48 #include "insn-config.h"
  49 #include "reload.h"
  50 #include "function.h"
  51 #include "output.h"
  52 #include "expr.h"
  53 #include "libfuncs.h"
  54 #include "except.h"
  55 #include "dwarf2.h"
  56 #include "dwarf2out.h"
  57 #include "dwarf2asm.h"
  58 #include "toplev.h"
  59 #include "varray.h"
  60 #include "ggc.h"
  61 #include "md5.h"
  62 #include "tm_p.h"
  63 #include "diagnostic.h"
  64 #include "debug.h"
  65 #include "target.h"
  66 #include "langhooks.h"
  67 #include "hashtab.h"
  68 #include "cgraph.h"
  69 #include "input.h"
  70
  71 #ifdef DWARF2_DEBUGGING_INFO
  72 static void dwarf2out_source_line (unsigned int, const char *);
  73 #endif
  74
  75 /* DWARF2 Abbreviation Glossary:
  76    CFA = Canonical Frame Address
  77            a fixed address on the stack which identifies a call frame.
  78            We define it to be the value of SP just before the call insn.
  79            The CFA register and offset, which may change during the course
  80            of the function, are used to calculate its value at runtime.
  81    CFI = Call Frame Instruction
  82            an instruction for the DWARF2 abstract machine
  83    CIE = Common Information Entry
  84            information describing information common to one or more FDEs
  85    DIE = Debugging Information Entry
  86    FDE = Frame Description Entry
  87            information describing the stack call frame, in particular,
  88            how to restore registers
  89
  90    DW_CFA_... = DWARF2 CFA call frame instruction
  91    DW_TAG_... = DWARF2 DIE tag */
  92
  93 #ifndef DWARF2_FRAME_INFO
  94 # ifdef DWARF2_DEBUGGING_INFO
  95 #  define DWARF2_FRAME_INFO \
  96   (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
  97 # else
  98 #  define DWARF2_FRAME_INFO 0
  99 # endif
 100 #endif
 101
 102 /* Decide whether we want to emit frame unwind information for the current
 103    translation unit.  */
 104
 105 int
 106 dwarf2out_do_frame (void)
 107 {
 108   /* We want to emit correct CFA location expressions or lists, so we
 109      have to return true if we're going to output debug info, even if
 110      we're not going to output frame or unwind info.  */
 111   return (write_symbols == DWARF2_DEBUG
 112           || write_symbols == VMS_AND_DWARF2_DEBUG
 113           || DWARF2_FRAME_INFO
 114 #ifdef DWARF2_UNWIND_INFO
 115           || (DWARF2_UNWIND_INFO
 116               && (flag_unwind_tables
 117                   || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
 118 #endif
 119           );
 120 }
 121
 122 /* The size of the target's pointer type.  */
 123 #ifndef PTR_SIZE
 124 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 125 #endif
 126
 127 /* Array of RTXes referenced by the debugging information, which therefore
 128    must be kept around forever.  */
 129 static GTY(()) VEC(rtx,gc) *used_rtx_array;
 130
 131 /* A pointer to the base of a list of incomplete types which might be
 132    completed at some later time.  incomplete_types_list needs to be a
 133    VEC(tree,gc) because we want to tell the garbage collector about
 134    it.  */
 135 static GTY(()) VEC(tree,gc) *incomplete_types;
 136
 137 /* A pointer to the base of a table of references to declaration
 138    scopes.  This table is a display which tracks the nesting
 139    of declaration scopes at the current scope and containing
 140    scopes.  This table is used to find the proper place to
 141    define type declaration DIE's.  */
 142 static GTY(()) VEC(tree,gc) *decl_scope_table;
 143
 144 /* Pointers to various DWARF2 sections.  */
 145 static GTY(()) section *debug_info_section;
 146 static GTY(()) section *debug_abbrev_section;
 147 static GTY(()) section *debug_aranges_section;
 148 static GTY(()) section *debug_macinfo_section;
 149 static GTY(()) section *debug_line_section;
 150 static GTY(()) section *debug_loc_section;
 151 static GTY(()) section *debug_pubnames_section;
 152 static GTY(()) section *debug_str_section;
 153 static GTY(()) section *debug_ranges_section;
 154
 155 /* How to start an assembler comment.  */
 156 #ifndef ASM_COMMENT_START
 157 #define ASM_COMMENT_START ";#"
 158 #endif
 159
 160 typedef struct dw_cfi_struct *dw_cfi_ref;
 161 typedef struct dw_fde_struct *dw_fde_ref;
 162 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
 163
 164 /* Call frames are described using a sequence of Call Frame
 165    Information instructions.  The register number, offset
 166    and address fields are provided as possible operands;
 167    their use is selected by the opcode field.  */
 168
 169 enum dw_cfi_oprnd_type {
 170   dw_cfi_oprnd_unused,
 171   dw_cfi_oprnd_reg_num,
 172   dw_cfi_oprnd_offset,
 173   dw_cfi_oprnd_addr,
 174   dw_cfi_oprnd_loc
 175 };
 176
 177 typedef union dw_cfi_oprnd_struct GTY(())
 178 {
 179   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
 180   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
 181   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
 182   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
 183 }
 184 dw_cfi_oprnd;
 185
 186 typedef struct dw_cfi_struct GTY(())
 187 {
 188   dw_cfi_ref dw_cfi_next;
 189   enum dwarf_call_frame_info dw_cfi_opc;
 190   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
 191     dw_cfi_oprnd1;
 192   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
 193     dw_cfi_oprnd2;
 194 }
 195 dw_cfi_node;
 196
 197 /* This is how we define the location of the CFA. We use to handle it
 198    as REG + OFFSET all the time,  but now it can be more complex.
 199    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 200    Instead of passing around REG and OFFSET, we pass a copy
 201    of this structure.  */
 202 typedef struct cfa_loc GTY(())
 203 {
 204   HOST_WIDE_INT offset;
 205   HOST_WIDE_INT base_offset;
 206   unsigned int reg;
 207   int indirect;            /* 1 if CFA is accessed via a dereference.  */
 208 } dw_cfa_location;
 209
 210 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 211    refer to a single Common Information Entry (CIE), defined at
 212    the beginning of the .debug_frame section.  This use of a single
 213    CIE obviates the need to keep track of multiple CIE's
 214    in the DWARF generation routines below.  */
 215
 216 typedef struct dw_fde_struct GTY(())
 217 {
 218   tree decl;
 219   const char *dw_fde_begin;
 220   const char *dw_fde_current_label;
 221   const char *dw_fde_end;
 222   const char *dw_fde_hot_section_label;
 223   const char *dw_fde_hot_section_end_label;
 224   const char *dw_fde_unlikely_section_label;
 225   const char *dw_fde_unlikely_section_end_label;
 226   bool dw_fde_switched_sections;
 227   dw_cfi_ref dw_fde_cfi;
 228   unsigned funcdef_number;
 229   unsigned all_throwers_are_sibcalls : 1;
 230   unsigned nothrow : 1;
 231   unsigned uses_eh_lsda : 1;
 232 }
 233 dw_fde_node;
 234
 235 /* Maximum size (in bytes) of an artificially generated label.  */
 236 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 237
 238 /* The size of addresses as they appear in the Dwarf 2 data.
 239    Some architectures use word addresses to refer to code locations,
 240    but Dwarf 2 info always uses byte addresses.  On such machines,
 241    Dwarf 2 addresses need to be larger than the architecture's
 242    pointers.  */
 243 #ifndef DWARF2_ADDR_SIZE
 244 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 245 #endif
 246
 247 /* The size in bytes of a DWARF field indicating an offset or length
 248    relative to a debug info section, specified to be 4 bytes in the
 249    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
 250    as PTR_SIZE.  */
 251
 252 #ifndef DWARF_OFFSET_SIZE
 253 #define DWARF_OFFSET_SIZE 4
 254 #endif
 255
 256 /* According to the (draft) DWARF 3 specification, the initial length
 257    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
 258    bytes are 0xffffffff, followed by the length stored in the next 8
 259    bytes.
 260
 261    However, the SGI/MIPS ABI uses an initial length which is equal to
 262    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
 263
 264 #ifndef DWARF_INITIAL_LENGTH_SIZE
 265 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
 266 #endif
 267
 268 #define DWARF_VERSION 2
 269
 270 /* Round SIZE up to the nearest BOUNDARY.  */
 271 #define DWARF_ROUND(SIZE,BOUNDARY) \
 272   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 273
 274 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 275 #ifndef DWARF_CIE_DATA_ALIGNMENT
 276 #ifdef STACK_GROWS_DOWNWARD
 277 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
 278 #else
 279 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
 280 #endif
 281 #endif
 282
 283 /* A pointer to the base of a table that contains frame description
 284    information for each routine.  */
 285 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
 286
 287 /* Number of elements currently allocated for fde_table.  */
 288 static GTY(()) unsigned fde_table_allocated;
 289
 290 /* Number of elements in fde_table currently in use.  */
 291 static GTY(()) unsigned fde_table_in_use;
 292
 293 /* Size (in elements) of increments by which we may expand the
 294    fde_table.  */
 295 #define FDE_TABLE_INCREMENT 256
 296
 297 /* A list of call frame insns for the CIE.  */
 298 static GTY(()) dw_cfi_ref cie_cfi_head;
 299
 300 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 301 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 302    attribute that accelerates the lookup of the FDE associated
 303    with the subprogram.  This variable holds the table index of the FDE
 304    associated with the current function (body) definition.  */
 305 static unsigned current_funcdef_fde;
 306 #endif
 307
 308 struct indirect_string_node GTY(())
 309 {
 310   const char *str;
 311   unsigned int refcount;
 312   unsigned int form;
 313   char *label;
 314 };
 315
 316 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 317
 318 static GTY(()) int dw2_string_counter;
 319 static GTY(()) unsigned long dwarf2out_cfi_label_num;
 320
 321 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 322
 323 /* Forward declarations for functions defined in this file.  */
 324
 325 static char *stripattributes (const char *);
 326 static const char *dwarf_cfi_name (unsigned);
 327 static dw_cfi_ref new_cfi (void);
 328 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
 329 static void add_fde_cfi (const char *, dw_cfi_ref);
 330 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
 331 static void lookup_cfa (dw_cfa_location *);
 332 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
 333 static void initial_return_save (rtx);
 334 static HOST_WIDE_INT stack_adjust_offset (rtx);
 335 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 336 static void output_call_frame_info (int);
 337 static void dwarf2out_stack_adjust (rtx, bool);
 338 static void flush_queued_reg_saves (void);
 339 static bool clobbers_queued_reg_save (rtx);
 340 static void dwarf2out_frame_debug_expr (rtx, const char *);
 341
 342 /* Support for complex CFA locations.  */
 343 static void output_cfa_loc (dw_cfi_ref);
 344 static void get_cfa_from_loc_descr (dw_cfa_location *,
 345                                     struct dw_loc_descr_struct *);
 346 static struct dw_loc_descr_struct *build_cfa_loc
 347   (dw_cfa_location *, HOST_WIDE_INT);
 348 static void def_cfa_1 (const char *, dw_cfa_location *);
 349
 350 /* How to start an assembler comment.  */
 351 #ifndef ASM_COMMENT_START
 352 #define ASM_COMMENT_START ";#"
 353 #endif
 354
 355 /* Data and reference forms for relocatable data.  */
 356 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 357 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 358
 359 #ifndef DEBUG_FRAME_SECTION
 360 #define DEBUG_FRAME_SECTION     ".debug_frame"
 361 #endif
 362
 363 #ifndef FUNC_BEGIN_LABEL
 364 #define FUNC_BEGIN_LABEL        "LFB"
 365 #endif
 366
 367 #ifndef FUNC_END_LABEL
 368 #define FUNC_END_LABEL          "LFE"
 369 #endif
 370
 371 #ifndef FRAME_BEGIN_LABEL
 372 #define FRAME_BEGIN_LABEL       "Lframe"
 373 #endif
 374 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 375 #define CIE_END_LABEL           "LECIE"
 376 #define FDE_LABEL               "LSFDE"
 377 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 378 #define FDE_END_LABEL           "LEFDE"
 379 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 380 #define LINE_NUMBER_END_LABEL   "LELT"
 381 #define LN_PROLOG_AS_LABEL      "LASLTP"
 382 #define LN_PROLOG_END_LABEL     "LELTP"
 383 #define DIE_LABEL_PREFIX        "DW"
 384
 385 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 386    is the column for PC, or the first column after all of the hard
 387    registers.  */
 388 #ifndef DWARF_FRAME_RETURN_COLUMN
 389 #ifdef PC_REGNUM
 390 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 391 #else
 392 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
 393 #endif
 394 #endif
 395
 396 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 397    default, we just provide columns for all registers.  */
 398 #ifndef DWARF_FRAME_REGNUM
 399 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 400 #endif
 401 \f
 402 /* Hook used by __throw.  */
 403
 404 rtx
 405 expand_builtin_dwarf_sp_column (void)
 406 {
 407   return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
 408 }
 409
 410 /* Return a pointer to a copy of the section string name S with all
 411    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 412
 413 static inline char *
 414 stripattributes (const char *s)
 415 {
 416   char *stripped = XNEWVEC (char, strlen (s) + 2);
 417   char *p = stripped;
 418
 419   *p++ = '*';
 420
 421   while (*s && *s != ',')
 422     *p++ = *s++;
 423
 424   *p = '\0';
 425   return stripped;
 426 }
 427
 428 /* Generate code to initialize the register size table.  */
 429
 430 void
 431 expand_builtin_init_dwarf_reg_sizes (tree address)
 432 {
 433   int i;
 434   enum machine_mode mode = TYPE_MODE (char_type_node);
 435   rtx addr = expand_normal (address);
 436   rtx mem = gen_rtx_MEM (BLKmode, addr);
 437   bool wrote_return_column = false;
 438
 439   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 440     if (DWARF_FRAME_REGNUM (i) < DWARF_FRAME_REGISTERS)
 441       {
 442         HOST_WIDE_INT offset = DWARF_FRAME_REGNUM (i) * GET_MODE_SIZE (mode);
 443         enum machine_mode save_mode = reg_raw_mode[i];
 444         HOST_WIDE_INT size;
 445
 446         if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
 447           save_mode = choose_hard_reg_mode (i, 1, true);
 448         if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
 449           {
 450             if (save_mode == VOIDmode)
 451               continue;
 452             wrote_return_column = true;
 453           }
 454         size = GET_MODE_SIZE (save_mode);
 455         if (offset < 0)
 456           continue;
 457
 458         emit_move_insn (adjust_address (mem, mode, offset),
 459                         gen_int_mode (size, mode));
 460       }
 461
 462 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
 463   gcc_assert (wrote_return_column);
 464   i = DWARF_ALT_FRAME_RETURN_COLUMN;
 465   wrote_return_column = false;
 466 #else
 467   i = DWARF_FRAME_RETURN_COLUMN;
 468 #endif
 469
 470   if (! wrote_return_column)
 471     {
 472       enum machine_mode save_mode = Pmode;
 473       HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
 474       HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
 475       emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 476     }
 477 }
 478
 479 /* Convert a DWARF call frame info. operation to its string name */
 480
 481 static const char *
 482 dwarf_cfi_name (unsigned int cfi_opc)
 483 {
 484   switch (cfi_opc)
 485     {
 486     case DW_CFA_advance_loc:
 487       return "DW_CFA_advance_loc";
 488     case DW_CFA_offset:
 489       return "DW_CFA_offset";
 490     case DW_CFA_restore:
 491       return "DW_CFA_restore";
 492     case DW_CFA_nop:
 493       return "DW_CFA_nop";
 494     case DW_CFA_set_loc:
 495       return "DW_CFA_set_loc";
 496     case DW_CFA_advance_loc1:
 497       return "DW_CFA_advance_loc1";
 498     case DW_CFA_advance_loc2:
 499       return "DW_CFA_advance_loc2";
 500     case DW_CFA_advance_loc4:
 501       return "DW_CFA_advance_loc4";
 502     case DW_CFA_offset_extended:
 503       return "DW_CFA_offset_extended";
 504     case DW_CFA_restore_extended:
 505       return "DW_CFA_restore_extended";
 506     case DW_CFA_undefined:
 507       return "DW_CFA_undefined";
 508     case DW_CFA_same_value:
 509       return "DW_CFA_same_value";
 510     case DW_CFA_register:
 511       return "DW_CFA_register";
 512     case DW_CFA_remember_state:
 513       return "DW_CFA_remember_state";
 514     case DW_CFA_restore_state:
 515       return "DW_CFA_restore_state";
 516     case DW_CFA_def_cfa:
 517       return "DW_CFA_def_cfa";
 518     case DW_CFA_def_cfa_register:
 519       return "DW_CFA_def_cfa_register";
 520     case DW_CFA_def_cfa_offset:
 521       return "DW_CFA_def_cfa_offset";
 522
 523     /* DWARF 3 */
 524     case DW_CFA_def_cfa_expression:
 525       return "DW_CFA_def_cfa_expression";
 526     case DW_CFA_expression:
 527       return "DW_CFA_expression";
 528     case DW_CFA_offset_extended_sf:
 529       return "DW_CFA_offset_extended_sf";
 530     case DW_CFA_def_cfa_sf:
 531       return "DW_CFA_def_cfa_sf";
 532     case DW_CFA_def_cfa_offset_sf:
 533       return "DW_CFA_def_cfa_offset_sf";
 534
 535     /* SGI/MIPS specific */
 536     case DW_CFA_MIPS_advance_loc8:
 537       return "DW_CFA_MIPS_advance_loc8";
 538
 539     /* GNU extensions */
 540     case DW_CFA_GNU_window_save:
 541       return "DW_CFA_GNU_window_save";
 542     case DW_CFA_GNU_args_size:
 543       return "DW_CFA_GNU_args_size";
 544     case DW_CFA_GNU_negative_offset_extended:
 545       return "DW_CFA_GNU_negative_offset_extended";
 546
 547     default:
 548       return "DW_CFA_<unknown>";
 549     }
 550 }
 551
 552 /* Return a pointer to a newly allocated Call Frame Instruction.  */
 553
 554 static inline dw_cfi_ref
 555 new_cfi (void)
 556 {
 557   dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
 558
 559   cfi->dw_cfi_next = NULL;
 560   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
 561   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
 562
 563   return cfi;
 564 }
 565
 566 /* Add a Call Frame Instruction to list of instructions.  */
 567
 568 static inline void
 569 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
 570 {
 571   dw_cfi_ref *p;
 572
 573   /* Find the end of the chain.  */
 574   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
 575     ;
 576
 577   *p = cfi;
 578 }
 579
 580 /* Generate a new label for the CFI info to refer to.  */
 581
 582 char *
 583 dwarf2out_cfi_label (void)
 584 {
 585   static char label[20];
 586
 587   ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
 588   ASM_OUTPUT_LABEL (asm_out_file, label);
 589   return label;
 590 }
 591
 592 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
 593    or to the CIE if LABEL is NULL.  */
 594
 595 static void
 596 add_fde_cfi (const char *label, dw_cfi_ref cfi)
 597 {
 598   if (label)
 599     {
 600       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 601
 602       if (*label == 0)
 603         label = dwarf2out_cfi_label ();
 604
 605       if (fde->dw_fde_current_label == NULL
 606           || strcmp (label, fde->dw_fde_current_label) != 0)
 607         {
 608           dw_cfi_ref xcfi;
 609
 610           fde->dw_fde_current_label = label = xstrdup (label);
 611
 612           /* Set the location counter to the new label.  */
 613           xcfi = new_cfi ();
 614           xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
 615           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 616           add_cfi (&fde->dw_fde_cfi, xcfi);
 617         }
 618
 619       add_cfi (&fde->dw_fde_cfi, cfi);
 620     }
 621
 622   else
 623     add_cfi (&cie_cfi_head, cfi);
 624 }
 625
 626 /* Subroutine of lookup_cfa.  */
 627
 628 static void
 629 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
 630 {
 631   switch (cfi->dw_cfi_opc)
 632     {
 633     case DW_CFA_def_cfa_offset:
 634       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
 635       break;
 636     case DW_CFA_def_cfa_offset_sf:
 637       loc->offset
 638         = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
 639       break;
 640     case DW_CFA_def_cfa_register:
 641       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 642       break;
 643     case DW_CFA_def_cfa:
 644       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 645       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
 646       break;
 647     case DW_CFA_def_cfa_sf:
 648       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 649       loc->offset
 650         = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
 651       break;
 652     case DW_CFA_def_cfa_expression:
 653       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
 654       break;
 655     default:
 656       break;
 657     }
 658 }
 659
 660 /* Find the previous value for the CFA.  */
 661
 662 static void
 663 lookup_cfa (dw_cfa_location *loc)
 664 {
 665   dw_cfi_ref cfi;
 666
 667   loc->reg = INVALID_REGNUM;
 668   loc->offset = 0;
 669   loc->indirect = 0;
 670   loc->base_offset = 0;
 671
 672   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
 673     lookup_cfa_1 (cfi, loc);
 674
 675   if (fde_table_in_use)
 676     {
 677       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 678       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 679         lookup_cfa_1 (cfi, loc);
 680     }
 681 }
 682
 683 /* The current rule for calculating the DWARF2 canonical frame address.  */
 684 static dw_cfa_location cfa;
 685
 686 /* The register used for saving registers to the stack, and its offset
 687    from the CFA.  */
 688 static dw_cfa_location cfa_store;
 689
 690 /* The running total of the size of arguments pushed onto the stack.  */
 691 static HOST_WIDE_INT args_size;
 692
 693 /* The last args_size we actually output.  */
 694 static HOST_WIDE_INT old_args_size;
 695
 696 /* Entry point to update the canonical frame address (CFA).
 697    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
 698    calculated from REG+OFFSET.  */
 699
 700 void
 701 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 702 {
 703   dw_cfa_location loc;
 704   loc.indirect = 0;
 705   loc.base_offset = 0;
 706   loc.reg = reg;
 707   loc.offset = offset;
 708   def_cfa_1 (label, &loc);
 709 }
 710
 711 /* Determine if two dw_cfa_location structures define the same data.  */
 712
 713 static bool
 714 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
 715 {
 716   return (loc1->reg == loc2->reg
 717           && loc1->offset == loc2->offset
 718           && loc1->indirect == loc2->indirect
 719           && (loc1->indirect == 0
 720               || loc1->base_offset == loc2->base_offset));
 721 }
 722
 723 /* This routine does the actual work.  The CFA is now calculated from
 724    the dw_cfa_location structure.  */
 725
 726 static void
 727 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
 728 {
 729   dw_cfi_ref cfi;
 730   dw_cfa_location old_cfa, loc;
 731
 732   cfa = *loc_p;
 733   loc = *loc_p;
 734
 735   if (cfa_store.reg == loc.reg && loc.indirect == 0)
 736     cfa_store.offset = loc.offset;
 737
 738   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
 739   lookup_cfa (&old_cfa);
 740
 741   /* If nothing changed, no need to issue any call frame instructions.  */
 742   if (cfa_equal_p (&loc, &old_cfa))
 743     return;
 744
 745   cfi = new_cfi ();
 746
 747   if (loc.reg == old_cfa.reg && !loc.indirect)
 748     {
 749       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
 750          the CFA register did not change but the offset did.  */
 751       if (loc.offset < 0)
 752         {
 753           HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
 754           gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
 755
 756           cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
 757           cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset;
 758         }
 759       else
 760         {
 761           cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
 762           cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
 763         }
 764     }
 765
 766 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
 767   else if (loc.offset == old_cfa.offset
 768            && old_cfa.reg != INVALID_REGNUM
 769            && !loc.indirect)
 770     {
 771       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
 772          indicating the CFA register has changed to <register> but the
 773          offset has not changed.  */
 774       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
 775       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 776     }
 777 #endif
 778
 779   else if (loc.indirect == 0)
 780     {
 781       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
 782          indicating the CFA register has changed to <register> with
 783          the specified offset.  */
 784       if (loc.offset < 0)
 785         {
 786           HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
 787           gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
 788
 789           cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
 790           cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 791           cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset;
 792         }
 793       else
 794         {
 795           cfi->dw_cfi_opc = DW_CFA_def_cfa;
 796           cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 797           cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
 798         }
 799     }
 800   else
 801     {
 802       /* Construct a DW_CFA_def_cfa_expression instruction to
 803          calculate the CFA using a full location expression since no
 804          register-offset pair is available.  */
 805       struct dw_loc_descr_struct *loc_list;
 806
 807       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
 808       loc_list = build_cfa_loc (&loc, 0);
 809       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
 810     }
 811
 812   add_fde_cfi (label, cfi);
 813 }
 814
 815 /* Add the CFI for saving a register.  REG is the CFA column number.
 816    LABEL is passed to add_fde_cfi.
 817    If SREG is -1, the register is saved at OFFSET from the CFA;
 818    otherwise it is saved in SREG.  */
 819
 820 static void
 821 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
 822 {
 823   dw_cfi_ref cfi = new_cfi ();
 824
 825   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
 826
 827   if (sreg == INVALID_REGNUM)
 828     {
 829       if (reg & ~0x3f)
 830         /* The register number won't fit in 6 bits, so we have to use
 831            the long form.  */
 832         cfi->dw_cfi_opc = DW_CFA_offset_extended;
 833       else
 834         cfi->dw_cfi_opc = DW_CFA_offset;
 835
 836 #ifdef ENABLE_CHECKING
 837       {
 838         /* If we get an offset that is not a multiple of
 839            DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
 840            definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
 841            description.  */
 842         HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
 843
 844         gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
 845       }
 846 #endif
 847       offset /= DWARF_CIE_DATA_ALIGNMENT;
 848       if (offset < 0)
 849         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
 850
 851       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
 852     }
 853   else if (sreg == reg)
 854     cfi->dw_cfi_opc = DW_CFA_same_value;
 855   else
 856     {
 857       cfi->dw_cfi_opc = DW_CFA_register;
 858       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
 859     }
 860
 861   add_fde_cfi (label, cfi);
 862 }
 863
 864 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
 865    This CFI tells the unwinder that it needs to restore the window registers
 866    from the previous frame's window save area.
 867
 868    ??? Perhaps we should note in the CIE where windows are saved (instead of
 869    assuming 0(cfa)) and what registers are in the window.  */
 870
 871 void
 872 dwarf2out_window_save (const char *label)
 873 {
 874   dw_cfi_ref cfi = new_cfi ();
 875
 876   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
 877   add_fde_cfi (label, cfi);
 878 }
 879
 880 /* Add a CFI to update the running total of the size of arguments
 881    pushed onto the stack.  */
 882
 883 void
 884 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
 885 {
 886   dw_cfi_ref cfi;
 887
 888   if (size == old_args_size)
 889     return;
 890
 891   old_args_size = size;
 892
 893   cfi = new_cfi ();
 894   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
 895   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
 896   add_fde_cfi (label, cfi);
 897 }
 898
 899 /* Entry point for saving a register to the stack.  REG is the GCC register
 900    number.  LABEL and OFFSET are passed to reg_save.  */
 901
 902 void
 903 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 904 {
 905   reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
 906 }
 907
 908 /* Entry point for saving the return address in the stack.
 909    LABEL and OFFSET are passed to reg_save.  */
 910
 911 void
 912 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
 913 {
 914   reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
 915 }
 916
 917 /* Entry point for saving the return address in a register.
 918    LABEL and SREG are passed to reg_save.  */
 919
 920 void
 921 dwarf2out_return_reg (const char *label, unsigned int sreg)
 922 {
 923   reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
 924 }
 925
 926 /* Record the initial position of the return address.  RTL is
 927    INCOMING_RETURN_ADDR_RTX.  */
 928
 929 static void
 930 initial_return_save (rtx rtl)
 931 {
 932   unsigned int reg = INVALID_REGNUM;
 933   HOST_WIDE_INT offset = 0;
 934
 935   switch (GET_CODE (rtl))
 936     {
 937     case REG:
 938       /* RA is in a register.  */
 939       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
 940       break;
 941
 942     case MEM:
 943       /* RA is on the stack.  */
 944       rtl = XEXP (rtl, 0);
 945       switch (GET_CODE (rtl))
 946         {
 947         case REG:
 948           gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
 949           offset = 0;
 950           break;
 951
 952         case PLUS:
 953           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 954           offset = INTVAL (XEXP (rtl, 1));
 955           break;
 956
 957         case MINUS:
 958           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 959           offset = -INTVAL (XEXP (rtl, 1));
 960           break;
 961
 962         default:
 963           gcc_unreachable ();
 964         }
 965
 966       break;
 967
 968     case PLUS:
 969       /* The return address is at some offset from any value we can
 970          actually load.  For instance, on the SPARC it is in %i7+8. Just
 971          ignore the offset for now; it doesn't matter for unwinding frames.  */
 972       gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
 973       initial_return_save (XEXP (rtl, 0));
 974       return;
 975
 976     default:
 977       gcc_unreachable ();
 978     }
 979
 980   if (reg != DWARF_FRAME_RETURN_COLUMN)
 981     reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
 982 }
 983
 984 /* Given a SET, calculate the amount of stack adjustment it
 985    contains.  */
 986
 987 static HOST_WIDE_INT
 988 stack_adjust_offset (rtx pattern)
 989 {
 990   rtx src = SET_SRC (pattern);
 991   rtx dest = SET_DEST (pattern);
 992   HOST_WIDE_INT offset = 0;
 993   enum rtx_code code;
 994
 995   if (dest == stack_pointer_rtx)
 996     {
 997       /* (set (reg sp) (plus (reg sp) (const_int))) */
 998       code = GET_CODE (src);
 999       if (! (code == PLUS || code == MINUS)
1000           || XEXP (src, 0) != stack_pointer_rtx
1001           || GET_CODE (XEXP (src, 1)) != CONST_INT)
1002         return 0;
1003
1004       offset = INTVAL (XEXP (src, 1));
1005       if (code == PLUS)
1006         offset = -offset;
1007     }
1008   else if (MEM_P (dest))
1009     {
1010       /* (set (mem (pre_dec (reg sp))) (foo)) */
1011       src = XEXP (dest, 0);
1012       code = GET_CODE (src);
1013
1014       switch (code)
1015         {
1016         case PRE_MODIFY:
1017         case POST_MODIFY:
1018           if (XEXP (src, 0) == stack_pointer_rtx)
1019             {
1020               rtx val = XEXP (XEXP (src, 1), 1);
1021               /* We handle only adjustments by constant amount.  */
1022               gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1023                           && GET_CODE (val) == CONST_INT);
1024               offset = -INTVAL (val);
1025               break;
1026             }
1027           return 0;
1028
1029         case PRE_DEC:
1030         case POST_DEC:
1031           if (XEXP (src, 0) == stack_pointer_rtx)
1032             {
1033               offset = GET_MODE_SIZE (GET_MODE (dest));
1034               break;
1035             }
1036           return 0;
1037
1038         case PRE_INC:
1039         case POST_INC:
1040           if (XEXP (src, 0) == stack_pointer_rtx)
1041             {
1042               offset = -GET_MODE_SIZE (GET_MODE (dest));
1043               break;
1044             }
1045           return 0;
1046
1047         default:
1048           return 0;
1049         }
1050     }
1051   else
1052     return 0;
1053
1054   return offset;
1055 }
1056
1057 /* Check INSN to see if it looks like a push or a stack adjustment, and
1058    make a note of it if it does.  EH uses this information to find out how
1059    much extra space it needs to pop off the stack.  */
1060
1061 static void
1062 dwarf2out_stack_adjust (rtx insn, bool after_p)
1063 {
1064   HOST_WIDE_INT offset;
1065   const char *label;
1066   int i;
1067
1068   /* Don't handle epilogues at all.  Certainly it would be wrong to do so
1069      with this function.  Proper support would require all frame-related
1070      insns to be marked, and to be able to handle saving state around
1071      epilogues textually in the middle of the function.  */
1072   if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1073     return;
1074
1075   /* If only calls can throw, and we have a frame pointer,
1076      save up adjustments until we see the CALL_INSN.  */
1077   if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1078     {
1079       if (CALL_P (insn) && !after_p)
1080         {
1081           /* Extract the size of the args from the CALL rtx itself.  */
1082           insn = PATTERN (insn);
1083           if (GET_CODE (insn) == PARALLEL)
1084             insn = XVECEXP (insn, 0, 0);
1085           if (GET_CODE (insn) == SET)
1086             insn = SET_SRC (insn);
1087           gcc_assert (GET_CODE (insn) == CALL);
1088           dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1089         }
1090       return;
1091     }
1092
1093   if (CALL_P (insn) && !after_p)
1094     {
1095       if (!flag_asynchronous_unwind_tables)
1096         dwarf2out_args_size ("", args_size);
1097       return;
1098     }
1099   else if (BARRIER_P (insn))
1100     {
1101       /* When we see a BARRIER, we know to reset args_size to 0.  Usually
1102          the compiler will have already emitted a stack adjustment, but
1103          doesn't bother for calls to noreturn functions.  */
1104 #ifdef STACK_GROWS_DOWNWARD
1105       offset = -args_size;
1106 #else
1107       offset = args_size;
1108 #endif
1109     }
1110   else if (GET_CODE (PATTERN (insn)) == SET)
1111     offset = stack_adjust_offset (PATTERN (insn));
1112   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1113            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1114     {
1115       /* There may be stack adjustments inside compound insns.  Search
1116          for them.  */
1117       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1118         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1119           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1120     }
1121   else
1122     return;
1123
1124   if (offset == 0)
1125     return;
1126
1127   if (cfa.reg == STACK_POINTER_REGNUM)
1128     cfa.offset += offset;
1129
1130 #ifndef STACK_GROWS_DOWNWARD
1131   offset = -offset;
1132 #endif
1133
1134   args_size += offset;
1135   if (args_size < 0)
1136     args_size = 0;
1137
1138   label = dwarf2out_cfi_label ();
1139   def_cfa_1 (label, &cfa);
1140   if (flag_asynchronous_unwind_tables)
1141     dwarf2out_args_size (label, args_size);
1142 }
1143
1144 #endif
1145
1146 /* We delay emitting a register save until either (a) we reach the end
1147    of the prologue or (b) the register is clobbered.  This clusters
1148    register saves so that there are fewer pc advances.  */
1149
1150 struct queued_reg_save GTY(())
1151 {
1152   struct queued_reg_save *next;
1153   rtx reg;
1154   HOST_WIDE_INT cfa_offset;
1155   rtx saved_reg;
1156 };
1157
1158 static GTY(()) struct queued_reg_save *queued_reg_saves;
1159
1160 /* The caller's ORIG_REG is saved in SAVED_IN_REG.  */
1161 struct reg_saved_in_data GTY(()) {
1162   rtx orig_reg;
1163   rtx saved_in_reg;
1164 };
1165
1166 /* A list of registers saved in other registers.
1167    The list intentionally has a small maximum capacity of 4; if your
1168    port needs more than that, you might consider implementing a
1169    more efficient data structure.  */
1170 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1171 static GTY(()) size_t num_regs_saved_in_regs;
1172
1173 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1174 static const char *last_reg_save_label;
1175
1176 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1177    SREG, or if SREG is NULL then it is saved at OFFSET to the CFA.  */
1178
1179 static void
1180 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1181 {
1182   struct queued_reg_save *q;
1183
1184   /* Duplicates waste space, but it's also necessary to remove them
1185      for correctness, since the queue gets output in reverse
1186      order.  */
1187   for (q = queued_reg_saves; q != NULL; q = q->next)
1188     if (REGNO (q->reg) == REGNO (reg))
1189       break;
1190
1191   if (q == NULL)
1192     {
1193       q = ggc_alloc (sizeof (*q));
1194       q->next = queued_reg_saves;
1195       queued_reg_saves = q;
1196     }
1197
1198   q->reg = reg;
1199   q->cfa_offset = offset;
1200   q->saved_reg = sreg;
1201
1202   last_reg_save_label = label;
1203 }
1204
1205 /* Output all the entries in QUEUED_REG_SAVES.  */
1206
1207 static void
1208 flush_queued_reg_saves (void)
1209 {
1210   struct queued_reg_save *q;
1211
1212   for (q = queued_reg_saves; q; q = q->next)
1213     {
1214       size_t i;
1215       unsigned int reg, sreg;
1216
1217       for (i = 0; i < num_regs_saved_in_regs; i++)
1218         if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1219           break;
1220       if (q->saved_reg && i == num_regs_saved_in_regs)
1221         {
1222           gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1223           num_regs_saved_in_regs++;
1224         }
1225       if (i != num_regs_saved_in_regs)
1226         {
1227           regs_saved_in_regs[i].orig_reg = q->reg;
1228           regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1229         }
1230
1231       reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1232       if (q->saved_reg)
1233         sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1234       else
1235         sreg = INVALID_REGNUM;
1236       reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1237     }
1238
1239   queued_reg_saves = NULL;
1240   last_reg_save_label = NULL;
1241 }
1242
1243 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1244    location for?  Or, does it clobber a register which we've previously
1245    said that some other register is saved in, and for which we now
1246    have a new location for?  */
1247
1248 static bool
1249 clobbers_queued_reg_save (rtx insn)
1250 {
1251   struct queued_reg_save *q;
1252
1253   for (q = queued_reg_saves; q; q = q->next)
1254     {
1255       size_t i;
1256       if (modified_in_p (q->reg, insn))
1257         return true;
1258       for (i = 0; i < num_regs_saved_in_regs; i++)
1259         if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1260             && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1261           return true;
1262     }
1263
1264   return false;
1265 }
1266
1267 /* Entry point for saving the first register into the second.  */
1268
1269 void
1270 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1271 {
1272   size_t i;
1273   unsigned int regno, sregno;
1274
1275   for (i = 0; i < num_regs_saved_in_regs; i++)
1276     if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1277       break;
1278   if (i == num_regs_saved_in_regs)
1279     {
1280       gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1281       num_regs_saved_in_regs++;
1282     }
1283   regs_saved_in_regs[i].orig_reg = reg;
1284   regs_saved_in_regs[i].saved_in_reg = sreg;
1285
1286   regno = DWARF_FRAME_REGNUM (REGNO (reg));
1287   sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1288   reg_save (label, regno, sregno, 0);
1289 }
1290
1291 /* What register, if any, is currently saved in REG?  */
1292
1293 static rtx
1294 reg_saved_in (rtx reg)
1295 {
1296   unsigned int regn = REGNO (reg);
1297   size_t i;
1298   struct queued_reg_save *q;
1299
1300   for (q = queued_reg_saves; q; q = q->next)
1301     if (q->saved_reg && regn == REGNO (q->saved_reg))
1302       return q->reg;
1303
1304   for (i = 0; i < num_regs_saved_in_regs; i++)
1305     if (regs_saved_in_regs[i].saved_in_reg
1306         && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1307       return regs_saved_in_regs[i].orig_reg;
1308
1309   return NULL_RTX;
1310 }
1311
1312
1313 /* A temporary register holding an integral value used in adjusting SP
1314    or setting up the store_reg.  The "offset" field holds the integer
1315    value, not an offset.  */
1316 static dw_cfa_location cfa_temp;
1317
1318 /* Record call frame debugging information for an expression EXPR,
1319    which either sets SP or FP (adjusting how we calculate the frame
1320    address) or saves a register to the stack or another register.
1321    LABEL indicates the address of EXPR.
1322
1323    This function encodes a state machine mapping rtxes to actions on
1324    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
1325    users need not read the source code.
1326
1327   The High-Level Picture
1328
1329   Changes in the register we use to calculate the CFA: Currently we
1330   assume that if you copy the CFA register into another register, we
1331   should take the other one as the new CFA register; this seems to
1332   work pretty well.  If it's wrong for some target, it's simple
1333   enough not to set RTX_FRAME_RELATED_P on the insn in question.
1334
1335   Changes in the register we use for saving registers to the stack:
1336   This is usually SP, but not always.  Again, we deduce that if you
1337   copy SP into another register (and SP is not the CFA register),
1338   then the new register is the one we will be using for register
1339   saves.  This also seems to work.
1340
1341   Register saves: There's not much guesswork about this one; if
1342   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1343   register save, and the register used to calculate the destination
1344   had better be the one we think we're using for this purpose.
1345   It's also assumed that a copy from a call-saved register to another
1346   register is saving that register if RTX_FRAME_RELATED_P is set on
1347   that instruction.  If the copy is from a call-saved register to
1348   the *same* register, that means that the register is now the same
1349   value as in the caller.
1350
1351   Except: If the register being saved is the CFA register, and the
1352   offset is nonzero, we are saving the CFA, so we assume we have to
1353   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
1354   the intent is to save the value of SP from the previous frame.
1355
1356   In addition, if a register has previously been saved to a different
1357   register,
1358
1359   Invariants / Summaries of Rules
1360
1361   cfa          current rule for calculating the CFA.  It usually
1362                consists of a register and an offset.
1363   cfa_store    register used by prologue code to save things to the stack
1364                cfa_store.offset is the offset from the value of
1365                cfa_store.reg to the actual CFA
1366   cfa_temp     register holding an integral value.  cfa_temp.offset
1367                stores the value, which will be used to adjust the
1368                stack pointer.  cfa_temp is also used like cfa_store,
1369                to track stores to the stack via fp or a temp reg.
1370
1371   Rules  1- 4: Setting a register's value to cfa.reg or an expression
1372                with cfa.reg as the first operand changes the cfa.reg and its
1373                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
1374                cfa_temp.offset.
1375
1376   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
1377                expression yielding a constant.  This sets cfa_temp.reg
1378                and cfa_temp.offset.
1379
1380   Rule 5:      Create a new register cfa_store used to save items to the
1381                stack.
1382
1383   Rules 10-14: Save a register to the stack.  Define offset as the
1384                difference of the original location and cfa_store's
1385                location (or cfa_temp's location if cfa_temp is used).
1386
1387   The Rules
1388
1389   "{a,b}" indicates a choice of a xor b.
1390   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1391
1392   Rule 1:
1393   (set <reg1> <reg2>:cfa.reg)
1394   effects: cfa.reg = <reg1>
1395            cfa.offset unchanged
1396            cfa_temp.reg = <reg1>
1397            cfa_temp.offset = cfa.offset
1398
1399   Rule 2:
1400   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1401                               {<const_int>,<reg>:cfa_temp.reg}))
1402   effects: cfa.reg = sp if fp used
1403            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1404            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1405              if cfa_store.reg==sp
1406
1407   Rule 3:
1408   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1409   effects: cfa.reg = fp
1410            cfa_offset += +/- <const_int>
1411
1412   Rule 4:
1413   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1414   constraints: <reg1> != fp
1415                <reg1> != sp
1416   effects: cfa.reg = <reg1>
1417            cfa_temp.reg = <reg1>
1418            cfa_temp.offset = cfa.offset
1419
1420   Rule 5:
1421   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1422   constraints: <reg1> != fp
1423                <reg1> != sp
1424   effects: cfa_store.reg = <reg1>
1425            cfa_store.offset = cfa.offset - cfa_temp.offset
1426
1427   Rule 6:
1428   (set <reg> <const_int>)
1429   effects: cfa_temp.reg = <reg>
1430            cfa_temp.offset = <const_int>
1431
1432   Rule 7:
1433   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1434   effects: cfa_temp.reg = <reg1>
1435            cfa_temp.offset |= <const_int>
1436
1437   Rule 8:
1438   (set <reg> (high <exp>))
1439   effects: none
1440
1441   Rule 9:
1442   (set <reg> (lo_sum <exp> <const_int>))
1443   effects: cfa_temp.reg = <reg>
1444            cfa_temp.offset = <const_int>
1445
1446   Rule 10:
1447   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1448   effects: cfa_store.offset -= <const_int>
1449            cfa.offset = cfa_store.offset if cfa.reg == sp
1450            cfa.reg = sp
1451            cfa.base_offset = -cfa_store.offset
1452
1453   Rule 11:
1454   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1455   effects: cfa_store.offset += -/+ mode_size(mem)
1456            cfa.offset = cfa_store.offset if cfa.reg == sp
1457            cfa.reg = sp
1458            cfa.base_offset = -cfa_store.offset
1459
1460   Rule 12:
1461   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1462
1463        <reg2>)
1464   effects: cfa.reg = <reg1>
1465            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1466
1467   Rule 13:
1468   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1469   effects: cfa.reg = <reg1>
1470            cfa.base_offset = -{cfa_store,cfa_temp}.offset
1471
1472   Rule 14:
1473   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1474   effects: cfa.reg = <reg1>
1475            cfa.base_offset = -cfa_temp.offset
1476            cfa_temp.offset -= mode_size(mem)
1477
1478   Rule 15:
1479   (set <reg> {unspec, unspec_volatile})
1480   effects: target-dependent  */
1481
1482 static void
1483 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1484 {
1485   rtx src, dest;
1486   HOST_WIDE_INT offset;
1487
1488   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1489      the PARALLEL independently. The first element is always processed if
1490      it is a SET. This is for backward compatibility.   Other elements
1491      are processed only if they are SETs and the RTX_FRAME_RELATED_P
1492      flag is set in them.  */
1493   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1494     {
1495       int par_index;
1496       int limit = XVECLEN (expr, 0);
1497
1498       for (par_index = 0; par_index < limit; par_index++)
1499         if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1500             && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1501                 || par_index == 0))
1502           dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1503
1504       return;
1505     }
1506
1507   gcc_assert (GET_CODE (expr) == SET);
1508
1509   src = SET_SRC (expr);
1510   dest = SET_DEST (expr);
1511
1512   if (REG_P (src))
1513     {
1514       rtx rsi = reg_saved_in (src);
1515       if (rsi)
1516         src = rsi;
1517     }
1518
1519   switch (GET_CODE (dest))
1520     {
1521     case REG:
1522       switch (GET_CODE (src))
1523         {
1524           /* Setting FP from SP.  */
1525         case REG:
1526           if (cfa.reg == (unsigned) REGNO (src))
1527             {
1528               /* Rule 1 */
1529               /* Update the CFA rule wrt SP or FP.  Make sure src is
1530                  relative to the current CFA register.
1531
1532                  We used to require that dest be either SP or FP, but the
1533                  ARM copies SP to a temporary register, and from there to
1534                  FP.  So we just rely on the backends to only set
1535                  RTX_FRAME_RELATED_P on appropriate insns.  */
1536               cfa.reg = REGNO (dest);
1537               cfa_temp.reg = cfa.reg;
1538               cfa_temp.offset = cfa.offset;
1539             }
1540           else
1541             {
1542               /* Saving a register in a register.  */
1543               gcc_assert (!fixed_regs [REGNO (dest)]
1544                           /* For the SPARC and its register window.  */
1545                           || (DWARF_FRAME_REGNUM (REGNO (src))
1546                               == DWARF_FRAME_RETURN_COLUMN));
1547               queue_reg_save (label, src, dest, 0);
1548             }
1549           break;
1550
1551         case PLUS:
1552         case MINUS:
1553         case LO_SUM:
1554           if (dest == stack_pointer_rtx)
1555             {
1556               /* Rule 2 */
1557               /* Adjusting SP.  */
1558               switch (GET_CODE (XEXP (src, 1)))
1559                 {
1560                 case CONST_INT:
1561                   offset = INTVAL (XEXP (src, 1));
1562                   break;
1563                 case REG:
1564                   gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1565                               == cfa_temp.reg);
1566                   offset = cfa_temp.offset;
1567                   break;
1568                 default:
1569                   gcc_unreachable ();
1570                 }
1571
1572               if (XEXP (src, 0) == hard_frame_pointer_rtx)
1573                 {
1574                   /* Restoring SP from FP in the epilogue.  */
1575                   gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1576                   cfa.reg = STACK_POINTER_REGNUM;
1577                 }
1578               else if (GET_CODE (src) == LO_SUM)
1579                 /* Assume we've set the source reg of the LO_SUM from sp.  */
1580                 ;
1581               else
1582                 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1583
1584               if (GET_CODE (src) != MINUS)
1585                 offset = -offset;
1586               if (cfa.reg == STACK_POINTER_REGNUM)
1587                 cfa.offset += offset;
1588               if (cfa_store.reg == STACK_POINTER_REGNUM)
1589                 cfa_store.offset += offset;
1590             }
1591           else if (dest == hard_frame_pointer_rtx)
1592             {
1593               /* Rule 3 */
1594               /* Either setting the FP from an offset of the SP,
1595                  or adjusting the FP */
1596               gcc_assert (frame_pointer_needed);
1597
1598               gcc_assert (REG_P (XEXP (src, 0))
1599                           && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1600                           && GET_CODE (XEXP (src, 1)) == CONST_INT);
1601               offset = INTVAL (XEXP (src, 1));
1602               if (GET_CODE (src) != MINUS)
1603                 offset = -offset;
1604               cfa.offset += offset;
1605               cfa.reg = HARD_FRAME_POINTER_REGNUM;
1606             }
1607           else
1608             {
1609               gcc_assert (GET_CODE (src) != MINUS);
1610
1611               /* Rule 4 */
1612               if (REG_P (XEXP (src, 0))
1613                   && REGNO (XEXP (src, 0)) == cfa.reg
1614                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1615                 {
1616                   /* Setting a temporary CFA register that will be copied
1617                      into the FP later on.  */
1618                   offset = - INTVAL (XEXP (src, 1));
1619                   cfa.offset += offset;
1620                   cfa.reg = REGNO (dest);
1621                   /* Or used to save regs to the stack.  */
1622                   cfa_temp.reg = cfa.reg;
1623                   cfa_temp.offset = cfa.offset;
1624                 }
1625
1626               /* Rule 5 */
1627               else if (REG_P (XEXP (src, 0))
1628                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
1629                        && XEXP (src, 1) == stack_pointer_rtx)
1630                 {
1631                   /* Setting a scratch register that we will use instead
1632                      of SP for saving registers to the stack.  */
1633                   gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1634                   cfa_store.reg = REGNO (dest);
1635                   cfa_store.offset = cfa.offset - cfa_temp.offset;
1636                 }
1637
1638               /* Rule 9 */
1639               else if (GET_CODE (src) == LO_SUM
1640                        && GET_CODE (XEXP (src, 1)) == CONST_INT)
1641                 {
1642                   cfa_temp.reg = REGNO (dest);
1643                   cfa_temp.offset = INTVAL (XEXP (src, 1));
1644                 }
1645               else
1646                 gcc_unreachable ();
1647             }
1648           break;
1649
1650           /* Rule 6 */
1651         case CONST_INT:
1652           cfa_temp.reg = REGNO (dest);
1653           cfa_temp.offset = INTVAL (src);
1654           break;
1655
1656           /* Rule 7 */
1657         case IOR:
1658           gcc_assert (REG_P (XEXP (src, 0))
1659                       && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1660                       && GET_CODE (XEXP (src, 1)) == CONST_INT);
1661
1662           if ((unsigned) REGNO (dest) != cfa_temp.reg)
1663             cfa_temp.reg = REGNO (dest);
1664           cfa_temp.offset |= INTVAL (XEXP (src, 1));
1665           break;
1666
1667           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1668              which will fill in all of the bits.  */
1669           /* Rule 8 */
1670         case HIGH:
1671           break;
1672
1673           /* Rule 15 */
1674         case UNSPEC:
1675         case UNSPEC_VOLATILE:
1676           gcc_assert (targetm.dwarf_handle_frame_unspec);
1677           targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1678           return;
1679
1680         default:
1681           gcc_unreachable ();
1682         }
1683
1684       def_cfa_1 (label, &cfa);
1685       break;
1686
1687     case MEM:
1688       gcc_assert (REG_P (src));
1689
1690       /* Saving a register to the stack.  Make sure dest is relative to the
1691          CFA register.  */
1692       switch (GET_CODE (XEXP (dest, 0)))
1693         {
1694           /* Rule 10 */
1695           /* With a push.  */
1696         case PRE_MODIFY:
1697           /* We can't handle variable size modifications.  */
1698           gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1699                       == CONST_INT);
1700           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1701
1702           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1703                       && cfa_store.reg == STACK_POINTER_REGNUM);
1704
1705           cfa_store.offset += offset;
1706           if (cfa.reg == STACK_POINTER_REGNUM)
1707             cfa.offset = cfa_store.offset;
1708
1709           offset = -cfa_store.offset;
1710           break;
1711
1712           /* Rule 11 */
1713         case PRE_INC:
1714         case PRE_DEC:
1715           offset = GET_MODE_SIZE (GET_MODE (dest));
1716           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1717             offset = -offset;
1718
1719           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1720                       && cfa_store.reg == STACK_POINTER_REGNUM);
1721
1722           cfa_store.offset += offset;
1723           if (cfa.reg == STACK_POINTER_REGNUM)
1724             cfa.offset = cfa_store.offset;
1725
1726           offset = -cfa_store.offset;
1727           break;
1728
1729           /* Rule 12 */
1730           /* With an offset.  */
1731         case PLUS:
1732         case MINUS:
1733         case LO_SUM:
1734           {
1735             int regno;
1736
1737             gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
1738                         && REG_P (XEXP (XEXP (dest, 0), 0)));
1739             offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1740             if (GET_CODE (XEXP (dest, 0)) == MINUS)
1741               offset = -offset;
1742
1743             regno = REGNO (XEXP (XEXP (dest, 0), 0));
1744
1745             if (cfa_store.reg == (unsigned) regno)
1746               offset -= cfa_store.offset;
1747             else
1748               {
1749                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1750                 offset -= cfa_temp.offset;
1751               }
1752           }
1753           break;
1754
1755           /* Rule 13 */
1756           /* Without an offset.  */
1757         case REG:
1758           {
1759             int regno = REGNO (XEXP (dest, 0));
1760
1761             if (cfa_store.reg == (unsigned) regno)
1762               offset = -cfa_store.offset;
1763             else
1764               {
1765                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1766                 offset = -cfa_temp.offset;
1767               }
1768           }
1769           break;
1770
1771           /* Rule 14 */
1772         case POST_INC:
1773           gcc_assert (cfa_temp.reg
1774                       == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1775           offset = -cfa_temp.offset;
1776           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1777           break;
1778
1779         default:
1780           gcc_unreachable ();
1781         }
1782
1783       if (REGNO (src) != STACK_POINTER_REGNUM
1784           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1785           && (unsigned) REGNO (src) == cfa.reg)
1786         {
1787           /* We're storing the current CFA reg into the stack.  */
1788
1789           if (cfa.offset == 0)
1790             {
1791               /* If the source register is exactly the CFA, assume
1792                  we're saving SP like any other register; this happens
1793                  on the ARM.  */
1794               def_cfa_1 (label, &cfa);
1795               queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1796               break;
1797             }
1798           else
1799             {
1800               /* Otherwise, we'll need to look in the stack to
1801                  calculate the CFA.  */
1802               rtx x = XEXP (dest, 0);
1803
1804               if (!REG_P (x))
1805                 x = XEXP (x, 0);
1806               gcc_assert (REG_P (x));
1807
1808               cfa.reg = REGNO (x);
1809               cfa.base_offset = offset;
1810               cfa.indirect = 1;
1811               def_cfa_1 (label, &cfa);
1812               break;
1813             }
1814         }
1815
1816       def_cfa_1 (label, &cfa);
1817       queue_reg_save (label, src, NULL_RTX, offset);
1818       break;
1819
1820     default:
1821       gcc_unreachable ();
1822     }
1823 }
1824
1825 /* Record call frame debugging information for INSN, which either
1826    sets SP or FP (adjusting how we calculate the frame address) or saves a
1827    register to the stack.  If INSN is NULL_RTX, initialize our state.
1828
1829    If AFTER_P is false, we're being called before the insn is emitted,
1830    otherwise after.  Call instructions get invoked twice.  */
1831
1832 void
1833 dwarf2out_frame_debug (rtx insn, bool after_p)
1834 {
1835   const char *label;
1836   rtx src;
1837
1838   if (insn == NULL_RTX)
1839     {
1840       size_t i;
1841
1842       /* Flush any queued register saves.  */
1843       flush_queued_reg_saves ();
1844
1845       /* Set up state for generating call frame debug info.  */
1846       lookup_cfa (&cfa);
1847       gcc_assert (cfa.reg
1848                   == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1849
1850       cfa.reg = STACK_POINTER_REGNUM;
1851       cfa_store = cfa;
1852       cfa_temp.reg = -1;
1853       cfa_temp.offset = 0;
1854
1855       for (i = 0; i < num_regs_saved_in_regs; i++)
1856         {
1857           regs_saved_in_regs[i].orig_reg = NULL_RTX;
1858           regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1859         }
1860       num_regs_saved_in_regs = 0;
1861       return;
1862     }
1863
1864   if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1865     flush_queued_reg_saves ();
1866
1867   if (! RTX_FRAME_RELATED_P (insn))
1868     {
1869       if (!ACCUMULATE_OUTGOING_ARGS)
1870         dwarf2out_stack_adjust (insn, after_p);
1871       return;
1872     }
1873
1874   label = dwarf2out_cfi_label ();
1875   src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1876   if (src)
1877     insn = XEXP (src, 0);
1878   else
1879     insn = PATTERN (insn);
1880
1881   dwarf2out_frame_debug_expr (insn, label);
1882 }
1883
1884 #endif
1885
1886 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
1887 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1888  (enum dwarf_call_frame_info cfi);
1889
1890 static enum dw_cfi_oprnd_type
1891 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1892 {
1893   switch (cfi)
1894     {
1895     case DW_CFA_nop:
1896     case DW_CFA_GNU_window_save:
1897       return dw_cfi_oprnd_unused;
1898
1899     case DW_CFA_set_loc:
1900     case DW_CFA_advance_loc1:
1901     case DW_CFA_advance_loc2:
1902     case DW_CFA_advance_loc4:
1903     case DW_CFA_MIPS_advance_loc8:
1904       return dw_cfi_oprnd_addr;
1905
1906     case DW_CFA_offset:
1907     case DW_CFA_offset_extended:
1908     case DW_CFA_def_cfa:
1909     case DW_CFA_offset_extended_sf:
1910     case DW_CFA_def_cfa_sf:
1911     case DW_CFA_restore_extended:
1912     case DW_CFA_undefined:
1913     case DW_CFA_same_value:
1914     case DW_CFA_def_cfa_register:
1915     case DW_CFA_register:
1916       return dw_cfi_oprnd_reg_num;
1917
1918     case DW_CFA_def_cfa_offset:
1919     case DW_CFA_GNU_args_size:
1920     case DW_CFA_def_cfa_offset_sf:
1921       return dw_cfi_oprnd_offset;
1922
1923     case DW_CFA_def_cfa_expression:
1924     case DW_CFA_expression:
1925       return dw_cfi_oprnd_loc;
1926
1927     default:
1928       gcc_unreachable ();
1929     }
1930 }
1931
1932 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
1933 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1934  (enum dwarf_call_frame_info cfi);
1935
1936 static enum dw_cfi_oprnd_type
1937 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1938 {
1939   switch (cfi)
1940     {
1941     case DW_CFA_def_cfa:
1942     case DW_CFA_def_cfa_sf:
1943     case DW_CFA_offset:
1944     case DW_CFA_offset_extended_sf:
1945     case DW_CFA_offset_extended:
1946       return dw_cfi_oprnd_offset;
1947
1948     case DW_CFA_register:
1949       return dw_cfi_oprnd_reg_num;
1950
1951     default:
1952       return dw_cfi_oprnd_unused;
1953     }
1954 }
1955
1956 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1957
1958 /* Switch to eh_frame_section.  If we don't have an eh_frame_section,
1959    switch to the data section instead, and write out a synthetic label
1960    for collect2.  */
1961
1962 static void
1963 switch_to_eh_frame_section (void)
1964 {
1965   tree label;
1966
1967 #ifdef EH_FRAME_SECTION_NAME
1968   if (eh_frame_section == 0)
1969     {
1970       int flags;
1971
1972       if (EH_TABLES_CAN_BE_READ_ONLY)
1973         {
1974           int fde_encoding;
1975           int per_encoding;
1976           int lsda_encoding;
1977
1978           fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
1979                                                        /*global=*/0);
1980           per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
1981                                                        /*global=*/1);
1982           lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
1983                                                         /*global=*/0);
1984           flags = ((! flag_pic
1985                     || ((fde_encoding & 0x70) != DW_EH_PE_absptr
1986                         && (fde_encoding & 0x70) != DW_EH_PE_aligned
1987                         && (per_encoding & 0x70) != DW_EH_PE_absptr
1988                         && (per_encoding & 0x70) != DW_EH_PE_aligned
1989                         && (lsda_encoding & 0x70) != DW_EH_PE_absptr
1990                         && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
1991                    ? 0 : SECTION_WRITE);
1992         }
1993       else
1994         flags = SECTION_WRITE;
1995       eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
1996     }
1997 #endif
1998
1999   if (eh_frame_section)
2000     switch_to_section (eh_frame_section);
2001   else
2002     {
2003       /* We have no special eh_frame section.  Put the information in
2004          the data section and emit special labels to guide collect2.  */
2005       switch_to_section (data_section);
2006       label = get_file_function_name ('F');
2007       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2008       targetm.asm_out.globalize_label (asm_out_file,
2009                                        IDENTIFIER_POINTER (label));
2010       ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2011     }
2012 }
2013
2014 /* Map register numbers held in the call frame info that gcc has
2015    collected using DWARF_FRAME_REGNUM to those that should be output in
2016    .debug_frame and .eh_frame.  */
2017 #ifndef DWARF2_FRAME_REG_OUT
2018 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
2019 #endif
2020
2021 /* Output a Call Frame Information opcode and its operand(s).  */
2022
2023 static void
2024 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2025 {
2026   unsigned long r;
2027   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2028     dw2_asm_output_data (1, (cfi->dw_cfi_opc
2029                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2030                          "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2031                          cfi->dw_cfi_oprnd1.dw_cfi_offset);
2032   else if (cfi->dw_cfi_opc == DW_CFA_offset)
2033     {
2034       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2035       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2036                            "DW_CFA_offset, column 0x%lx", r);
2037       dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2038     }
2039   else if (cfi->dw_cfi_opc == DW_CFA_restore)
2040     {
2041       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2042       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2043                            "DW_CFA_restore, column 0x%lx", r);
2044     }
2045   else
2046     {
2047       dw2_asm_output_data (1, cfi->dw_cfi_opc,
2048                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2049
2050       switch (cfi->dw_cfi_opc)
2051         {
2052         case DW_CFA_set_loc:
2053           if (for_eh)
2054             dw2_asm_output_encoded_addr_rtx (
2055                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2056                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2057                 false, NULL);
2058           else
2059             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2060                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2061           break;
2062
2063         case DW_CFA_advance_loc1:
2064           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2065                                 fde->dw_fde_current_label, NULL);
2066           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2067           break;
2068
2069         case DW_CFA_advance_loc2:
2070           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2071                                 fde->dw_fde_current_label, NULL);
2072           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2073           break;
2074
2075         case DW_CFA_advance_loc4:
2076           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2077                                 fde->dw_fde_current_label, NULL);
2078           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2079           break;
2080
2081         case DW_CFA_MIPS_advance_loc8:
2082           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2083                                 fde->dw_fde_current_label, NULL);
2084           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2085           break;
2086
2087         case DW_CFA_offset_extended:
2088         case DW_CFA_def_cfa:
2089           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2090           dw2_asm_output_data_uleb128 (r, NULL);
2091           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2092           break;
2093
2094         case DW_CFA_offset_extended_sf:
2095         case DW_CFA_def_cfa_sf:
2096           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2097           dw2_asm_output_data_uleb128 (r, NULL);
2098           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2099           break;
2100
2101         case DW_CFA_restore_extended:
2102         case DW_CFA_undefined:
2103         case DW_CFA_same_value:
2104         case DW_CFA_def_cfa_register:
2105           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2106           dw2_asm_output_data_uleb128 (r, NULL);
2107           break;
2108
2109         case DW_CFA_register:
2110           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2111           dw2_asm_output_data_uleb128 (r, NULL);
2112           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2113           dw2_asm_output_data_uleb128 (r, NULL);
2114           break;
2115
2116         case DW_CFA_def_cfa_offset:
2117         case DW_CFA_GNU_args_size:
2118           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2119           break;
2120
2121         case DW_CFA_def_cfa_offset_sf:
2122           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2123           break;
2124
2125         case DW_CFA_GNU_window_save:
2126           break;
2127
2128         case DW_CFA_def_cfa_expression:
2129         case DW_CFA_expression:
2130           output_cfa_loc (cfi);
2131           break;
2132
2133         case DW_CFA_GNU_negative_offset_extended:
2134           /* Obsoleted by DW_CFA_offset_extended_sf.  */
2135           gcc_unreachable ();
2136
2137         default:
2138           break;
2139         }
2140     }
2141 }
2142
2143 /* Output the call frame information used to record information
2144    that relates to calculating the frame pointer, and records the
2145    location of saved registers.  */
2146
2147 static void
2148 output_call_frame_info (int for_eh)
2149 {
2150   unsigned int i;
2151   dw_fde_ref fde;
2152   dw_cfi_ref cfi;
2153   char l1[20], l2[20], section_start_label[20];
2154   bool any_lsda_needed = false;
2155   char augmentation[6];
2156   int augmentation_size;
2157   int fde_encoding = DW_EH_PE_absptr;
2158   int per_encoding = DW_EH_PE_absptr;
2159   int lsda_encoding = DW_EH_PE_absptr;
2160   int return_reg;
2161
2162   /* Don't emit a CIE if there won't be any FDEs.  */
2163   if (fde_table_in_use == 0)
2164     return;
2165
2166   /* If we make FDEs linkonce, we may have to emit an empty label for
2167      an FDE that wouldn't otherwise be emitted.  We want to avoid
2168      having an FDE kept around when the function it refers to is
2169      discarded.  Example where this matters: a primary function
2170      template in C++ requires EH information, but an explicit
2171      specialization doesn't.  */
2172   if (TARGET_USES_WEAK_UNWIND_INFO
2173       && ! flag_asynchronous_unwind_tables
2174       && for_eh)
2175     for (i = 0; i < fde_table_in_use; i++)
2176       if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2177           && !fde_table[i].uses_eh_lsda
2178           && ! DECL_WEAK (fde_table[i].decl))
2179         targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2180                                       for_eh, /* empty */ 1);
2181
2182   /* If we don't have any functions we'll want to unwind out of, don't
2183      emit any EH unwind information.  Note that if exceptions aren't
2184      enabled, we won't have collected nothrow information, and if we
2185      asked for asynchronous tables, we always want this info.  */
2186   if (for_eh)
2187     {
2188       bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2189
2190       for (i = 0; i < fde_table_in_use; i++)
2191         if (fde_table[i].uses_eh_lsda)
2192           any_eh_needed = any_lsda_needed = true;
2193         else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2194           any_eh_needed = true;
2195         else if (! fde_table[i].nothrow
2196                  && ! fde_table[i].all_throwers_are_sibcalls)
2197           any_eh_needed = true;
2198
2199       if (! any_eh_needed)
2200         return;
2201     }
2202
2203   /* We're going to be generating comments, so turn on app.  */
2204   if (flag_debug_asm)
2205     app_enable ();
2206
2207   if (for_eh)
2208     switch_to_eh_frame_section ();
2209   else
2210     switch_to_section (get_section (DEBUG_FRAME_SECTION, SECTION_DEBUG, NULL));
2211
2212   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2213   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2214
2215   /* Output the CIE.  */
2216   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2217   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2218   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2219                         "Length of Common Information Entry");
2220   ASM_OUTPUT_LABEL (asm_out_file, l1);
2221
2222   /* Now that the CIE pointer is PC-relative for EH,
2223      use 0 to identify the CIE.  */
2224   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2225                        (for_eh ? 0 : DW_CIE_ID),
2226                        "CIE Identifier Tag");
2227
2228   dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2229
2230   augmentation[0] = 0;
2231   augmentation_size = 0;
2232   if (for_eh)
2233     {
2234       char *p;
2235
2236       /* Augmentation:
2237          z      Indicates that a uleb128 is present to size the
2238                 augmentation section.
2239          L      Indicates the encoding (and thus presence) of
2240                 an LSDA pointer in the FDE augmentation.
2241          R      Indicates a non-default pointer encoding for
2242                 FDE code pointers.
2243          P      Indicates the presence of an encoding + language
2244                 personality routine in the CIE augmentation.  */
2245
2246       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2247       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2248       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2249
2250       p = augmentation + 1;
2251       if (eh_personality_libfunc)
2252         {
2253           *p++ = 'P';
2254           augmentation_size += 1 + size_of_encoded_value (per_encoding);
2255         }
2256       if (any_lsda_needed)
2257         {
2258           *p++ = 'L';
2259           augmentation_size += 1;
2260         }
2261       if (fde_encoding != DW_EH_PE_absptr)
2262         {
2263           *p++ = 'R';
2264           augmentation_size += 1;
2265         }
2266       if (p > augmentation + 1)
2267         {
2268           augmentation[0] = 'z';
2269           *p = '\0';
2270         }
2271
2272       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
2273       if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2274         {
2275           int offset = (  4             /* Length */
2276                         + 4             /* CIE Id */
2277                         + 1             /* CIE version */
2278                         + strlen (augmentation) + 1     /* Augmentation */
2279                         + size_of_uleb128 (1)           /* Code alignment */
2280                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2281                         + 1             /* RA column */
2282                         + 1             /* Augmentation size */
2283                         + 1             /* Personality encoding */ );
2284           int pad = -offset & (PTR_SIZE - 1);
2285
2286           augmentation_size += pad;
2287
2288           /* Augmentations should be small, so there's scarce need to
2289              iterate for a solution.  Die if we exceed one uleb128 byte.  */
2290           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2291         }
2292     }
2293
2294   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2295   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2296   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2297                                "CIE Data Alignment Factor");
2298
2299   return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2300   if (DW_CIE_VERSION == 1)
2301     dw2_asm_output_data (1, return_reg, "CIE RA Column");
2302   else
2303     dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2304
2305   if (augmentation[0])
2306     {
2307       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2308       if (eh_personality_libfunc)
2309         {
2310           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2311                                eh_data_format_name (per_encoding));
2312           dw2_asm_output_encoded_addr_rtx (per_encoding,
2313                                            eh_personality_libfunc,
2314                                            true, NULL);
2315         }
2316
2317       if (any_lsda_needed)
2318         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2319                              eh_data_format_name (lsda_encoding));
2320
2321       if (fde_encoding != DW_EH_PE_absptr)
2322         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2323                              eh_data_format_name (fde_encoding));
2324     }
2325
2326   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2327     output_cfi (cfi, NULL, for_eh);
2328
2329   /* Pad the CIE out to an address sized boundary.  */
2330   ASM_OUTPUT_ALIGN (asm_out_file,
2331                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2332   ASM_OUTPUT_LABEL (asm_out_file, l2);
2333
2334   /* Loop through all of the FDE's.  */
2335   for (i = 0; i < fde_table_in_use; i++)
2336     {
2337       fde = &fde_table[i];
2338
2339       /* Don't emit EH unwind info for leaf functions that don't need it.  */
2340       if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2341           && (fde->nothrow || fde->all_throwers_are_sibcalls)
2342           && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2343           && !fde->uses_eh_lsda)
2344         continue;
2345
2346       targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2347       targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2348       ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2349       ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2350       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2351                             "FDE Length");
2352       ASM_OUTPUT_LABEL (asm_out_file, l1);
2353
2354       if (for_eh)
2355         dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2356       else
2357         dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2358                                "FDE CIE offset");
2359
2360       if (for_eh)
2361         {
2362           rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2363           SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2364           dw2_asm_output_encoded_addr_rtx (fde_encoding,
2365                                            sym_ref,
2366                                            false,
2367                                            "FDE initial location");
2368           if (fde->dw_fde_switched_sections)
2369             {
2370               rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2371                                       fde->dw_fde_unlikely_section_label);
2372               rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2373                                       fde->dw_fde_hot_section_label);
2374               SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2375               SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2376               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
2377                                                "FDE initial location");
2378               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2379                                     fde->dw_fde_hot_section_end_label,
2380                                     fde->dw_fde_hot_section_label,
2381                                     "FDE address range");
2382               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
2383                                                "FDE initial location");
2384               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2385                                     fde->dw_fde_unlikely_section_end_label,
2386                                     fde->dw_fde_unlikely_section_label,
2387                                     "FDE address range");
2388             }
2389           else
2390             dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2391                                   fde->dw_fde_end, fde->dw_fde_begin,
2392                                   "FDE address range");
2393         }
2394       else
2395         {
2396           dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2397                                "FDE initial location");
2398           if (fde->dw_fde_switched_sections)
2399             {
2400               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2401                                    fde->dw_fde_hot_section_label,
2402                                    "FDE initial location");
2403               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2404                                     fde->dw_fde_hot_section_end_label,
2405                                     fde->dw_fde_hot_section_label,
2406                                     "FDE address range");
2407               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2408                                    fde->dw_fde_unlikely_section_label,
2409                                    "FDE initial location");
2410               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2411                                     fde->dw_fde_unlikely_section_end_label,
2412                                     fde->dw_fde_unlikely_section_label,
2413                                     "FDE address range");
2414             }
2415           else
2416             dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2417                                   fde->dw_fde_end, fde->dw_fde_begin,
2418                                   "FDE address range");
2419         }
2420
2421       if (augmentation[0])
2422         {
2423           if (any_lsda_needed)
2424             {
2425               int size = size_of_encoded_value (lsda_encoding);
2426
2427               if (lsda_encoding == DW_EH_PE_aligned)
2428                 {
2429                   int offset = (  4             /* Length */
2430                                 + 4             /* CIE offset */
2431                                 + 2 * size_of_encoded_value (fde_encoding)
2432                                 + 1             /* Augmentation size */ );
2433                   int pad = -offset & (PTR_SIZE - 1);
2434
2435                   size += pad;
2436                   gcc_assert (size_of_uleb128 (size) == 1);
2437                 }
2438
2439               dw2_asm_output_data_uleb128 (size, "Augmentation size");
2440
2441               if (fde->uses_eh_lsda)
2442                 {
2443                   ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2444                                                fde->funcdef_number);
2445                   dw2_asm_output_encoded_addr_rtx (
2446                         lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2447                         false, "Language Specific Data Area");
2448                 }
2449               else
2450                 {
2451                   if (lsda_encoding == DW_EH_PE_aligned)
2452                     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2453                   dw2_asm_output_data
2454                     (size_of_encoded_value (lsda_encoding), 0,
2455                      "Language Specific Data Area (none)");
2456                 }
2457             }
2458           else
2459             dw2_asm_output_data_uleb128 (0, "Augmentation size");
2460         }
2461
2462       /* Loop through the Call Frame Instructions associated with
2463          this FDE.  */
2464       fde->dw_fde_current_label = fde->dw_fde_begin;
2465       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2466         output_cfi (cfi, fde, for_eh);
2467
2468       /* Pad the FDE out to an address sized boundary.  */
2469       ASM_OUTPUT_ALIGN (asm_out_file,
2470                         floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2471       ASM_OUTPUT_LABEL (asm_out_file, l2);
2472     }
2473
2474   if (for_eh && targetm.terminate_dw2_eh_frame_info)
2475     dw2_asm_output_data (4, 0, "End of Table");
2476 #ifdef MIPS_DEBUGGING_INFO
2477   /* Work around Irix 6 assembler bug whereby labels at the end of a section
2478      get a value of 0.  Putting .align 0 after the label fixes it.  */
2479   ASM_OUTPUT_ALIGN (asm_out_file, 0);
2480 #endif
2481
2482   /* Turn off app to make assembly quicker.  */
2483   if (flag_debug_asm)
2484     app_disable ();
2485 }
2486
2487 /* Output a marker (i.e. a label) for the beginning of a function, before
2488    the prologue.  */
2489
2490 void
2491 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2492                           const char *file ATTRIBUTE_UNUSED)
2493 {
2494   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2495   char * dup_label;
2496   dw_fde_ref fde;
2497
2498   current_function_func_begin_label = NULL;
2499
2500 #ifdef TARGET_UNWIND_INFO
2501   /* ??? current_function_func_begin_label is also used by except.c
2502      for call-site information.  We must emit this label if it might
2503      be used.  */
2504   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2505       && ! dwarf2out_do_frame ())
2506     return;
2507 #else
2508   if (! dwarf2out_do_frame ())
2509     return;
2510 #endif
2511
2512   switch_to_section (function_section (current_function_decl));
2513   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2514                                current_function_funcdef_no);
2515   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2516                           current_function_funcdef_no);
2517   dup_label = xstrdup (label);
2518   current_function_func_begin_label = dup_label;
2519
2520 #ifdef TARGET_UNWIND_INFO
2521   /* We can elide the fde allocation if we're not emitting debug info.  */
2522   if (! dwarf2out_do_frame ())
2523     return;
2524 #endif
2525
2526   /* Expand the fde table if necessary.  */
2527   if (fde_table_in_use == fde_table_allocated)
2528     {
2529       fde_table_allocated += FDE_TABLE_INCREMENT;
2530       fde_table = ggc_realloc (fde_table,
2531                                fde_table_allocated * sizeof (dw_fde_node));
2532       memset (fde_table + fde_table_in_use, 0,
2533               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2534     }
2535
2536   /* Record the FDE associated with this function.  */
2537   current_funcdef_fde = fde_table_in_use;
2538
2539   /* Add the new FDE at the end of the fde_table.  */
2540   fde = &fde_table[fde_table_in_use++];
2541   fde->decl = current_function_decl;
2542   fde->dw_fde_begin = dup_label;
2543   fde->dw_fde_current_label = NULL;
2544   fde->dw_fde_hot_section_label = NULL;
2545   fde->dw_fde_hot_section_end_label = NULL;
2546   fde->dw_fde_unlikely_section_label = NULL;
2547   fde->dw_fde_unlikely_section_end_label = NULL;
2548   fde->dw_fde_switched_sections = false;
2549   fde->dw_fde_end = NULL;
2550   fde->dw_fde_cfi = NULL;
2551   fde->funcdef_number = current_function_funcdef_no;
2552   fde->nothrow = TREE_NOTHROW (current_function_decl);
2553   fde->uses_eh_lsda = cfun->uses_eh_lsda;
2554   fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2555
2556   args_size = old_args_size = 0;
2557
2558   /* We only want to output line number information for the genuine dwarf2
2559      prologue case, not the eh frame case.  */
2560 #ifdef DWARF2_DEBUGGING_INFO
2561   if (file)
2562     dwarf2out_source_line (line, file);
2563 #endif
2564 }
2565
2566 /* Output a marker (i.e. a label) for the absolute end of the generated code
2567    for a function definition.  This gets called *after* the epilogue code has
2568    been generated.  */
2569
2570 void
2571 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2572                         const char *file ATTRIBUTE_UNUSED)
2573 {
2574   dw_fde_ref fde;
2575   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2576
2577   /* Output a label to mark the endpoint of the code generated for this
2578      function.  */
2579   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2580                                current_function_funcdef_no);
2581   ASM_OUTPUT_LABEL (asm_out_file, label);
2582   fde = &fde_table[fde_table_in_use - 1];
2583   fde->dw_fde_end = xstrdup (label);
2584 }
2585
2586 void
2587 dwarf2out_frame_init (void)
2588 {
2589   /* Allocate the initial hunk of the fde_table.  */
2590   fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2591   fde_table_allocated = FDE_TABLE_INCREMENT;
2592   fde_table_in_use = 0;
2593
2594   /* Generate the CFA instructions common to all FDE's.  Do it now for the
2595      sake of lookup_cfa.  */
2596
2597   /* On entry, the Canonical Frame Address is at SP.  */
2598   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2599
2600 #ifdef DWARF2_UNWIND_INFO
2601   if (DWARF2_UNWIND_INFO)
2602     initial_return_save (INCOMING_RETURN_ADDR_RTX);
2603 #endif
2604 }
2605
2606 void
2607 dwarf2out_frame_finish (void)
2608 {
2609   /* Output call frame information.  */
2610   if (DWARF2_FRAME_INFO)
2611     output_call_frame_info (0);
2612
2613 #ifndef TARGET_UNWIND_INFO
2614   /* Output another copy for the unwinder.  */
2615   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2616     output_call_frame_info (1);
2617 #endif
2618 }
2619 #endif
2620 \f
2621 /* And now, the subset of the debugging information support code necessary
2622    for emitting location expressions.  */
2623
2624 /* We need some way to distinguish DW_OP_addr with a direct symbol
2625    relocation from DW_OP_addr with a dtp-relative symbol relocation.  */
2626 #define INTERNAL_DW_OP_tls_addr         (0x100 + DW_OP_addr)
2627
2628
2629 typedef struct dw_val_struct *dw_val_ref;
2630 typedef struct die_struct *dw_die_ref;
2631 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2632 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2633
2634 /* Each DIE may have a series of attribute/value pairs.  Values
2635    can take on several forms.  The forms that are used in this
2636    implementation are listed below.  */
2637
2638 enum dw_val_class
2639 {
2640   dw_val_class_addr,
2641   dw_val_class_offset,
2642   dw_val_class_loc,
2643   dw_val_class_loc_list,
2644   dw_val_class_range_list,
2645   dw_val_class_const,
2646   dw_val_class_unsigned_const,
2647   dw_val_class_long_long,
2648   dw_val_class_vec,
2649   dw_val_class_flag,
2650   dw_val_class_die_ref,
2651   dw_val_class_fde_ref,
2652   dw_val_class_lbl_id,
2653   dw_val_class_lbl_offset,
2654   dw_val_class_str
2655 };
2656
2657 /* Describe a double word constant value.  */
2658 /* ??? Every instance of long_long in the code really means CONST_DOUBLE.  */
2659
2660 typedef struct dw_long_long_struct GTY(())
2661 {
2662   unsigned long hi;
2663   unsigned long low;
2664 }
2665 dw_long_long_const;
2666
2667 /* Describe a floating point constant value, or a vector constant value.  */
2668
2669 typedef struct dw_vec_struct GTY(())
2670 {
2671   unsigned char * GTY((length ("%h.length"))) array;
2672   unsigned length;
2673   unsigned elt_size;
2674 }
2675 dw_vec_const;
2676
2677 /* The dw_val_node describes an attribute's value, as it is
2678    represented internally.  */
2679
2680 typedef struct dw_val_struct GTY(())
2681 {
2682   enum dw_val_class val_class;
2683   union dw_val_struct_union
2684     {
2685       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2686       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2687       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2688       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2689       HOST_WIDE_INT GTY ((default)) val_int;
2690       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2691       dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2692       dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2693       struct dw_val_die_union
2694         {
2695           dw_die_ref die;
2696           int external;
2697         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2698       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2699       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2700       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2701       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2702     }
2703   GTY ((desc ("%1.val_class"))) v;
2704 }
2705 dw_val_node;
2706
2707 /* Locations in memory are described using a sequence of stack machine
2708    operations.  */
2709
2710 typedef struct dw_loc_descr_struct GTY(())
2711 {
2712   dw_loc_descr_ref dw_loc_next;
2713   enum dwarf_location_atom dw_loc_opc;
2714   dw_val_node dw_loc_oprnd1;
2715   dw_val_node dw_loc_oprnd2;
2716   int dw_loc_addr;
2717 }
2718 dw_loc_descr_node;
2719
2720 /* Location lists are ranges + location descriptions for that range,
2721    so you can track variables that are in different places over
2722    their entire life.  */
2723 typedef struct dw_loc_list_struct GTY(())
2724 {
2725   dw_loc_list_ref dw_loc_next;
2726   const char *begin; /* Label for begin address of range */
2727   const char *end;  /* Label for end address of range */
2728   char *ll_symbol; /* Label for beginning of location list.
2729                       Only on head of list */
2730   const char *section; /* Section this loclist is relative to */
2731   dw_loc_descr_ref expr;
2732 } dw_loc_list_node;
2733
2734 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2735
2736 static const char *dwarf_stack_op_name (unsigned);
2737 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2738                                        unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2739 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2740 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2741 static unsigned long size_of_locs (dw_loc_descr_ref);
2742 static void output_loc_operands (dw_loc_descr_ref);
2743 static void output_loc_sequence (dw_loc_descr_ref);
2744
2745 /* Convert a DWARF stack opcode into its string name.  */
2746
2747 static const char *
2748 dwarf_stack_op_name (unsigned int op)
2749 {
2750   switch (op)
2751     {
2752     case DW_OP_addr:
2753     case INTERNAL_DW_OP_tls_addr:
2754       return "DW_OP_addr";
2755     case DW_OP_deref:
2756       return "DW_OP_deref";
2757     case DW_OP_const1u:
2758       return "DW_OP_const1u";
2759     case DW_OP_const1s:
2760       return "DW_OP_const1s";
2761     case DW_OP_const2u:
2762       return "DW_OP_const2u";
2763     case DW_OP_const2s:
2764       return "DW_OP_const2s";
2765     case DW_OP_const4u:
2766       return "DW_OP_const4u";
2767     case DW_OP_const4s:
2768       return "DW_OP_const4s";
2769     case DW_OP_const8u:
2770       return "DW_OP_const8u";
2771     case DW_OP_const8s:
2772       return "DW_OP_const8s";
2773     case DW_OP_constu:
2774       return "DW_OP_constu";
2775     case DW_OP_consts:
2776       return "DW_OP_consts";
2777     case DW_OP_dup:
2778       return "DW_OP_dup";
2779     case DW_OP_drop:
2780       return "DW_OP_drop";
2781     case DW_OP_over:
2782       return "DW_OP_over";
2783     case DW_OP_pick:
2784       return "DW_OP_pick";
2785     case DW_OP_swap:
2786       return "DW_OP_swap";
2787     case DW_OP_rot:
2788       return "DW_OP_rot";
2789     case DW_OP_xderef:
2790       return "DW_OP_xderef";
2791     case DW_OP_abs:
2792       return "DW_OP_abs";
2793     case DW_OP_and:
2794       return "DW_OP_and";
2795     case DW_OP_div:
2796       return "DW_OP_div";
2797     case DW_OP_minus:
2798       return "DW_OP_minus";
2799     case DW_OP_mod:
2800       return "DW_OP_mod";
2801     case DW_OP_mul:
2802       return "DW_OP_mul";
2803     case DW_OP_neg:
2804       return "DW_OP_neg";
2805     case DW_OP_not:
2806       return "DW_OP_not";
2807     case DW_OP_or:
2808       return "DW_OP_or";
2809     case DW_OP_plus:
2810       return "DW_OP_plus";
2811     case DW_OP_plus_uconst:
2812       return "DW_OP_plus_uconst";
2813     case DW_OP_shl:
2814       return "DW_OP_shl";
2815     case DW_OP_shr:
2816       return "DW_OP_shr";
2817     case DW_OP_shra:
2818       return "DW_OP_shra";
2819     case DW_OP_xor:
2820       return "DW_OP_xor";
2821     case DW_OP_bra:
2822       return "DW_OP_bra";
2823     case DW_OP_eq:
2824       return "DW_OP_eq";
2825     case DW_OP_ge:
2826       return "DW_OP_ge";
2827     case DW_OP_gt:
2828       return "DW_OP_gt";
2829     case DW_OP_le:
2830       return "DW_OP_le";
2831     case DW_OP_lt:
2832       return "DW_OP_lt";
2833     case DW_OP_ne:
2834       return "DW_OP_ne";
2835     case DW_OP_skip:
2836       return "DW_OP_skip";
2837     case DW_OP_lit0:
2838       return "DW_OP_lit0";
2839     case DW_OP_lit1:
2840       return "DW_OP_lit1";
2841     case DW_OP_lit2:
2842       return "DW_OP_lit2";
2843     case DW_OP_lit3:
2844       return "DW_OP_lit3";
2845     case DW_OP_lit4:
2846       return "DW_OP_lit4";
2847     case DW_OP_lit5:
2848       return "DW_OP_lit5";
2849     case DW_OP_lit6:
2850       return "DW_OP_lit6";
2851     case DW_OP_lit7:
2852       return "DW_OP_lit7";
2853     case DW_OP_lit8:
2854       return "DW_OP_lit8";
2855     case DW_OP_lit9:
2856       return "DW_OP_lit9";
2857     case DW_OP_lit10:
2858       return "DW_OP_lit10";
2859     case DW_OP_lit11:
2860       return "DW_OP_lit11";
2861     case DW_OP_lit12:
2862       return "DW_OP_lit12";
2863     case DW_OP_lit13:
2864       return "DW_OP_lit13";
2865     case DW_OP_lit14:
2866       return "DW_OP_lit14";
2867     case DW_OP_lit15:
2868       return "DW_OP_lit15";
2869     case DW_OP_lit16:
2870       return "DW_OP_lit16";
2871     case DW_OP_lit17:
2872       return "DW_OP_lit17";
2873     case DW_OP_lit18:
2874       return "DW_OP_lit18";
2875     case DW_OP_lit19:
2876       return "DW_OP_lit19";
2877     case DW_OP_lit20:
2878       return "DW_OP_lit20";
2879     case DW_OP_lit21:
2880       return "DW_OP_lit21";
2881     case DW_OP_lit22:
2882       return "DW_OP_lit22";
2883     case DW_OP_lit23:
2884       return "DW_OP_lit23";
2885     case DW_OP_lit24:
2886       return "DW_OP_lit24";
2887     case DW_OP_lit25:
2888       return "DW_OP_lit25";
2889     case DW_OP_lit26:
2890       return "DW_OP_lit26";
2891     case DW_OP_lit27:
2892       return "DW_OP_lit27";
2893     case DW_OP_lit28:
2894       return "DW_OP_lit28";
2895     case DW_OP_lit29:
2896       return "DW_OP_lit29";
2897     case DW_OP_lit30:
2898       return "DW_OP_lit30";
2899     case DW_OP_lit31:
2900       return "DW_OP_lit31";
2901     case DW_OP_reg0:
2902       return "DW_OP_reg0";
2903     case DW_OP_reg1:
2904       return "DW_OP_reg1";
2905     case DW_OP_reg2:
2906       return "DW_OP_reg2";
2907     case DW_OP_reg3:
2908       return "DW_OP_reg3";
2909     case DW_OP_reg4:
2910       return "DW_OP_reg4";
2911     case DW_OP_reg5:
2912       return "DW_OP_reg5";
2913     case DW_OP_reg6:
2914       return "DW_OP_reg6";
2915     case DW_OP_reg7:
2916       return "DW_OP_reg7";
2917     case DW_OP_reg8:
2918       return "DW_OP_reg8";
2919     case DW_OP_reg9:
2920       return "DW_OP_reg9";
2921     case DW_OP_reg10:
2922       return "DW_OP_reg10";
2923     case DW_OP_reg11:
2924       return "DW_OP_reg11";
2925     case DW_OP_reg12:
2926       return "DW_OP_reg12";
2927     case DW_OP_reg13:
2928       return "DW_OP_reg13";
2929     case DW_OP_reg14:
2930       return "DW_OP_reg14";
2931     case DW_OP_reg15:
2932       return "DW_OP_reg15";
2933     case DW_OP_reg16:
2934       return "DW_OP_reg16";
2935     case DW_OP_reg17:
2936       return "DW_OP_reg17";
2937     case DW_OP_reg18:
2938       return "DW_OP_reg18";
2939     case DW_OP_reg19:
2940       return "DW_OP_reg19";
2941     case DW_OP_reg20:
2942       return "DW_OP_reg20";
2943     case DW_OP_reg21:
2944       return "DW_OP_reg21";
2945     case DW_OP_reg22:
2946       return "DW_OP_reg22";
2947     case DW_OP_reg23:
2948       return "DW_OP_reg23";
2949     case DW_OP_reg24:
2950       return "DW_OP_reg24";
2951     case DW_OP_reg25:
2952       return "DW_OP_reg25";
2953     case DW_OP_reg26:
2954       return "DW_OP_reg26";
2955     case DW_OP_reg27:
2956       return "DW_OP_reg27";
2957     case DW_OP_reg28:
2958       return "DW_OP_reg28";
2959     case DW_OP_reg29:
2960       return "DW_OP_reg29";
2961     case DW_OP_reg30:
2962       return "DW_OP_reg30";
2963     case DW_OP_reg31:
2964       return "DW_OP_reg31";
2965     case DW_OP_breg0:
2966       return "DW_OP_breg0";
2967     case DW_OP_breg1:
2968       return "DW_OP_breg1";
2969     case DW_OP_breg2:
2970       return "DW_OP_breg2";
2971     case DW_OP_breg3:
2972       return "DW_OP_breg3";
2973     case DW_OP_breg4:
2974       return "DW_OP_breg4";
2975     case DW_OP_breg5:
2976       return "DW_OP_breg5";
2977     case DW_OP_breg6:
2978       return "DW_OP_breg6";
2979     case DW_OP_breg7:
2980       return "DW_OP_breg7";
2981     case DW_OP_breg8:
2982       return "DW_OP_breg8";
2983     case DW_OP_breg9:
2984       return "DW_OP_breg9";
2985     case DW_OP_breg10:
2986       return "DW_OP_breg10";
2987     case DW_OP_breg11:
2988       return "DW_OP_breg11";
2989     case DW_OP_breg12:
2990       return "DW_OP_breg12";
2991     case DW_OP_breg13:
2992       return "DW_OP_breg13";
2993     case DW_OP_breg14:
2994       return "DW_OP_breg14";
2995     case DW_OP_breg15:
2996       return "DW_OP_breg15";
2997     case DW_OP_breg16:
2998       return "DW_OP_breg16";
2999     case DW_OP_breg17:
3000       return "DW_OP_breg17";
3001     case DW_OP_breg18:
3002       return "DW_OP_breg18";
3003     case DW_OP_breg19:
3004       return "DW_OP_breg19";
3005     case DW_OP_breg20:
3006       return "DW_OP_breg20";
3007     case DW_OP_breg21:
3008       return "DW_OP_breg21";
3009     case DW_OP_breg22:
3010       return "DW_OP_breg22";
3011     case DW_OP_breg23:
3012       return "DW_OP_breg23";
3013     case DW_OP_breg24:
3014       return "DW_OP_breg24";
3015     case DW_OP_breg25:
3016       return "DW_OP_breg25";
3017     case DW_OP_breg26:
3018       return "DW_OP_breg26";
3019     case DW_OP_breg27:
3020       return "DW_OP_breg27";
3021     case DW_OP_breg28:
3022       return "DW_OP_breg28";
3023     case DW_OP_breg29:
3024       return "DW_OP_breg29";
3025     case DW_OP_breg30:
3026       return "DW_OP_breg30";
3027     case DW_OP_breg31:
3028       return "DW_OP_breg31";
3029     case DW_OP_regx:
3030       return "DW_OP_regx";
3031     case DW_OP_fbreg:
3032       return "DW_OP_fbreg";
3033     case DW_OP_bregx:
3034       return "DW_OP_bregx";
3035     case DW_OP_piece:
3036       return "DW_OP_piece";
3037     case DW_OP_deref_size:
3038       return "DW_OP_deref_size";
3039     case DW_OP_xderef_size:
3040       return "DW_OP_xderef_size";
3041     case DW_OP_nop:
3042       return "DW_OP_nop";
3043     case DW_OP_push_object_address:
3044       return "DW_OP_push_object_address";
3045     case DW_OP_call2:
3046       return "DW_OP_call2";
3047     case DW_OP_call4:
3048       return "DW_OP_call4";
3049     case DW_OP_call_ref:
3050       return "DW_OP_call_ref";
3051     case DW_OP_GNU_push_tls_address:
3052       return "DW_OP_GNU_push_tls_address";
3053     default:
3054       return "OP_<unknown>";
3055     }
3056 }
3057
3058 /* Return a pointer to a newly allocated location description.  Location
3059    descriptions are simple expression terms that can be strung
3060    together to form more complicated location (address) descriptions.  */
3061
3062 static inline dw_loc_descr_ref
3063 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3064                unsigned HOST_WIDE_INT oprnd2)
3065 {
3066   dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
3067
3068   descr->dw_loc_opc = op;
3069   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3070   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3071   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3072   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3073
3074   return descr;
3075 }
3076
3077 /* Add a location description term to a location description expression.  */
3078
3079 static inline void
3080 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3081 {
3082   dw_loc_descr_ref *d;
3083
3084   /* Find the end of the chain.  */
3085   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3086     ;
3087
3088   *d = descr;
3089 }
3090
3091 /* Return the size of a location descriptor.  */
3092
3093 static unsigned long
3094 size_of_loc_descr (dw_loc_descr_ref loc)
3095 {
3096   unsigned long size = 1;
3097
3098   switch (loc->dw_loc_opc)
3099     {
3100     case DW_OP_addr:
3101     case INTERNAL_DW_OP_tls_addr:
3102       size += DWARF2_ADDR_SIZE;
3103       break;
3104     case DW_OP_const1u:
3105     case DW_OP_const1s:
3106       size += 1;
3107       break;
3108     case DW_OP_const2u:
3109     case DW_OP_const2s:
3110       size += 2;
3111       break;
3112     case DW_OP_const4u:
3113     case DW_OP_const4s:
3114       size += 4;
3115       break;
3116     case DW_OP_const8u:
3117     case DW_OP_const8s:
3118       size += 8;
3119       break;
3120     case DW_OP_constu:
3121       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3122       break;
3123     case DW_OP_consts:
3124       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3125       break;
3126     case DW_OP_pick:
3127       size += 1;
3128       break;
3129     case DW_OP_plus_uconst:
3130       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3131       break;
3132     case DW_OP_skip:
3133     case DW_OP_bra:
3134       size += 2;
3135       break;
3136     case DW_OP_breg0:
3137     case DW_OP_breg1:
3138     case DW_OP_breg2:
3139     case DW_OP_breg3:
3140     case DW_OP_breg4:
3141     case DW_OP_breg5:
3142     case DW_OP_breg6:
3143     case DW_OP_breg7:
3144     case DW_OP_breg8:
3145     case DW_OP_breg9:
3146     case DW_OP_breg10:
3147     case DW_OP_breg11:
3148     case DW_OP_breg12:
3149     case DW_OP_breg13:
3150     case DW_OP_breg14:
3151     case DW_OP_breg15:
3152     case DW_OP_breg16:
3153     case DW_OP_breg17:
3154     case DW_OP_breg18:
3155     case DW_OP_breg19:
3156     case DW_OP_breg20:
3157     case DW_OP_breg21:
3158     case DW_OP_breg22:
3159     case DW_OP_breg23:
3160     case DW_OP_breg24:
3161     case DW_OP_breg25:
3162     case DW_OP_breg26:
3163     case DW_OP_breg27:
3164     case DW_OP_breg28:
3165     case DW_OP_breg29:
3166     case DW_OP_breg30:
3167     case DW_OP_breg31:
3168       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3169       break;
3170     case DW_OP_regx:
3171       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3172       break;
3173     case DW_OP_fbreg:
3174       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3175       break;
3176     case DW_OP_bregx:
3177       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3178       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3179       break;
3180     case DW_OP_piece:
3181       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3182       break;
3183     case DW_OP_deref_size:
3184     case DW_OP_xderef_size:
3185       size += 1;
3186       break;
3187     case DW_OP_call2:
3188       size += 2;
3189       break;
3190     case DW_OP_call4:
3191       size += 4;
3192       break;
3193     case DW_OP_call_ref:
3194       size += DWARF2_ADDR_SIZE;
3195       break;
3196     default:
3197       break;
3198     }
3199
3200   return size;
3201 }
3202
3203 /* Return the size of a series of location descriptors.  */
3204
3205 static unsigned long
3206 size_of_locs (dw_loc_descr_ref loc)
3207 {
3208   unsigned long size;
3209
3210   for (size = 0; loc != NULL; loc = loc->dw_loc_next)
3211     {
3212       loc->dw_loc_addr = size;
3213       size += size_of_loc_descr (loc);
3214     }
3215
3216   return size;
3217 }
3218
3219 /* Output location description stack opcode's operands (if any).  */
3220
3221 static void
3222 output_loc_operands (dw_loc_descr_ref loc)
3223 {
3224   dw_val_ref val1 = &loc->dw_loc_oprnd1;
3225   dw_val_ref val2 = &loc->dw_loc_oprnd2;
3226
3227   switch (loc->dw_loc_opc)
3228     {
3229 #ifdef DWARF2_DEBUGGING_INFO
3230     case DW_OP_addr:
3231       dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3232       break;
3233     case DW_OP_const2u:
3234     case DW_OP_const2s:
3235       dw2_asm_output_data (2, val1->v.val_int, NULL);
3236       break;
3237     case DW_OP_const4u:
3238     case DW_OP_const4s:
3239       dw2_asm_output_data (4, val1->v.val_int, NULL);
3240       break;
3241     case DW_OP_const8u:
3242     case DW_OP_const8s:
3243       gcc_assert (HOST_BITS_PER_LONG >= 64);
3244       dw2_asm_output_data (8, val1->v.val_int, NULL);
3245       break;
3246     case DW_OP_skip:
3247     case DW_OP_bra:
3248       {
3249         int offset;
3250
3251         gcc_assert (val1->val_class == dw_val_class_loc);
3252         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3253
3254         dw2_asm_output_data (2, offset, NULL);
3255       }
3256       break;
3257 #else
3258     case DW_OP_addr:
3259     case DW_OP_const2u:
3260     case DW_OP_const2s:
3261     case DW_OP_const4u:
3262     case DW_OP_const4s:
3263     case DW_OP_const8u:
3264     case DW_OP_const8s:
3265     case DW_OP_skip:
3266     case DW_OP_bra:
3267       /* We currently don't make any attempt to make sure these are
3268          aligned properly like we do for the main unwind info, so
3269          don't support emitting things larger than a byte if we're
3270          only doing unwinding.  */
3271       gcc_unreachable ();
3272 #endif
3273     case DW_OP_const1u:
3274     case DW_OP_const1s:
3275       dw2_asm_output_data (1, val1->v.val_int, NULL);
3276       break;
3277     case DW_OP_constu:
3278       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3279       break;
3280     case DW_OP_consts:
3281       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3282       break;
3283     case DW_OP_pick:
3284       dw2_asm_output_data (1, val1->v.val_int, NULL);
3285       break;
3286     case DW_OP_plus_uconst:
3287       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3288       break;
3289     case DW_OP_breg0:
3290     case DW_OP_breg1:
3291     case DW_OP_breg2:
3292     case DW_OP_breg3:
3293     case DW_OP_breg4:
3294     case DW_OP_breg5:
3295     case DW_OP_breg6:
3296     case DW_OP_breg7:
3297     case DW_OP_breg8:
3298     case DW_OP_breg9:
3299     case DW_OP_breg10:
3300     case DW_OP_breg11:
3301     case DW_OP_breg12:
3302     case DW_OP_breg13:
3303     case DW_OP_breg14:
3304     case DW_OP_breg15:
3305     case DW_OP_breg16:
3306     case DW_OP_breg17:
3307     case DW_OP_breg18:
3308     case DW_OP_breg19:
3309     case DW_OP_breg20:
3310     case DW_OP_breg21:
3311     case DW_OP_breg22:
3312     case DW_OP_breg23:
3313     case DW_OP_breg24:
3314     case DW_OP_breg25:
3315     case DW_OP_breg26:
3316     case DW_OP_breg27:
3317     case DW_OP_breg28:
3318     case DW_OP_breg29:
3319     case DW_OP_breg30:
3320     case DW_OP_breg31:
3321       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3322       break;
3323     case DW_OP_regx:
3324       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3325       break;
3326     case DW_OP_fbreg:
3327       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3328       break;
3329     case DW_OP_bregx:
3330       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3331       dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3332       break;
3333     case DW_OP_piece:
3334       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3335       break;
3336     case DW_OP_deref_size:
3337     case DW_OP_xderef_size:
3338       dw2_asm_output_data (1, val1->v.val_int, NULL);
3339       break;
3340
3341     case INTERNAL_DW_OP_tls_addr:
3342       if (targetm.asm_out.output_dwarf_dtprel)
3343         {
3344           targetm.asm_out.output_dwarf_dtprel (asm_out_file,
3345                                                DWARF2_ADDR_SIZE,
3346                                                val1->v.val_addr);
3347           fputc ('\n', asm_out_file);
3348         }
3349       else
3350         gcc_unreachable ();
3351       break;
3352
3353     default:
3354       /* Other codes have no operands.  */
3355       break;
3356     }
3357 }
3358
3359 /* Output a sequence of location operations.  */
3360
3361 static void
3362 output_loc_sequence (dw_loc_descr_ref loc)
3363 {
3364   for (; loc != NULL; loc = loc->dw_loc_next)
3365     {
3366       /* Output the opcode.  */
3367       dw2_asm_output_data (1, loc->dw_loc_opc,
3368                            "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3369
3370       /* Output the operand(s) (if any).  */
3371       output_loc_operands (loc);
3372     }
3373 }
3374
3375 /* This routine will generate the correct assembly data for a location
3376    description based on a cfi entry with a complex address.  */
3377
3378 static void
3379 output_cfa_loc (dw_cfi_ref cfi)
3380 {
3381   dw_loc_descr_ref loc;
3382   unsigned long size;
3383
3384   /* Output the size of the block.  */
3385   loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3386   size = size_of_locs (loc);
3387   dw2_asm_output_data_uleb128 (size, NULL);
3388
3389   /* Now output the operations themselves.  */
3390   output_loc_sequence (loc);
3391 }
3392
3393 /* This function builds a dwarf location descriptor sequence from a
3394    dw_cfa_location, adding the given OFFSET to the result of the
3395    expression.  */
3396
3397 static struct dw_loc_descr_struct *
3398 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
3399 {
3400   struct dw_loc_descr_struct *head, *tmp;
3401
3402   offset += cfa->offset;
3403
3404   if (cfa->indirect)
3405     {
3406       if (cfa->base_offset)
3407         {
3408           if (cfa->reg <= 31)
3409             head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3410           else
3411             head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3412         }
3413       else if (cfa->reg <= 31)
3414         head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3415       else
3416         head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3417
3418       head->dw_loc_oprnd1.val_class = dw_val_class_const;
3419       tmp = new_loc_descr (DW_OP_deref, 0, 0);
3420       add_loc_descr (&head, tmp);
3421       if (offset != 0)
3422         {
3423           tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
3424           add_loc_descr (&head, tmp);
3425         }
3426     }
3427   else
3428     {
3429       if (offset == 0)
3430         if (cfa->reg <= 31)
3431           head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3432         else
3433           head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3434       else if (cfa->reg <= 31)
3435         head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0);
3436       else
3437         head = new_loc_descr (DW_OP_bregx, cfa->reg, offset);
3438     }
3439
3440   return head;
3441 }
3442
3443 /* This function fills in aa dw_cfa_location structure from a dwarf location
3444    descriptor sequence.  */
3445
3446 static void
3447 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3448 {
3449   struct dw_loc_descr_struct *ptr;
3450   cfa->offset = 0;
3451   cfa->base_offset = 0;
3452   cfa->indirect = 0;
3453   cfa->reg = -1;
3454
3455   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3456     {
3457       enum dwarf_location_atom op = ptr->dw_loc_opc;
3458
3459       switch (op)
3460         {
3461         case DW_OP_reg0:
3462         case DW_OP_reg1:
3463         case DW_OP_reg2:
3464         case DW_OP_reg3:
3465         case DW_OP_reg4:
3466         case DW_OP_reg5:
3467         case DW_OP_reg6:
3468         case DW_OP_reg7:
3469         case DW_OP_reg8:
3470         case DW_OP_reg9:
3471         case DW_OP_reg10:
3472         case DW_OP_reg11:
3473         case DW_OP_reg12:
3474         case DW_OP_reg13:
3475         case DW_OP_reg14:
3476         case DW_OP_reg15:
3477         case DW_OP_reg16:
3478         case DW_OP_reg17:
3479         case DW_OP_reg18:
3480         case DW_OP_reg19:
3481         case DW_OP_reg20:
3482         case DW_OP_reg21:
3483         case DW_OP_reg22:
3484         case DW_OP_reg23:
3485         case DW_OP_reg24:
3486         case DW_OP_reg25:
3487         case DW_OP_reg26:
3488         case DW_OP_reg27:
3489         case DW_OP_reg28:
3490         case DW_OP_reg29:
3491         case DW_OP_reg30:
3492         case DW_OP_reg31:
3493           cfa->reg = op - DW_OP_reg0;
3494           break;
3495         case DW_OP_regx:
3496           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3497           break;
3498         case DW_OP_breg0:
3499         case DW_OP_breg1:
3500         case DW_OP_breg2:
3501         case DW_OP_breg3:
3502         case DW_OP_breg4:
3503         case DW_OP_breg5:
3504         case DW_OP_breg6:
3505         case DW_OP_breg7:
3506         case DW_OP_breg8:
3507         case DW_OP_breg9:
3508         case DW_OP_breg10:
3509         case DW_OP_breg11:
3510         case DW_OP_breg12:
3511         case DW_OP_breg13:
3512         case DW_OP_breg14:
3513         case DW_OP_breg15:
3514         case DW_OP_breg16:
3515         case DW_OP_breg17:
3516         case DW_OP_breg18:
3517         case DW_OP_breg19:
3518         case DW_OP_breg20:
3519         case DW_OP_breg21:
3520         case DW_OP_breg22:
3521         case DW_OP_breg23:
3522         case DW_OP_breg24:
3523         case DW_OP_breg25:
3524         case DW_OP_breg26:
3525         case DW_OP_breg27:
3526         case DW_OP_breg28:
3527         case DW_OP_breg29:
3528         case DW_OP_breg30:
3529         case DW_OP_breg31:
3530           cfa->reg = op - DW_OP_breg0;
3531           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3532           break;
3533         case DW_OP_bregx:
3534           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3535           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3536           break;
3537         case DW_OP_deref:
3538           cfa->indirect = 1;
3539           break;
3540         case DW_OP_plus_uconst:
3541           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3542           break;
3543         default:
3544           internal_error ("DW_LOC_OP %s not implemented",
3545                           dwarf_stack_op_name (ptr->dw_loc_opc));
3546         }
3547     }
3548 }
3549 #endif /* .debug_frame support */
3550 \f
3551 /* And now, the support for symbolic debugging information.  */
3552 #ifdef DWARF2_DEBUGGING_INFO
3553
3554 /* .debug_str support.  */
3555 static int output_indirect_string (void **, void *);
3556
3557 static void dwarf2out_init (const char *);
3558 static void dwarf2out_finish (const char *);
3559 static void dwarf2out_define (unsigned int, const char *);
3560 static void dwarf2out_undef (unsigned int, const char *);
3561 static void dwarf2out_start_source_file (unsigned, const char *);
3562 static void dwarf2out_end_source_file (unsigned);
3563 static void dwarf2out_begin_block (unsigned, unsigned);
3564 static void dwarf2out_end_block (unsigned, unsigned);
3565 static bool dwarf2out_ignore_block (tree);
3566 static void dwarf2out_global_decl (tree);
3567 static void dwarf2out_type_decl (tree, int);
3568 static void dwarf2out_imported_module_or_decl (tree, tree);
3569 static void dwarf2out_abstract_function (tree);
3570 static void dwarf2out_var_location (rtx);
3571 static void dwarf2out_begin_function (tree);
3572 static void dwarf2out_switch_text_section (void);
3573
3574 /* The debug hooks structure.  */
3575
3576 const struct gcc_debug_hooks dwarf2_debug_hooks =
3577 {
3578   dwarf2out_init,
3579   dwarf2out_finish,
3580   dwarf2out_define,
3581   dwarf2out_undef,
3582   dwarf2out_start_source_file,
3583   dwarf2out_end_source_file,
3584   dwarf2out_begin_block,
3585   dwarf2out_end_block,
3586   dwarf2out_ignore_block,
3587   dwarf2out_source_line,
3588   dwarf2out_begin_prologue,
3589   debug_nothing_int_charstar,   /* end_prologue */
3590   dwarf2out_end_epilogue,
3591   dwarf2out_begin_function,
3592   debug_nothing_int,            /* end_function */
3593   dwarf2out_decl,               /* function_decl */
3594   dwarf2out_global_decl,
3595   dwarf2out_type_decl,          /* type_decl */
3596   dwarf2out_imported_module_or_decl,
3597   debug_nothing_tree,           /* deferred_inline_function */
3598   /* The DWARF 2 backend tries to reduce debugging bloat by not
3599      emitting the abstract description of inline functions until
3600      something tries to reference them.  */
3601   dwarf2out_abstract_function,  /* outlining_inline_function */
3602   debug_nothing_rtx,            /* label */
3603   debug_nothing_int,            /* handle_pch */
3604   dwarf2out_var_location,
3605   dwarf2out_switch_text_section,
3606   1                             /* start_end_main_source_file */
3607 };
3608 #endif
3609 \f
3610 /* NOTE: In the comments in this file, many references are made to
3611    "Debugging Information Entries".  This term is abbreviated as `DIE'
3612    throughout the remainder of this file.  */
3613
3614 /* An internal representation of the DWARF output is built, and then
3615    walked to generate the DWARF debugging info.  The walk of the internal
3616    representation is done after the entire program has been compiled.
3617    The types below are used to describe the internal representation.  */
3618
3619 /* Various DIE's use offsets relative to the beginning of the
3620    .debug_info section to refer to each other.  */
3621
3622 typedef long int dw_offset;
3623
3624 /* Define typedefs here to avoid circular dependencies.  */
3625
3626 typedef struct dw_attr_struct *dw_attr_ref;
3627 typedef struct dw_line_info_struct *dw_line_info_ref;
3628 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3629 typedef struct pubname_struct *pubname_ref;
3630 typedef struct dw_ranges_struct *dw_ranges_ref;
3631
3632 /* Each entry in the line_info_table maintains the file and
3633    line number associated with the label generated for that
3634    entry.  The label gives the PC value associated with
3635    the line number entry.  */
3636
3637 typedef struct dw_line_info_struct GTY(())
3638 {
3639   unsigned long dw_file_num;
3640   unsigned long dw_line_num;
3641 }
3642 dw_line_info_entry;
3643
3644 /* Line information for functions in separate sections; each one gets its
3645    own sequence.  */
3646 typedef struct dw_separate_line_info_struct GTY(())
3647 {
3648   unsigned long dw_file_num;
3649   unsigned long dw_line_num;
3650   unsigned long function;
3651 }
3652 dw_separate_line_info_entry;
3653
3654 /* Each DIE attribute has a field specifying the attribute kind,
3655    a link to the next attribute in the chain, and an attribute value.
3656    Attributes are typically linked below the DIE they modify.  */
3657
3658 typedef struct dw_attr_struct GTY(())
3659 {
3660   enum dwarf_attribute dw_attr;
3661   dw_attr_ref dw_attr_next;
3662   dw_val_node dw_attr_val;
3663 }
3664 dw_attr_node;
3665
3666 /* The Debugging Information Entry (DIE) structure */
3667
3668 typedef struct die_struct GTY(())
3669 {
3670   enum dwarf_tag die_tag;
3671   char *die_symbol;
3672   dw_attr_ref die_attr;
3673   dw_die_ref die_parent;
3674   dw_die_ref die_child;
3675   dw_die_ref die_sib;
3676   dw_die_ref die_definition; /* ref from a specification to its definition */
3677   dw_offset die_offset;
3678   unsigned long die_abbrev;
3679   int die_mark;
3680   unsigned int decl_id;
3681 }
3682 die_node;
3683
3684 /* The pubname structure */
3685
3686 typedef struct pubname_struct GTY(())
3687 {
3688   dw_die_ref die;
3689   char *name;
3690 }
3691 pubname_entry;
3692
3693 struct dw_ranges_struct GTY(())
3694 {
3695   int block_num;
3696 };
3697
3698 /* The limbo die list structure.  */
3699 typedef struct limbo_die_struct GTY(())
3700 {
3701   dw_die_ref die;
3702   tree created_for;
3703   struct limbo_die_struct *next;
3704 }
3705 limbo_die_node;
3706
3707 /* How to start an assembler comment.  */
3708 #ifndef ASM_COMMENT_START
3709 #define ASM_COMMENT_START ";#"
3710 #endif
3711
3712 /* Define a macro which returns nonzero for a TYPE_DECL which was
3713    implicitly generated for a tagged type.
3714
3715    Note that unlike the gcc front end (which generates a NULL named
3716    TYPE_DECL node for each complete tagged type, each array type, and
3717    each function type node created) the g++ front end generates a
3718    _named_ TYPE_DECL node for each tagged type node created.
3719    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3720    generate a DW_TAG_typedef DIE for them.  */
3721
3722 #define TYPE_DECL_IS_STUB(decl)                         \
3723   (DECL_NAME (decl) == NULL_TREE                        \
3724    || (DECL_ARTIFICIAL (decl)                           \
3725        && is_tagged_type (TREE_TYPE (decl))             \
3726        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
3727            /* This is necessary for stub decls that     \
3728               appear in nested inline functions.  */    \
3729            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3730                && (decl_ultimate_origin (decl)          \
3731                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3732
3733 /* Information concerning the compilation unit's programming
3734    language, and compiler version.  */
3735
3736 /* Fixed size portion of the DWARF compilation unit header.  */
3737 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3738   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3739
3740 /* Fixed size portion of public names info.  */
3741 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3742
3743 /* Fixed size portion of the address range info.  */
3744 #define DWARF_ARANGES_HEADER_SIZE                                       \
3745   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
3746                 DWARF2_ADDR_SIZE * 2)                                   \
3747    - DWARF_INITIAL_LENGTH_SIZE)
3748
3749 /* Size of padding portion in the address range info.  It must be
3750    aligned to twice the pointer size.  */
3751 #define DWARF_ARANGES_PAD_SIZE \
3752   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3753                 DWARF2_ADDR_SIZE * 2) \
3754    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3755
3756 /* Use assembler line directives if available.  */
3757 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3758 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3759 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3760 #else
3761 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3762 #endif
3763 #endif
3764
3765 /* Minimum line offset in a special line info. opcode.
3766    This value was chosen to give a reasonable range of values.  */
3767 #define DWARF_LINE_BASE  -10
3768
3769 /* First special line opcode - leave room for the standard opcodes.  */
3770 #define DWARF_LINE_OPCODE_BASE  10
3771
3772 /* Range of line offsets in a special line info. opcode.  */
3773 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
3774
3775 /* Flag that indicates the initial value of the is_stmt_start flag.
3776    In the present implementation, we do not mark any lines as
3777    the beginning of a source statement, because that information
3778    is not made available by the GCC front-end.  */
3779 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3780
3781 #ifdef DWARF2_DEBUGGING_INFO
3782 /* This location is used by calc_die_sizes() to keep track
3783    the offset of each DIE within the .debug_info section.  */
3784 static unsigned long next_die_offset;
3785 #endif
3786
3787 /* Record the root of the DIE's built for the current compilation unit.  */
3788 static GTY(()) dw_die_ref comp_unit_die;
3789
3790 /* A list of DIEs with a NULL parent waiting to be relocated.  */
3791 static GTY(()) limbo_die_node *limbo_die_list;
3792
3793 /* Filenames referenced by this compilation unit.  */
3794 static GTY(()) varray_type file_table;
3795 static GTY(()) varray_type file_table_emitted;
3796 static GTY(()) size_t file_table_last_lookup_index;
3797
3798 /* A hash table of references to DIE's that describe declarations.
3799    The key is a DECL_UID() which is a unique number identifying each decl.  */
3800 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3801
3802 /* Node of the variable location list.  */
3803 struct var_loc_node GTY ((chain_next ("%h.next")))
3804 {
3805   rtx GTY (()) var_loc_note;
3806   const char * GTY (()) label;
3807   const char * GTY (()) section_label;
3808   struct var_loc_node * GTY (()) next;
3809 };
3810
3811 /* Variable location list.  */
3812 struct var_loc_list_def GTY (())
3813 {
3814   struct var_loc_node * GTY (()) first;
3815
3816   /* Do not mark the last element of the chained list because
3817      it is marked through the chain.  */
3818   struct var_loc_node * GTY ((skip ("%h"))) last;
3819
3820   /* DECL_UID of the variable decl.  */
3821   unsigned int decl_id;
3822 };
3823 typedef struct var_loc_list_def var_loc_list;
3824
3825
3826 /* Table of decl location linked lists.  */
3827 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3828
3829 /* A pointer to the base of a list of references to DIE's that
3830    are uniquely identified by their tag, presence/absence of
3831    children DIE's, and list of attribute/value pairs.  */
3832 static GTY((length ("abbrev_die_table_allocated")))
3833   dw_die_ref *abbrev_die_table;
3834
3835 /* Number of elements currently allocated for abbrev_die_table.  */
3836 static GTY(()) unsigned abbrev_die_table_allocated;
3837
3838 /* Number of elements in type_die_table currently in use.  */
3839 static GTY(()) unsigned abbrev_die_table_in_use;
3840
3841 /* Size (in elements) of increments by which we may expand the
3842    abbrev_die_table.  */
3843 #define ABBREV_DIE_TABLE_INCREMENT 256
3844
3845 /* A pointer to the base of a table that contains line information
3846    for each source code line in .text in the compilation unit.  */
3847 static GTY((length ("line_info_table_allocated")))
3848      dw_line_info_ref line_info_table;
3849
3850 /* Number of elements currently allocated for line_info_table.  */
3851 static GTY(()) unsigned line_info_table_allocated;
3852
3853 /* Number of elements in line_info_table currently in use.  */
3854 static GTY(()) unsigned line_info_table_in_use;
3855
3856 /* True if the compilation unit places functions in more than one section.  */
3857 static GTY(()) bool have_multiple_function_sections = false;
3858
3859 /* A pointer to the base of a table that contains line information
3860    for each source code line outside of .text in the compilation unit.  */
3861 static GTY ((length ("separate_line_info_table_allocated")))
3862      dw_separate_line_info_ref separate_line_info_table;
3863
3864 /* Number of elements currently allocated for separate_line_info_table.  */
3865 static GTY(()) unsigned separate_line_info_table_allocated;
3866
3867 /* Number of elements in separate_line_info_table currently in use.  */
3868 static GTY(()) unsigned separate_line_info_table_in_use;
3869
3870 /* Size (in elements) of increments by which we may expand the
3871    line_info_table.  */
3872 #define LINE_INFO_TABLE_INCREMENT 1024
3873
3874 /* A pointer to the base of a table that contains a list of publicly
3875    accessible names.  */
3876 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3877
3878 /* Number of elements currently allocated for pubname_table.  */
3879 static GTY(()) unsigned pubname_table_allocated;
3880
3881 /* Number of elements in pubname_table currently in use.  */
3882 static GTY(()) unsigned pubname_table_in_use;
3883
3884 /* Size (in elements) of increments by which we may expand the
3885    pubname_table.  */
3886 #define PUBNAME_TABLE_INCREMENT 64
3887
3888 /* Array of dies for which we should generate .debug_arange info.  */
3889 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3890
3891 /* Number of elements currently allocated for arange_table.  */
3892 static GTY(()) unsigned arange_table_allocated;
3893
3894 /* Number of elements in arange_table currently in use.  */
3895 static GTY(()) unsigned arange_table_in_use;
3896
3897 /* Size (in elements) of increments by which we may expand the
3898    arange_table.  */
3899 #define ARANGE_TABLE_INCREMENT 64
3900
3901 /* Array of dies for which we should generate .debug_ranges info.  */
3902 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3903
3904 /* Number of elements currently allocated for ranges_table.  */
3905 static GTY(()) unsigned ranges_table_allocated;
3906
3907 /* Number of elements in ranges_table currently in use.  */
3908 static GTY(()) unsigned ranges_table_in_use;
3909
3910 /* Size (in elements) of increments by which we may expand the
3911    ranges_table.  */
3912 #define RANGES_TABLE_INCREMENT 64
3913
3914 /* Whether we have location lists that need outputting */
3915 static GTY(()) bool have_location_lists;
3916
3917 /* Unique label counter.  */
3918 static GTY(()) unsigned int loclabel_num;
3919
3920 #ifdef DWARF2_DEBUGGING_INFO
3921 /* Record whether the function being analyzed contains inlined functions.  */
3922 static int current_function_has_inlines;
3923 #endif
3924 #if 0 && defined (MIPS_DEBUGGING_INFO)
3925 static int comp_unit_has_inlines;
3926 #endif
3927
3928 /* Number of file tables emitted in maybe_emit_file().  */
3929 static GTY(()) int emitcount = 0;
3930
3931 /* Number of internal labels generated by gen_internal_sym().  */
3932 static GTY(()) int label_num;
3933
3934 #ifdef DWARF2_DEBUGGING_INFO
3935
3936 /* Offset from the "steady-state frame pointer" to the frame base,
3937    within the current function.  */
3938 static HOST_WIDE_INT frame_pointer_fb_offset;
3939
3940 /* Forward declarations for functions defined in this file.  */
3941
3942 static int is_pseudo_reg (rtx);
3943 static tree type_main_variant (tree);
3944 static int is_tagged_type (tree);
3945 static const char *dwarf_tag_name (unsigned);
3946 static const char *dwarf_attr_name (unsigned);
3947 static const char *dwarf_form_name (unsigned);
3948 static tree decl_ultimate_origin (tree);
3949 static tree block_ultimate_origin (tree);
3950 static tree decl_class_context (tree);
3951 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3952 static inline enum dw_val_class AT_class (dw_attr_ref);
3953 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3954 static inline unsigned AT_flag (dw_attr_ref);
3955 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3956 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3957 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3958 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3959 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
3960                               unsigned long);
3961 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3962                                unsigned int, unsigned char *);
3963 static hashval_t debug_str_do_hash (const void *);
3964 static int debug_str_eq (const void *, const void *);
3965 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3966 static inline const char *AT_string (dw_attr_ref);
3967 static int AT_string_form (dw_attr_ref);
3968 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3969 static void add_AT_specification (dw_die_ref, dw_die_ref);
3970 static inline dw_die_ref AT_ref (dw_attr_ref);
3971 static inline int AT_ref_external (dw_attr_ref);
3972 static inline void set_AT_ref_external (dw_attr_ref, int);
3973 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3974 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3975 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3976 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3977                              dw_loc_list_ref);
3978 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3979 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3980 static inline rtx AT_addr (dw_attr_ref);
3981 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3982 static void add_AT_lbl_offset (dw_die_ref, enum dwarf_attribute, const char *);
3983 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3984                            unsigned HOST_WIDE_INT);
3985 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3986                                unsigned long);
3987 static inline const char *AT_lbl (dw_attr_ref);
3988 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3989 static const char *get_AT_low_pc (dw_die_ref);
3990 static const char *get_AT_hi_pc (dw_die_ref);
3991 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3992 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3993 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3994 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3995 static bool is_c_family (void);
3996 static bool is_cxx (void);
3997 static bool is_java (void);
3998 static bool is_fortran (void);
3999 static bool is_ada (void);
4000 static void remove_AT (dw_die_ref, enum dwarf_attribute);
4001 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
4002 static inline void free_die (dw_die_ref);
4003 static void remove_children (dw_die_ref);
4004 static void add_child_die (dw_die_ref, dw_die_ref);
4005 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4006 static dw_die_ref lookup_type_die (tree);
4007 static void equate_type_number_to_die (tree, dw_die_ref);
4008 static hashval_t decl_die_table_hash (const void *);
4009 static int decl_die_table_eq (const void *, const void *);
4010 static dw_die_ref lookup_decl_die (tree);
4011 static hashval_t decl_loc_table_hash (const void *);
4012 static int decl_loc_table_eq (const void *, const void *);
4013 static var_loc_list *lookup_decl_loc (tree);
4014 static void equate_decl_number_to_die (tree, dw_die_ref);
4015 static void add_var_loc_to_decl (tree, struct var_loc_node *);
4016 static void print_spaces (FILE *);
4017 static void print_die (dw_die_ref, FILE *);
4018 static void print_dwarf_line_table (FILE *);
4019 static void reverse_die_lists (dw_die_ref);
4020 static void reverse_all_dies (dw_die_ref);
4021 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4022 static dw_die_ref pop_compile_unit (dw_die_ref);
4023 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4024 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4025 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4026 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4027 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
4028 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4029 static int same_die_p (dw_die_ref, dw_die_ref, int *);
4030 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4031 static void compute_section_prefix (dw_die_ref);
4032 static int is_type_die (dw_die_ref);
4033 static int is_comdat_die (dw_die_ref);
4034 static int is_symbol_die (dw_die_ref);
4035 static void assign_symbol_names (dw_die_ref);
4036 static void break_out_includes (dw_die_ref);
4037 static hashval_t htab_cu_hash (const void *);
4038 static int htab_cu_eq (const void *, const void *);
4039 static void htab_cu_del (void *);
4040 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4041 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4042 static void add_sibling_attributes (dw_die_ref);
4043 static void build_abbrev_table (dw_die_ref);
4044 static void output_location_lists (dw_die_ref);
4045 static int constant_size (long unsigned);
4046 static unsigned long size_of_die (dw_die_ref);
4047 static void calc_die_sizes (dw_die_ref);
4048 static void mark_dies (dw_die_ref);
4049 static void unmark_dies (dw_die_ref);
4050 static void unmark_all_dies (dw_die_ref);
4051 static unsigned long size_of_pubnames (void);
4052 static unsigned long size_of_aranges (void);
4053 static enum dwarf_form value_format (dw_attr_ref);
4054 static void output_value_format (dw_attr_ref);
4055 static void output_abbrev_section (void);
4056 static void output_die_symbol (dw_die_ref);
4057 static void output_die (dw_die_ref);
4058 static void output_compilation_unit_header (void);
4059 static void output_comp_unit (dw_die_ref, int);
4060 static const char *dwarf2_name (tree, int);
4061 static void add_pubname (tree, dw_die_ref);
4062 static void output_pubnames (void);
4063 static void add_arange (tree, dw_die_ref);
4064 static void output_aranges (void);
4065 static unsigned int add_ranges (tree);
4066 static void output_ranges (void);
4067 static void output_line_info (void);
4068 static void output_file_names (void);
4069 static dw_die_ref base_type_die (tree);
4070 static tree root_type (tree);
4071 static int is_base_type (tree);
4072 static bool is_subrange_type (tree);
4073 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4074 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4075 static int type_is_enum (tree);
4076 static unsigned int dbx_reg_number (rtx);
4077 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4078 static dw_loc_descr_ref reg_loc_descriptor (rtx);
4079 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4080 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4081 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4082 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4083 static int is_based_loc (rtx);
4084 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4085 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4086 static dw_loc_descr_ref loc_descriptor (rtx);
4087 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4088 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4089 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4090 static tree field_type (tree);
4091 static unsigned int simple_type_align_in_bits (tree);
4092 static unsigned int simple_decl_align_in_bits (tree);
4093 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4094 static HOST_WIDE_INT field_byte_offset (tree);
4095 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4096                                          dw_loc_descr_ref);
4097 static void add_data_member_location_attribute (dw_die_ref, tree);
4098 static void add_const_value_attribute (dw_die_ref, rtx);
4099 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4100 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4101 static void insert_float (rtx, unsigned char *);
4102 static rtx rtl_for_decl_location (tree);
4103 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4104                                                    enum dwarf_attribute);
4105 static void tree_add_const_value_attribute (dw_die_ref, tree);
4106 static void add_name_attribute (dw_die_ref, const char *);
4107 static void add_comp_dir_attribute (dw_die_ref);
4108 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4109 static void add_subscript_info (dw_die_ref, tree);
4110 static void add_byte_size_attribute (dw_die_ref, tree);
4111 static void add_bit_offset_attribute (dw_die_ref, tree);
4112 static void add_bit_size_attribute (dw_die_ref, tree);
4113 static void add_prototyped_attribute (dw_die_ref, tree);
4114 static void add_abstract_origin_attribute (dw_die_ref, tree);
4115 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4116 static void add_src_coords_attributes (dw_die_ref, tree);
4117 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4118 static void push_decl_scope (tree);
4119 static void pop_decl_scope (void);
4120 static dw_die_ref scope_die_for (tree, dw_die_ref);
4121 static inline int local_scope_p (dw_die_ref);
4122 static inline int class_or_namespace_scope_p (dw_die_ref);
4123 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4124 static void add_calling_convention_attribute (dw_die_ref, tree);
4125 static const char *type_tag (tree);
4126 static tree member_declared_type (tree);
4127 #if 0
4128 static const char *decl_start_label (tree);
4129 #endif
4130 static void gen_array_type_die (tree, dw_die_ref);
4131 #if 0
4132 static void gen_entry_point_die (tree, dw_die_ref);
4133 #endif
4134 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4135 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4136 static void gen_inlined_union_type_die (tree, dw_die_ref);
4137 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4138 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4139 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4140 static void gen_formal_types_die (tree, dw_die_ref);
4141 static void gen_subprogram_die (tree, dw_die_ref);
4142 static void gen_variable_die (tree, dw_die_ref);
4143 static void gen_label_die (tree, dw_die_ref);
4144 static void gen_lexical_block_die (tree, dw_die_ref, int);
4145 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4146 static void gen_field_die (tree, dw_die_ref);
4147 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4148 static dw_die_ref gen_compile_unit_die (const char *);
4149 static void gen_inheritance_die (tree, tree, dw_die_ref);
4150 static void gen_member_die (tree, dw_die_ref);
4151 static void gen_struct_or_union_type_die (tree, dw_die_ref);
4152 static void gen_subroutine_type_die (tree, dw_die_ref);
4153 static void gen_typedef_die (tree, dw_die_ref);
4154 static void gen_type_die (tree, dw_die_ref);
4155 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4156 static void gen_block_die (tree, dw_die_ref, int);
4157 static void decls_for_scope (tree, dw_die_ref, int);
4158 static int is_redundant_typedef (tree);
4159 static void gen_namespace_die (tree);
4160 static void gen_decl_die (tree, dw_die_ref);
4161 static dw_die_ref force_decl_die (tree);
4162 static dw_die_ref force_type_die (tree);
4163 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4164 static void declare_in_namespace (tree, dw_die_ref);
4165 static unsigned lookup_filename (const char *);
4166 static void init_file_table (void);
4167 static void retry_incomplete_types (void);
4168 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4169 static void splice_child_die (dw_die_ref, dw_die_ref);
4170 static int file_info_cmp (const void *, const void *);
4171 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4172                                      const char *, const char *, unsigned);
4173 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4174                                        const char *, const char *,
4175                                        const char *);
4176 static void output_loc_list (dw_loc_list_ref);
4177 static char *gen_internal_sym (const char *);
4178
4179 static void prune_unmark_dies (dw_die_ref);
4180 static void prune_unused_types_mark (dw_die_ref, int);
4181 static void prune_unused_types_walk (dw_die_ref);
4182 static void prune_unused_types_walk_attribs (dw_die_ref);
4183 static void prune_unused_types_prune (dw_die_ref);
4184 static void prune_unused_types (void);
4185 static int maybe_emit_file (int);
4186
4187 /* Section names used to hold DWARF debugging information.  */
4188 #ifndef DEBUG_INFO_SECTION
4189 #define DEBUG_INFO_SECTION      ".debug_info"
4190 #endif
4191 #ifndef DEBUG_ABBREV_SECTION
4192 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
4193 #endif
4194 #ifndef DEBUG_ARANGES_SECTION
4195 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
4196 #endif
4197 #ifndef DEBUG_MACINFO_SECTION
4198 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
4199 #endif
4200 #ifndef DEBUG_LINE_SECTION
4201 #define DEBUG_LINE_SECTION      ".debug_line"
4202 #endif
4203 #ifndef DEBUG_LOC_SECTION
4204 #define DEBUG_LOC_SECTION       ".debug_loc"
4205 #endif
4206 #ifndef DEBUG_PUBNAMES_SECTION
4207 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
4208 #endif
4209 #ifndef DEBUG_STR_SECTION
4210 #define DEBUG_STR_SECTION       ".debug_str"
4211 #endif
4212 #ifndef DEBUG_RANGES_SECTION
4213 #define DEBUG_RANGES_SECTION    ".debug_ranges"
4214 #endif
4215
4216 /* Standard ELF section names for compiled code and data.  */
4217 #ifndef TEXT_SECTION_NAME
4218 #define TEXT_SECTION_NAME       ".text"
4219 #endif
4220
4221 /* Section flags for .debug_str section.  */
4222 #define DEBUG_STR_SECTION_FLAGS \
4223   (HAVE_GAS_SHF_MERGE && flag_merge_constants                   \
4224    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
4225    : SECTION_DEBUG)
4226
4227 /* Labels we insert at beginning sections we can reference instead of
4228    the section names themselves.  */
4229
4230 #ifndef TEXT_SECTION_LABEL
4231 #define TEXT_SECTION_LABEL              "Ltext"
4232 #endif
4233 #ifndef COLD_TEXT_SECTION_LABEL
4234 #define COLD_TEXT_SECTION_LABEL         "Ltext_cold"
4235 #endif
4236 #ifndef DEBUG_LINE_SECTION_LABEL
4237 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
4238 #endif
4239 #ifndef DEBUG_INFO_SECTION_LABEL
4240 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
4241 #endif
4242 #ifndef DEBUG_ABBREV_SECTION_LABEL
4243 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
4244 #endif
4245 #ifndef DEBUG_LOC_SECTION_LABEL
4246 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
4247 #endif
4248 #ifndef DEBUG_RANGES_SECTION_LABEL
4249 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
4250 #endif
4251 #ifndef DEBUG_MACINFO_SECTION_LABEL
4252 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
4253 #endif
4254
4255 /* Definitions of defaults for formats and names of various special
4256    (artificial) labels which may be generated within this file (when the -g
4257    options is used and DWARF2_DEBUGGING_INFO is in effect.
4258    If necessary, these may be overridden from within the tm.h file, but
4259    typically, overriding these defaults is unnecessary.  */
4260
4261 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4262 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4263 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4264 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4265 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4266 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4267 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4268 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4269 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4270 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4271
4272 #ifndef TEXT_END_LABEL
4273 #define TEXT_END_LABEL          "Letext"
4274 #endif
4275 #ifndef COLD_END_LABEL
4276 #define COLD_END_LABEL          "Letext_cold"
4277 #endif
4278 #ifndef BLOCK_BEGIN_LABEL
4279 #define BLOCK_BEGIN_LABEL       "LBB"
4280 #endif
4281 #ifndef BLOCK_END_LABEL
4282 #define BLOCK_END_LABEL         "LBE"
4283 #endif
4284 #ifndef LINE_CODE_LABEL
4285 #define LINE_CODE_LABEL         "LM"
4286 #endif
4287 #ifndef SEPARATE_LINE_CODE_LABEL
4288 #define SEPARATE_LINE_CODE_LABEL        "LSM"
4289 #endif
4290 \f
4291 /* We allow a language front-end to designate a function that is to be
4292    called to "demangle" any name before it is put into a DIE.  */
4293
4294 static const char *(*demangle_name_func) (const char *);
4295
4296 void
4297 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4298 {
4299   demangle_name_func = func;
4300 }
4301
4302 /* Test if rtl node points to a pseudo register.  */
4303
4304 static inline int
4305 is_pseudo_reg (rtx rtl)
4306 {
4307   return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4308           || (GET_CODE (rtl) == SUBREG
4309               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4310 }
4311
4312 /* Return a reference to a type, with its const and volatile qualifiers
4313    removed.  */
4314
4315 static inline tree
4316 type_main_variant (tree type)
4317 {
4318   type = TYPE_MAIN_VARIANT (type);
4319
4320   /* ??? There really should be only one main variant among any group of
4321      variants of a given type (and all of the MAIN_VARIANT values for all
4322      members of the group should point to that one type) but sometimes the C
4323      front-end messes this up for array types, so we work around that bug
4324      here.  */
4325   if (TREE_CODE (type) == ARRAY_TYPE)
4326     while (type != TYPE_MAIN_VARIANT (type))
4327       type = TYPE_MAIN_VARIANT (type);
4328
4329   return type;
4330 }
4331
4332 /* Return nonzero if the given type node represents a tagged type.  */
4333
4334 static inline int
4335 is_tagged_type (tree type)
4336 {
4337   enum tree_code code = TREE_CODE (type);
4338
4339   return (code == RECORD_TYPE || code == UNION_TYPE
4340           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4341 }
4342
4343 /* Convert a DIE tag into its string name.  */
4344
4345 static const char *
4346 dwarf_tag_name (unsigned int tag)
4347 {
4348   switch (tag)
4349     {
4350     case DW_TAG_padding:
4351       return "DW_TAG_padding";
4352     case DW_TAG_array_type:
4353       return "DW_TAG_array_type";
4354     case DW_TAG_class_type:
4355       return "DW_TAG_class_type";
4356     case DW_TAG_entry_point:
4357       return "DW_TAG_entry_point";
4358     case DW_TAG_enumeration_type:
4359       return "DW_TAG_enumeration_type";
4360     case DW_TAG_formal_parameter:
4361       return "DW_TAG_formal_parameter";
4362     case DW_TAG_imported_declaration:
4363       return "DW_TAG_imported_declaration";
4364     case DW_TAG_label:
4365       return "DW_TAG_label";
4366     case DW_TAG_lexical_block:
4367       return "DW_TAG_lexical_block";
4368     case DW_TAG_member:
4369       return "DW_TAG_member";
4370     case DW_TAG_pointer_type:
4371       return "DW_TAG_pointer_type";
4372     case DW_TAG_reference_type:
4373       return "DW_TAG_reference_type";
4374     case DW_TAG_compile_unit:
4375       return "DW_TAG_compile_unit";
4376     case DW_TAG_string_type:
4377       return "DW_TAG_string_type";
4378     case DW_TAG_structure_type:
4379       return "DW_TAG_structure_type";
4380     case DW_TAG_subroutine_type:
4381       return "DW_TAG_subroutine_type";
4382     case DW_TAG_typedef:
4383       return "DW_TAG_typedef";
4384     case DW_TAG_union_type:
4385       return "DW_TAG_union_type";
4386     case DW_TAG_unspecified_parameters:
4387       return "DW_TAG_unspecified_parameters";
4388     case DW_TAG_variant:
4389       return "DW_TAG_variant";
4390     case DW_TAG_common_block:
4391       return "DW_TAG_common_block";
4392     case DW_TAG_common_inclusion:
4393       return "DW_TAG_common_inclusion";
4394     case DW_TAG_inheritance:
4395       return "DW_TAG_inheritance";
4396     case DW_TAG_inlined_subroutine:
4397       return "DW_TAG_inlined_subroutine";
4398     case DW_TAG_module:
4399       return "DW_TAG_module";
4400     case DW_TAG_ptr_to_member_type:
4401       return "DW_TAG_ptr_to_member_type";
4402     case DW_TAG_set_type:
4403       return "DW_TAG_set_type";
4404     case DW_TAG_subrange_type:
4405       return "DW_TAG_subrange_type";
4406     case DW_TAG_with_stmt:
4407       return "DW_TAG_with_stmt";
4408     case DW_TAG_access_declaration:
4409       return "DW_TAG_access_declaration";
4410     case DW_TAG_base_type:
4411       return "DW_TAG_base_type";
4412     case DW_TAG_catch_block:
4413       return "DW_TAG_catch_block";
4414     case DW_TAG_const_type:
4415       return "DW_TAG_const_type";
4416     case DW_TAG_constant:
4417       return "DW_TAG_constant";
4418     case DW_TAG_enumerator:
4419       return "DW_TAG_enumerator";
4420     case DW_TAG_file_type:
4421       return "DW_TAG_file_type";
4422     case DW_TAG_friend:
4423       return "DW_TAG_friend";
4424     case DW_TAG_namelist:
4425       return "DW_TAG_namelist";
4426     case DW_TAG_namelist_item:
4427       return "DW_TAG_namelist_item";
4428     case DW_TAG_namespace:
4429       return "DW_TAG_namespace";
4430     case DW_TAG_packed_type:
4431       return "DW_TAG_packed_type";
4432     case DW_TAG_subprogram:
4433       return "DW_TAG_subprogram";
4434     case DW_TAG_template_type_param:
4435       return "DW_TAG_template_type_param";
4436     case DW_TAG_template_value_param:
4437       return "DW_TAG_template_value_param";
4438     case DW_TAG_thrown_type:
4439       return "DW_TAG_thrown_type";
4440     case DW_TAG_try_block:
4441       return "DW_TAG_try_block";
4442     case DW_TAG_variant_part:
4443       return "DW_TAG_variant_part";
4444     case DW_TAG_variable:
4445       return "DW_TAG_variable";
4446     case DW_TAG_volatile_type:
4447       return "DW_TAG_volatile_type";
4448     case DW_TAG_imported_module:
4449       return "DW_TAG_imported_module";
4450     case DW_TAG_MIPS_loop:
4451       return "DW_TAG_MIPS_loop";
4452     case DW_TAG_format_label:
4453       return "DW_TAG_format_label";
4454     case DW_TAG_function_template:
4455       return "DW_TAG_function_template";
4456     case DW_TAG_class_template:
4457       return "DW_TAG_class_template";
4458     case DW_TAG_GNU_BINCL:
4459       return "DW_TAG_GNU_BINCL";
4460     case DW_TAG_GNU_EINCL:
4461       return "DW_TAG_GNU_EINCL";
4462     default:
4463       return "DW_TAG_<unknown>";
4464     }
4465 }
4466
4467 /* Convert a DWARF attribute code into its string name.  */
4468
4469 static const char *
4470 dwarf_attr_name (unsigned int attr)
4471 {
4472   switch (attr)
4473     {
4474     case DW_AT_sibling:
4475       return "DW_AT_sibling";
4476     case DW_AT_location:
4477       return "DW_AT_location";
4478     case DW_AT_name:
4479       return "DW_AT_name";
4480     case DW_AT_ordering:
4481       return "DW_AT_ordering";
4482     case DW_AT_subscr_data:
4483       return "DW_AT_subscr_data";
4484     case DW_AT_byte_size:
4485       return "DW_AT_byte_size";
4486     case DW_AT_bit_offset:
4487       return "DW_AT_bit_offset";
4488     case DW_AT_bit_size:
4489       return "DW_AT_bit_size";
4490     case DW_AT_element_list:
4491       return "DW_AT_element_list";
4492     case DW_AT_stmt_list:
4493       return "DW_AT_stmt_list";
4494     case DW_AT_low_pc:
4495       return "DW_AT_low_pc";
4496     case DW_AT_high_pc:
4497       return "DW_AT_high_pc";
4498     case DW_AT_language:
4499       return "DW_AT_language";
4500     case DW_AT_member:
4501       return "DW_AT_member";
4502     case DW_AT_discr:
4503       return "DW_AT_discr";
4504     case DW_AT_discr_value:
4505       return "DW_AT_discr_value";
4506     case DW_AT_visibility:
4507       return "DW_AT_visibility";
4508     case DW_AT_import:
4509       return "DW_AT_import";
4510     case DW_AT_string_length:
4511       return "DW_AT_string_length";
4512     case DW_AT_common_reference:
4513       return "DW_AT_common_reference";
4514     case DW_AT_comp_dir:
4515       return "DW_AT_comp_dir";
4516     case DW_AT_const_value:
4517       return "DW_AT_const_value";
4518     case DW_AT_containing_type:
4519       return "DW_AT_containing_type";
4520     case DW_AT_default_value:
4521       return "DW_AT_default_value";
4522     case DW_AT_inline:
4523       return "DW_AT_inline";
4524     case DW_AT_is_optional:
4525       return "DW_AT_is_optional";
4526     case DW_AT_lower_bound:
4527       return "DW_AT_lower_bound";
4528     case DW_AT_producer:
4529       return "DW_AT_producer";
4530     case DW_AT_prototyped:
4531       return "DW_AT_prototyped";
4532     case DW_AT_return_addr:
4533       return "DW_AT_return_addr";
4534     case DW_AT_start_scope:
4535       return "DW_AT_start_scope";
4536     case DW_AT_stride_size:
4537       return "DW_AT_stride_size";
4538     case DW_AT_upper_bound:
4539       return "DW_AT_upper_bound";
4540     case DW_AT_abstract_origin:
4541       return "DW_AT_abstract_origin";
4542     case DW_AT_accessibility:
4543       return "DW_AT_accessibility";
4544     case DW_AT_address_class:
4545       return "DW_AT_address_class";
4546     case DW_AT_artificial:
4547       return "DW_AT_artificial";
4548     case DW_AT_base_types:
4549       return "DW_AT_base_types";
4550     case DW_AT_calling_convention:
4551       return "DW_AT_calling_convention";
4552     case DW_AT_count:
4553       return "DW_AT_count";
4554     case DW_AT_data_member_location:
4555       return "DW_AT_data_member_location";
4556     case DW_AT_decl_column:
4557       return "DW_AT_decl_column";
4558     case DW_AT_decl_file:
4559       return "DW_AT_decl_file";
4560     case DW_AT_decl_line:
4561       return "DW_AT_decl_line";
4562     case DW_AT_declaration:
4563       return "DW_AT_declaration";
4564     case DW_AT_discr_list:
4565       return "DW_AT_discr_list";
4566     case DW_AT_encoding:
4567       return "DW_AT_encoding";
4568     case DW_AT_external:
4569       return "DW_AT_external";
4570     case DW_AT_frame_base:
4571       return "DW_AT_frame_base";
4572     case DW_AT_friend:
4573       return "DW_AT_friend";
4574     case DW_AT_identifier_case:
4575       return "DW_AT_identifier_case";
4576     case DW_AT_macro_info:
4577       return "DW_AT_macro_info";
4578     case DW_AT_namelist_items:
4579       return "DW_AT_namelist_items";
4580     case DW_AT_priority:
4581       return "DW_AT_priority";
4582     case DW_AT_segment:
4583       return "DW_AT_segment";
4584     case DW_AT_specification:
4585       return "DW_AT_specification";
4586     case DW_AT_static_link:
4587       return "DW_AT_static_link";
4588     case DW_AT_type:
4589       return "DW_AT_type";
4590     case DW_AT_use_location:
4591       return "DW_AT_use_location";
4592     case DW_AT_variable_parameter:
4593       return "DW_AT_variable_parameter";
4594     case DW_AT_virtuality:
4595       return "DW_AT_virtuality";
4596     case DW_AT_vtable_elem_location:
4597       return "DW_AT_vtable_elem_location";
4598
4599     case DW_AT_allocated:
4600       return "DW_AT_allocated";
4601     case DW_AT_associated:
4602       return "DW_AT_associated";
4603     case DW_AT_data_location:
4604       return "DW_AT_data_location";
4605     case DW_AT_stride:
4606       return "DW_AT_stride";
4607     case DW_AT_entry_pc:
4608       return "DW_AT_entry_pc";
4609     case DW_AT_use_UTF8:
4610       return "DW_AT_use_UTF8";
4611     case DW_AT_extension:
4612       return "DW_AT_extension";
4613     case DW_AT_ranges:
4614       return "DW_AT_ranges";
4615     case DW_AT_trampoline:
4616       return "DW_AT_trampoline";
4617     case DW_AT_call_column:
4618       return "DW_AT_call_column";
4619     case DW_AT_call_file:
4620       return "DW_AT_call_file";
4621     case DW_AT_call_line:
4622       return "DW_AT_call_line";
4623
4624     case DW_AT_MIPS_fde:
4625       return "DW_AT_MIPS_fde";
4626     case DW_AT_MIPS_loop_begin:
4627       return "DW_AT_MIPS_loop_begin";
4628     case DW_AT_MIPS_tail_loop_begin:
4629       return "DW_AT_MIPS_tail_loop_begin";
4630     case DW_AT_MIPS_epilog_begin:
4631       return "DW_AT_MIPS_epilog_begin";
4632     case DW_AT_MIPS_loop_unroll_factor:
4633       return "DW_AT_MIPS_loop_unroll_factor";
4634     case DW_AT_MIPS_software_pipeline_depth:
4635       return "DW_AT_MIPS_software_pipeline_depth";
4636     case DW_AT_MIPS_linkage_name:
4637       return "DW_AT_MIPS_linkage_name";
4638     case DW_AT_MIPS_stride:
4639       return "DW_AT_MIPS_stride";
4640     case DW_AT_MIPS_abstract_name:
4641       return "DW_AT_MIPS_abstract_name";
4642     case DW_AT_MIPS_clone_origin:
4643       return "DW_AT_MIPS_clone_origin";
4644     case DW_AT_MIPS_has_inlines:
4645       return "DW_AT_MIPS_has_inlines";
4646
4647     case DW_AT_sf_names:
4648       return "DW_AT_sf_names";
4649     case DW_AT_src_info:
4650       return "DW_AT_src_info";
4651     case DW_AT_mac_info:
4652       return "DW_AT_mac_info";
4653     case DW_AT_src_coords:
4654       return "DW_AT_src_coords";
4655     case DW_AT_body_begin:
4656       return "DW_AT_body_begin";
4657     case DW_AT_body_end:
4658       return "DW_AT_body_end";
4659     case DW_AT_GNU_vector:
4660       return "DW_AT_GNU_vector";
4661
4662     case DW_AT_VMS_rtnbeg_pd_address:
4663       return "DW_AT_VMS_rtnbeg_pd_address";
4664
4665     default:
4666       return "DW_AT_<unknown>";
4667     }
4668 }
4669
4670 /* Convert a DWARF value form code into its string name.  */
4671
4672 static const char *
4673 dwarf_form_name (unsigned int form)
4674 {
4675   switch (form)
4676     {
4677     case DW_FORM_addr:
4678       return "DW_FORM_addr";
4679     case DW_FORM_block2:
4680       return "DW_FORM_block2";
4681     case DW_FORM_block4:
4682       return "DW_FORM_block4";
4683     case DW_FORM_data2:
4684       return "DW_FORM_data2";
4685     case DW_FORM_data4:
4686       return "DW_FORM_data4";
4687     case DW_FORM_data8:
4688       return "DW_FORM_data8";
4689     case DW_FORM_string:
4690       return "DW_FORM_string";
4691     case DW_FORM_block:
4692       return "DW_FORM_block";
4693     case DW_FORM_block1:
4694       return "DW_FORM_block1";
4695     case DW_FORM_data1:
4696       return "DW_FORM_data1";
4697     case DW_FORM_flag:
4698       return "DW_FORM_flag";
4699     case DW_FORM_sdata:
4700       return "DW_FORM_sdata";
4701     case DW_FORM_strp:
4702       return "DW_FORM_strp";
4703     case DW_FORM_udata:
4704       return "DW_FORM_udata";
4705     case DW_FORM_ref_addr:
4706       return "DW_FORM_ref_addr";
4707     case DW_FORM_ref1:
4708       return "DW_FORM_ref1";
4709     case DW_FORM_ref2:
4710       return "DW_FORM_ref2";
4711     case DW_FORM_ref4:
4712       return "DW_FORM_ref4";
4713     case DW_FORM_ref8:
4714       return "DW_FORM_ref8";
4715     case DW_FORM_ref_udata:
4716       return "DW_FORM_ref_udata";
4717     case DW_FORM_indirect:
4718       return "DW_FORM_indirect";
4719     default:
4720       return "DW_FORM_<unknown>";
4721     }
4722 }
4723 \f
4724 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
4725    instance of an inlined instance of a decl which is local to an inline
4726    function, so we have to trace all of the way back through the origin chain
4727    to find out what sort of node actually served as the original seed for the
4728    given block.  */
4729
4730 static tree
4731 decl_ultimate_origin (tree decl)
4732 {
4733   if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4734     return NULL_TREE;
4735
4736   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4737      nodes in the function to point to themselves; ignore that if
4738      we're trying to output the abstract instance of this function.  */
4739   if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4740     return NULL_TREE;
4741
4742   /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4743      most distant ancestor, this should never happen.  */
4744   gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4745
4746   return DECL_ABSTRACT_ORIGIN (decl);
4747 }
4748
4749 /* Determine the "ultimate origin" of a block.  The block may be an inlined
4750    instance of an inlined instance of a block which is local to an inline
4751    function, so we have to trace all of the way back through the origin chain
4752    to find out what sort of node actually served as the original seed for the
4753    given block.  */
4754
4755 static tree
4756 block_ultimate_origin (tree block)
4757 {
4758   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4759
4760   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4761      nodes in the function to point to themselves; ignore that if
4762      we're trying to output the abstract instance of this function.  */
4763   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4764     return NULL_TREE;
4765
4766   if (immediate_origin == NULL_TREE)
4767     return NULL_TREE;
4768   else
4769     {
4770       tree ret_val;
4771       tree lookahead = immediate_origin;
4772
4773       do
4774         {
4775           ret_val = lookahead;
4776           lookahead = (TREE_CODE (ret_val) == BLOCK
4777                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4778         }
4779       while (lookahead != NULL && lookahead != ret_val);
4780
4781       /* The block's abstract origin chain may not be the *ultimate* origin of
4782          the block. It could lead to a DECL that has an abstract origin set.
4783          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4784          will give us if it has one).  Note that DECL's abstract origins are
4785          supposed to be the most distant ancestor (or so decl_ultimate_origin
4786          claims), so we don't need to loop following the DECL origins.  */
4787       if (DECL_P (ret_val))
4788         return DECL_ORIGIN (ret_val);
4789
4790       return ret_val;
4791     }
4792 }
4793
4794 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
4795    of a virtual function may refer to a base class, so we check the 'this'
4796    parameter.  */
4797
4798 static tree
4799 decl_class_context (tree decl)
4800 {
4801   tree context = NULL_TREE;
4802
4803   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4804     context = DECL_CONTEXT (decl);
4805   else
4806     context = TYPE_MAIN_VARIANT
4807       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4808
4809   if (context && !TYPE_P (context))
4810     context = NULL_TREE;
4811
4812   return context;
4813 }
4814 \f
4815 /* Add an attribute/value pair to a DIE.  We build the lists up in reverse
4816    addition order, and correct that in reverse_all_dies.  */
4817
4818 static inline void
4819 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4820 {
4821   if (die != NULL && attr != NULL)
4822     {
4823       attr->dw_attr_next = die->die_attr;
4824       die->die_attr = attr;
4825     }
4826 }
4827
4828 static inline enum dw_val_class
4829 AT_class (dw_attr_ref a)
4830 {
4831   return a->dw_attr_val.val_class;
4832 }
4833
4834 /* Add a flag value attribute to a DIE.  */
4835
4836 static inline void
4837 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4838 {
4839   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4840
4841   attr->dw_attr_next = NULL;
4842   attr->dw_attr = attr_kind;
4843   attr->dw_attr_val.val_class = dw_val_class_flag;
4844   attr->dw_attr_val.v.val_flag = flag;
4845   add_dwarf_attr (die, attr);
4846 }
4847
4848 static inline unsigned
4849 AT_flag (dw_attr_ref a)
4850 {
4851   gcc_assert (a && AT_class (a) == dw_val_class_flag);
4852   return a->dw_attr_val.v.val_flag;
4853 }
4854
4855 /* Add a signed integer attribute value to a DIE.  */
4856
4857 static inline void
4858 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4859 {
4860   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4861
4862   attr->dw_attr_next = NULL;
4863   attr->dw_attr = attr_kind;
4864   attr->dw_attr_val.val_class = dw_val_class_const;
4865   attr->dw_attr_val.v.val_int = int_val;
4866   add_dwarf_attr (die, attr);
4867 }
4868
4869 static inline HOST_WIDE_INT
4870 AT_int (dw_attr_ref a)
4871 {
4872   gcc_assert (a && AT_class (a) == dw_val_class_const);
4873   return a->dw_attr_val.v.val_int;
4874 }
4875
4876 /* Add an unsigned integer attribute value to a DIE.  */
4877
4878 static inline void
4879 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4880                  unsigned HOST_WIDE_INT unsigned_val)
4881 {
4882   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4883
4884   attr->dw_attr_next = NULL;
4885   attr->dw_attr = attr_kind;
4886   attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
4887   attr->dw_attr_val.v.val_unsigned = unsigned_val;
4888   add_dwarf_attr (die, attr);
4889 }
4890
4891 static inline unsigned HOST_WIDE_INT
4892 AT_unsigned (dw_attr_ref a)
4893 {
4894   gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4895   return a->dw_attr_val.v.val_unsigned;
4896 }
4897
4898 /* Add an unsigned double integer attribute value to a DIE.  */
4899
4900 static inline void
4901 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4902                   long unsigned int val_hi, long unsigned int val_low)
4903 {
4904   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4905
4906   attr->dw_attr_next = NULL;
4907   attr->dw_attr = attr_kind;
4908   attr->dw_attr_val.val_class = dw_val_class_long_long;
4909   attr->dw_attr_val.v.val_long_long.hi = val_hi;
4910   attr->dw_attr_val.v.val_long_long.low = val_low;
4911   add_dwarf_attr (die, attr);
4912 }
4913
4914 /* Add a floating point attribute value to a DIE and return it.  */
4915
4916 static inline void
4917 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4918             unsigned int length, unsigned int elt_size, unsigned char *array)
4919 {
4920   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4921
4922   attr->dw_attr_next = NULL;
4923   attr->dw_attr = attr_kind;
4924   attr->dw_attr_val.val_class = dw_val_class_vec;
4925   attr->dw_attr_val.v.val_vec.length = length;
4926   attr->dw_attr_val.v.val_vec.elt_size = elt_size;
4927   attr->dw_attr_val.v.val_vec.array = array;
4928   add_dwarf_attr (die, attr);
4929 }
4930
4931 /* Hash and equality functions for debug_str_hash.  */
4932
4933 static hashval_t
4934 debug_str_do_hash (const void *x)
4935 {
4936   return htab_hash_string (((const struct indirect_string_node *)x)->str);
4937 }
4938
4939 static int
4940 debug_str_eq (const void *x1, const void *x2)
4941 {
4942   return strcmp ((((const struct indirect_string_node *)x1)->str),
4943                  (const char *)x2) == 0;
4944 }
4945
4946 /* Add a string attribute value to a DIE.  */
4947
4948 static inline void
4949 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4950 {
4951   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4952   struct indirect_string_node *node;
4953   void **slot;
4954
4955   if (! debug_str_hash)
4956     debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
4957                                       debug_str_eq, NULL);
4958
4959   slot = htab_find_slot_with_hash (debug_str_hash, str,
4960                                    htab_hash_string (str), INSERT);
4961   if (*slot == NULL)
4962     *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
4963   node = (struct indirect_string_node *) *slot;
4964   node->str = ggc_strdup (str);
4965   node->refcount++;
4966
4967   attr->dw_attr_next = NULL;
4968   attr->dw_attr = attr_kind;
4969   attr->dw_attr_val.val_class = dw_val_class_str;
4970   attr->dw_attr_val.v.val_str = node;
4971   add_dwarf_attr (die, attr);
4972 }
4973
4974 static inline const char *
4975 AT_string (dw_attr_ref a)
4976 {
4977   gcc_assert (a && AT_class (a) == dw_val_class_str);
4978   return a->dw_attr_val.v.val_str->str;
4979 }
4980
4981 /* Find out whether a string should be output inline in DIE
4982    or out-of-line in .debug_str section.  */
4983
4984 static int
4985 AT_string_form (dw_attr_ref a)
4986 {
4987   struct indirect_string_node *node;
4988   unsigned int len;
4989   char label[32];
4990
4991   gcc_assert (a && AT_class (a) == dw_val_class_str);
4992
4993   node = a->dw_attr_val.v.val_str;
4994   if (node->form)
4995     return node->form;
4996
4997   len = strlen (node->str) + 1;
4998
4999   /* If the string is shorter or equal to the size of the reference, it is
5000      always better to put it inline.  */
5001   if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5002     return node->form = DW_FORM_string;
5003
5004   /* If we cannot expect the linker to merge strings in .debug_str
5005      section, only put it into .debug_str if it is worth even in this
5006      single module.  */
5007   if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5008       && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5009     return node->form = DW_FORM_string;
5010
5011   ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5012   ++dw2_string_counter;
5013   node->label = xstrdup (label);
5014
5015   return node->form = DW_FORM_strp;
5016 }
5017
5018 /* Add a DIE reference attribute value to a DIE.  */
5019
5020 static inline void
5021 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5022 {
5023   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5024
5025   attr->dw_attr_next = NULL;
5026   attr->dw_attr = attr_kind;
5027   attr->dw_attr_val.val_class = dw_val_class_die_ref;
5028   attr->dw_attr_val.v.val_die_ref.die = targ_die;
5029   attr->dw_attr_val.v.val_die_ref.external = 0;
5030   add_dwarf_attr (die, attr);
5031 }
5032
5033 /* Add an AT_specification attribute to a DIE, and also make the back
5034    pointer from the specification to the definition.  */
5035
5036 static inline void
5037 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5038 {
5039   add_AT_die_ref (die, DW_AT_specification, targ_die);
5040   gcc_assert (!targ_die->die_definition);
5041   targ_die->die_definition = die;
5042 }
5043
5044 static inline dw_die_ref
5045 AT_ref (dw_attr_ref a)
5046 {
5047   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5048   return a->dw_attr_val.v.val_die_ref.die;
5049 }
5050
5051 static inline int
5052 AT_ref_external (dw_attr_ref a)
5053 {
5054   if (a && AT_class (a) == dw_val_class_die_ref)
5055     return a->dw_attr_val.v.val_die_ref.external;
5056
5057   return 0;
5058 }
5059
5060 static inline void
5061 set_AT_ref_external (dw_attr_ref a, int i)
5062 {
5063   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5064   a->dw_attr_val.v.val_die_ref.external = i;
5065 }
5066
5067 /* Add an FDE reference attribute value to a DIE.  */
5068
5069 static inline void
5070 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5071 {
5072   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5073
5074   attr->dw_attr_next = NULL;
5075   attr->dw_attr = attr_kind;
5076   attr->dw_attr_val.val_class = dw_val_class_fde_ref;
5077   attr->dw_attr_val.v.val_fde_index = targ_fde;
5078   add_dwarf_attr (die, attr);
5079 }
5080
5081 /* Add a location description attribute value to a DIE.  */
5082
5083 static inline void
5084 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5085 {
5086   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5087
5088   attr->dw_attr_next = NULL;
5089   attr->dw_attr = attr_kind;
5090   attr->dw_attr_val.val_class = dw_val_class_loc;
5091   attr->dw_attr_val.v.val_loc = loc;
5092   add_dwarf_attr (die, attr);
5093 }
5094
5095 static inline dw_loc_descr_ref
5096 AT_loc (dw_attr_ref a)
5097 {
5098   gcc_assert (a && AT_class (a) == dw_val_class_loc);
5099   return a->dw_attr_val.v.val_loc;
5100 }
5101
5102 static inline void
5103 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5104 {
5105   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5106
5107   attr->dw_attr_next = NULL;
5108   attr->dw_attr = attr_kind;
5109   attr->dw_attr_val.val_class = dw_val_class_loc_list;
5110   attr->dw_attr_val.v.val_loc_list = loc_list;
5111   add_dwarf_attr (die, attr);
5112   have_location_lists = true;
5113 }
5114
5115 static inline dw_loc_list_ref
5116 AT_loc_list (dw_attr_ref a)
5117 {
5118   gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5119   return a->dw_attr_val.v.val_loc_list;
5120 }
5121
5122 /* Add an address constant attribute value to a DIE.  */
5123
5124 static inline void
5125 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5126 {
5127   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5128
5129   attr->dw_attr_next = NULL;
5130   attr->dw_attr = attr_kind;
5131   attr->dw_attr_val.val_class = dw_val_class_addr;
5132   attr->dw_attr_val.v.val_addr = addr;
5133   add_dwarf_attr (die, attr);
5134 }
5135
5136 static inline rtx
5137 AT_addr (dw_attr_ref a)
5138 {
5139   gcc_assert (a && AT_class (a) == dw_val_class_addr);
5140   return a->dw_attr_val.v.val_addr;
5141 }
5142
5143 /* Add a label identifier attribute value to a DIE.  */
5144
5145 static inline void
5146 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5147 {
5148   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5149
5150   attr->dw_attr_next = NULL;
5151   attr->dw_attr = attr_kind;
5152   attr->dw_attr_val.val_class = dw_val_class_lbl_id;
5153   attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5154   add_dwarf_attr (die, attr);
5155 }
5156
5157 /* Add a section offset attribute value to a DIE.  */
5158
5159 static inline void
5160 add_AT_lbl_offset (dw_die_ref die, enum dwarf_attribute attr_kind, const char *label)
5161 {
5162   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5163
5164   attr->dw_attr_next = NULL;
5165   attr->dw_attr = attr_kind;
5166   attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
5167   attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
5168   add_dwarf_attr (die, attr);
5169 }
5170
5171 /* Add an offset attribute value to a DIE.  */
5172
5173 static inline void
5174 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5175                unsigned HOST_WIDE_INT offset)
5176 {
5177   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5178
5179   attr->dw_attr_next = NULL;
5180   attr->dw_attr = attr_kind;
5181   attr->dw_attr_val.val_class = dw_val_class_offset;
5182   attr->dw_attr_val.v.val_offset = offset;
5183   add_dwarf_attr (die, attr);
5184 }
5185
5186 /* Add an range_list attribute value to a DIE.  */
5187
5188 static void
5189 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5190                    long unsigned int offset)
5191 {
5192   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5193
5194   attr->dw_attr_next = NULL;
5195   attr->dw_attr = attr_kind;
5196   attr->dw_attr_val.val_class = dw_val_class_range_list;
5197   attr->dw_attr_val.v.val_offset = offset;
5198   add_dwarf_attr (die, attr);
5199 }
5200
5201 static inline const char *
5202 AT_lbl (dw_attr_ref a)
5203 {
5204   gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5205                     || AT_class (a) == dw_val_class_lbl_offset));
5206   return a->dw_attr_val.v.val_lbl_id;
5207 }
5208
5209 /* Get the attribute of type attr_kind.  */
5210
5211 static dw_attr_ref
5212 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5213 {
5214   dw_attr_ref a;
5215   dw_die_ref spec = NULL;
5216
5217   if (die != NULL)
5218     {
5219       for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5220         if (a->dw_attr == attr_kind)
5221           return a;
5222         else if (a->dw_attr == DW_AT_specification
5223                  || a->dw_attr == DW_AT_abstract_origin)
5224           spec = AT_ref (a);
5225
5226       if (spec)
5227         return get_AT (spec, attr_kind);
5228     }
5229
5230   return NULL;
5231 }
5232
5233 /* Return the "low pc" attribute value, typically associated with a subprogram
5234    DIE.  Return null if the "low pc" attribute is either not present, or if it
5235    cannot be represented as an assembler label identifier.  */
5236
5237 static inline const char *
5238 get_AT_low_pc (dw_die_ref die)
5239 {
5240   dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5241
5242   return a ? AT_lbl (a) : NULL;
5243 }
5244
5245 /* Return the "high pc" attribute value, typically associated with a subprogram
5246    DIE.  Return null if the "high pc" attribute is either not present, or if it
5247    cannot be represented as an assembler label identifier.  */
5248
5249 static inline const char *
5250 get_AT_hi_pc (dw_die_ref die)
5251 {
5252   dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5253
5254   return a ? AT_lbl (a) : NULL;
5255 }
5256
5257 /* Return the value of the string attribute designated by ATTR_KIND, or
5258    NULL if it is not present.  */
5259
5260 static inline const char *
5261 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5262 {
5263   dw_attr_ref a = get_AT (die, attr_kind);
5264
5265   return a ? AT_string (a) : NULL;
5266 }
5267
5268 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5269    if it is not present.  */
5270
5271 static inline int
5272 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5273 {
5274   dw_attr_ref a = get_AT (die, attr_kind);
5275
5276   return a ? AT_flag (a) : 0;
5277 }
5278
5279 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5280    if it is not present.  */
5281
5282 static inline unsigned
5283 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5284 {
5285   dw_attr_ref a = get_AT (die, attr_kind);
5286
5287   return a ? AT_unsigned (a) : 0;
5288 }
5289
5290 static inline dw_die_ref
5291 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5292 {
5293   dw_attr_ref a = get_AT (die, attr_kind);
5294
5295   return a ? AT_ref (a) : NULL;
5296 }
5297
5298 /* Return TRUE if the language is C or C++.  */
5299
5300 static inline bool
5301 is_c_family (void)
5302 {
5303   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5304
5305   return (lang == DW_LANG_C || lang == DW_LANG_C89
5306           || lang == DW_LANG_C_plus_plus);
5307 }
5308
5309 /* Return TRUE if the language is C++.  */
5310
5311 static inline bool
5312 is_cxx (void)
5313 {
5314   return (get_AT_unsigned (comp_unit_die, DW_AT_language)
5315           == DW_LANG_C_plus_plus);
5316 }
5317
5318 /* Return TRUE if the language is Fortran.  */
5319
5320 static inline bool
5321 is_fortran (void)
5322 {
5323   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5324
5325   return (lang == DW_LANG_Fortran77
5326           || lang == DW_LANG_Fortran90
5327           || lang == DW_LANG_Fortran95);
5328 }
5329
5330 /* Return TRUE if the language is Java.  */
5331
5332 static inline bool
5333 is_java (void)
5334 {
5335   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5336
5337   return lang == DW_LANG_Java;
5338 }
5339
5340 /* Return TRUE if the language is Ada.  */
5341
5342 static inline bool
5343 is_ada (void)
5344 {
5345   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5346
5347   return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5348 }
5349
5350 /* Free up the memory used by A.  */
5351
5352 static inline void free_AT (dw_attr_ref);
5353 static inline void
5354 free_AT (dw_attr_ref a)
5355 {
5356   if (AT_class (a) == dw_val_class_str)
5357     if (a->dw_attr_val.v.val_str->refcount)
5358       a->dw_attr_val.v.val_str->refcount--;
5359 }
5360
5361 /* Remove the specified attribute if present.  */
5362
5363 static void
5364 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5365 {
5366   dw_attr_ref *p;
5367   dw_attr_ref removed = NULL;
5368
5369   if (die != NULL)
5370     {
5371       for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
5372         if ((*p)->dw_attr == attr_kind)
5373           {
5374             removed = *p;
5375             *p = (*p)->dw_attr_next;
5376             break;
5377           }
5378
5379       if (removed != 0)
5380         free_AT (removed);
5381     }
5382 }
5383
5384 /* Remove child die whose die_tag is specified tag.  */
5385
5386 static void
5387 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5388 {
5389   dw_die_ref current, prev, next;
5390   current = die->die_child;
5391   prev = NULL;
5392   while (current != NULL)
5393     {
5394       if (current->die_tag == tag)
5395         {
5396           next = current->die_sib;
5397           if (prev == NULL)
5398             die->die_child = next;
5399           else
5400             prev->die_sib = next;
5401           free_die (current);
5402           current = next;
5403         }
5404       else
5405         {
5406           prev = current;
5407           current = current->die_sib;
5408         }
5409     }
5410 }
5411
5412 /* Free up the memory used by DIE.  */
5413
5414 static inline void
5415 free_die (dw_die_ref die)
5416 {
5417   remove_children (die);
5418 }
5419
5420 /* Discard the children of this DIE.  */
5421
5422 static void
5423 remove_children (dw_die_ref die)
5424 {
5425   dw_die_ref child_die = die->die_child;
5426
5427   die->die_child = NULL;
5428
5429   while (child_die != NULL)
5430     {
5431       dw_die_ref tmp_die = child_die;
5432       dw_attr_ref a;
5433
5434       child_die = child_die->die_sib;
5435
5436       for (a = tmp_die->die_attr; a != NULL;)
5437         {
5438           dw_attr_ref tmp_a = a;
5439
5440           a = a->dw_attr_next;
5441           free_AT (tmp_a);
5442         }
5443
5444       free_die (tmp_die);
5445     }
5446 }
5447
5448 /* Add a child DIE below its parent.  We build the lists up in reverse
5449    addition order, and correct that in reverse_all_dies.  */
5450
5451 static inline void
5452 add_child_die (dw_die_ref die, dw_die_ref child_die)
5453 {
5454   if (die != NULL && child_die != NULL)
5455     {
5456       gcc_assert (die != child_die);
5457
5458       child_die->die_parent = die;
5459       child_die->die_sib = die->die_child;
5460       die->die_child = child_die;
5461     }
5462 }
5463
5464 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5465    is the specification, to the front of PARENT's list of children.  */
5466
5467 static void
5468 splice_child_die (dw_die_ref parent, dw_die_ref child)
5469 {
5470   dw_die_ref *p;
5471
5472   /* We want the declaration DIE from inside the class, not the
5473      specification DIE at toplevel.  */
5474   if (child->die_parent != parent)
5475     {
5476       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5477
5478       if (tmp)
5479         child = tmp;
5480     }
5481
5482   gcc_assert (child->die_parent == parent
5483               || (child->die_parent
5484                   == get_AT_ref (parent, DW_AT_specification)));
5485
5486   for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
5487     if (*p == child)
5488       {
5489         *p = child->die_sib;
5490         break;
5491       }
5492
5493   child->die_parent = parent;
5494   child->die_sib = parent->die_child;
5495   parent->die_child = child;
5496 }
5497
5498 /* Return a pointer to a newly created DIE node.  */
5499
5500 static inline dw_die_ref
5501 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5502 {
5503   dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5504
5505   die->die_tag = tag_value;
5506
5507   if (parent_die != NULL)
5508     add_child_die (parent_die, die);
5509   else
5510     {
5511       limbo_die_node *limbo_node;
5512
5513       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5514       limbo_node->die = die;
5515       limbo_node->created_for = t;
5516       limbo_node->next = limbo_die_list;
5517       limbo_die_list = limbo_node;
5518     }
5519
5520   return die;
5521 }
5522
5523 /* Return the DIE associated with the given type specifier.  */
5524
5525 static inline dw_die_ref
5526 lookup_type_die (tree type)
5527 {
5528   return TYPE_SYMTAB_DIE (type);
5529 }
5530
5531 /* Equate a DIE to a given type specifier.  */
5532
5533 static inline void
5534 equate_type_number_to_die (tree type, dw_die_ref type_die)
5535 {
5536   TYPE_SYMTAB_DIE (type) = type_die;
5537 }
5538
5539 /* Returns a hash value for X (which really is a die_struct).  */
5540
5541 static hashval_t
5542 decl_die_table_hash (const void *x)
5543 {
5544   return (hashval_t) ((const dw_die_ref) x)->decl_id;
5545 }
5546
5547 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
5548
5549 static int
5550 decl_die_table_eq (const void *x, const void *y)
5551 {
5552   return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5553 }
5554
5555 /* Return the DIE associated with a given declaration.  */
5556
5557 static inline dw_die_ref
5558 lookup_decl_die (tree decl)
5559 {
5560   return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5561 }
5562
5563 /* Returns a hash value for X (which really is a var_loc_list).  */
5564
5565 static hashval_t
5566 decl_loc_table_hash (const void *x)
5567 {
5568   return (hashval_t) ((const var_loc_list *) x)->decl_id;
5569 }
5570
5571 /* Return nonzero if decl_id of var_loc_list X is the same as
5572    UID of decl *Y.  */
5573
5574 static int
5575 decl_loc_table_eq (const void *x, const void *y)
5576 {
5577   return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5578 }
5579
5580 /* Return the var_loc list associated with a given declaration.  */
5581
5582 static inline var_loc_list *
5583 lookup_decl_loc (tree decl)
5584 {
5585   return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5586 }
5587
5588 /* Equate a DIE to a particular declaration.  */
5589
5590 static void
5591 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5592 {
5593   unsigned int decl_id = DECL_UID (decl);
5594   void **slot;
5595
5596   slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5597   *slot = decl_die;
5598   decl_die->decl_id = decl_id;
5599 }
5600
5601 /* Add a variable location node to the linked list for DECL.  */
5602
5603 static void
5604 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5605 {
5606   unsigned int decl_id = DECL_UID (decl);
5607   var_loc_list *temp;
5608   void **slot;
5609
5610   slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5611   if (*slot == NULL)
5612     {
5613       temp = ggc_alloc_cleared (sizeof (var_loc_list));
5614       temp->decl_id = decl_id;
5615       *slot = temp;
5616     }
5617   else
5618     temp = *slot;
5619
5620   if (temp->last)
5621     {
5622       /* If the current location is the same as the end of the list,
5623          we have nothing to do.  */
5624       if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5625                         NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5626         {
5627           /* Add LOC to the end of list and update LAST.  */
5628           temp->last->next = loc;
5629           temp->last = loc;
5630         }
5631     }
5632   /* Do not add empty location to the beginning of the list.  */
5633   else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5634     {
5635       temp->first = loc;
5636       temp->last = loc;
5637     }
5638 }
5639 \f
5640 /* Keep track of the number of spaces used to indent the
5641    output of the debugging routines that print the structure of
5642    the DIE internal representation.  */
5643 static int print_indent;
5644
5645 /* Indent the line the number of spaces given by print_indent.  */
5646
5647 static inline void
5648 print_spaces (FILE *outfile)
5649 {
5650   fprintf (outfile, "%*s", print_indent, "");
5651 }
5652
5653 /* Print the information associated with a given DIE, and its children.
5654    This routine is a debugging aid only.  */
5655
5656 static void
5657 print_die (dw_die_ref die, FILE *outfile)
5658 {
5659   dw_attr_ref a;
5660   dw_die_ref c;
5661
5662   print_spaces (outfile);
5663   fprintf (outfile, "DIE %4lu: %s\n",
5664            die->die_offset, dwarf_tag_name (die->die_tag));
5665   print_spaces (outfile);
5666   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5667   fprintf (outfile, " offset: %lu\n", die->die_offset);
5668
5669   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5670     {
5671       print_spaces (outfile);
5672       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5673
5674       switch (AT_class (a))
5675         {
5676         case dw_val_class_addr:
5677           fprintf (outfile, "address");
5678           break;
5679         case dw_val_class_offset:
5680           fprintf (outfile, "offset");
5681           break;
5682         case dw_val_class_loc:
5683           fprintf (outfile, "location descriptor");
5684           break;
5685         case dw_val_class_loc_list:
5686           fprintf (outfile, "location list -> label:%s",
5687                    AT_loc_list (a)->ll_symbol);
5688           break;
5689         case dw_val_class_range_list:
5690           fprintf (outfile, "range list");
5691           break;
5692         case dw_val_class_const:
5693           fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5694           break;
5695         case dw_val_class_unsigned_const:
5696           fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5697           break;
5698         case dw_val_class_long_long:
5699           fprintf (outfile, "constant (%lu,%lu)",
5700                    a->dw_attr_val.v.val_long_long.hi,
5701                    a->dw_attr_val.v.val_long_long.low);
5702           break;
5703         case dw_val_class_vec:
5704           fprintf (outfile, "floating-point or vector constant");
5705           break;
5706         case dw_val_class_flag:
5707           fprintf (outfile, "%u", AT_flag (a));
5708           break;
5709         case dw_val_class_die_ref:
5710           if (AT_ref (a) != NULL)
5711             {
5712               if (AT_ref (a)->die_symbol)
5713                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5714               else
5715                 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5716             }
5717           else
5718             fprintf (outfile, "die -> <null>");
5719           break;
5720         case dw_val_class_lbl_id:
5721         case dw_val_class_lbl_offset:
5722           fprintf (outfile, "label: %s", AT_lbl (a));
5723           break;
5724         case dw_val_class_str:
5725           if (AT_string (a) != NULL)
5726             fprintf (outfile, "\"%s\"", AT_string (a));
5727           else
5728             fprintf (outfile, "<null>");
5729           break;
5730         default:
5731           break;
5732         }
5733
5734       fprintf (outfile, "\n");
5735     }
5736
5737   if (die->die_child != NULL)
5738     {
5739       print_indent += 4;
5740       for (c = die->die_child; c != NULL; c = c->die_sib)
5741         print_die (c, outfile);
5742
5743       print_indent -= 4;
5744     }
5745   if (print_indent == 0)
5746     fprintf (outfile, "\n");
5747 }
5748
5749 /* Print the contents of the source code line number correspondence table.
5750    This routine is a debugging aid only.  */
5751
5752 static void
5753 print_dwarf_line_table (FILE *outfile)
5754 {
5755   unsigned i;
5756   dw_line_info_ref line_info;
5757
5758   fprintf (outfile, "\n\nDWARF source line information\n");
5759   for (i = 1; i < line_info_table_in_use; i++)
5760     {
5761       line_info = &line_info_table[i];
5762       fprintf (outfile, "%5d: ", i);
5763       fprintf (outfile, "%-20s",
5764                VARRAY_CHAR_PTR (file_table, line_info->dw_file_num));
5765       fprintf (outfile, "%6ld", line_info->dw_line_num);
5766       fprintf (outfile, "\n");
5767     }
5768
5769   fprintf (outfile, "\n\n");
5770 }
5771
5772 /* Print the information collected for a given DIE.  */
5773
5774 void
5775 debug_dwarf_die (dw_die_ref die)
5776 {
5777   print_die (die, stderr);
5778 }
5779
5780 /* Print all DWARF information collected for the compilation unit.
5781    This routine is a debugging aid only.  */
5782
5783 void
5784 debug_dwarf (void)
5785 {
5786   print_indent = 0;
5787   print_die (comp_unit_die, stderr);
5788   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5789     print_dwarf_line_table (stderr);
5790 }
5791 \f
5792 /* We build up the lists of children and attributes by pushing new ones
5793    onto the beginning of the list.  Reverse the lists for DIE so that
5794    they are in order of addition.  */
5795
5796 static void
5797 reverse_die_lists (dw_die_ref die)
5798 {
5799   dw_die_ref c, cp, cn;
5800   dw_attr_ref a, ap, an;
5801
5802   for (a = die->die_attr, ap = 0; a; a = an)
5803     {
5804       an = a->dw_attr_next;
5805       a->dw_attr_next = ap;
5806       ap = a;
5807     }
5808
5809   die->die_attr = ap;
5810
5811   for (c = die->die_child, cp = 0; c; c = cn)
5812     {
5813       cn = c->die_sib;
5814       c->die_sib = cp;
5815       cp = c;
5816     }
5817
5818   die->die_child = cp;
5819 }
5820
5821 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5822    reverse all dies in add_sibling_attributes, which runs through all the dies,
5823    it would reverse all the dies.  Now, however, since we don't call
5824    reverse_die_lists in add_sibling_attributes, we need a routine to
5825    recursively reverse all the dies. This is that routine.  */
5826
5827 static void
5828 reverse_all_dies (dw_die_ref die)
5829 {
5830   dw_die_ref c;
5831
5832   reverse_die_lists (die);
5833
5834   for (c = die->die_child; c; c = c->die_sib)
5835     reverse_all_dies (c);
5836 }
5837
5838 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5839    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5840    DIE that marks the start of the DIEs for this include file.  */
5841
5842 static dw_die_ref
5843 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5844 {
5845   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5846   dw_die_ref new_unit = gen_compile_unit_die (filename);
5847
5848   new_unit->die_sib = old_unit;
5849   return new_unit;
5850 }
5851
5852 /* Close an include-file CU and reopen the enclosing one.  */
5853
5854 static dw_die_ref
5855 pop_compile_unit (dw_die_ref old_unit)
5856 {
5857   dw_die_ref new_unit = old_unit->die_sib;
5858
5859   old_unit->die_sib = NULL;
5860   return new_unit;
5861 }
5862
5863 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5864 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5865
5866 /* Calculate the checksum of a location expression.  */
5867
5868 static inline void
5869 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5870 {
5871   CHECKSUM (loc->dw_loc_opc);
5872   CHECKSUM (loc->dw_loc_oprnd1);
5873   CHECKSUM (loc->dw_loc_oprnd2);
5874 }
5875
5876 /* Calculate the checksum of an attribute.  */
5877
5878 static void
5879 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5880 {
5881   dw_loc_descr_ref loc;
5882   rtx r;
5883
5884   CHECKSUM (at->dw_attr);
5885
5886   /* We don't care about differences in file numbering.  */
5887   if (at->dw_attr == DW_AT_decl_file
5888       /* Or that this was compiled with a different compiler snapshot; if
5889          the output is the same, that's what matters.  */
5890       || at->dw_attr == DW_AT_producer)
5891     return;
5892
5893   switch (AT_class (at))
5894     {
5895     case dw_val_class_const:
5896       CHECKSUM (at->dw_attr_val.v.val_int);
5897       break;
5898     case dw_val_class_unsigned_const:
5899       CHECKSUM (at->dw_attr_val.v.val_unsigned);
5900       break;
5901     case dw_val_class_long_long:
5902       CHECKSUM (at->dw_attr_val.v.val_long_long);
5903       break;
5904     case dw_val_class_vec:
5905       CHECKSUM (at->dw_attr_val.v.val_vec);
5906       break;
5907     case dw_val_class_flag:
5908       CHECKSUM (at->dw_attr_val.v.val_flag);
5909       break;
5910     case dw_val_class_str:
5911       CHECKSUM_STRING (AT_string (at));
5912       break;
5913
5914     case dw_val_class_addr:
5915       r = AT_addr (at);
5916       gcc_assert (GET_CODE (r) == SYMBOL_REF);
5917       CHECKSUM_STRING (XSTR (r, 0));
5918       break;
5919
5920     case dw_val_class_offset:
5921       CHECKSUM (at->dw_attr_val.v.val_offset);
5922       break;
5923
5924     case dw_val_class_loc:
5925       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5926         loc_checksum (loc, ctx);
5927       break;
5928
5929     case dw_val_class_die_ref:
5930       die_checksum (AT_ref (at), ctx, mark);
5931       break;
5932
5933     case dw_val_class_fde_ref:
5934     case dw_val_class_lbl_id:
5935     case dw_val_class_lbl_offset:
5936       break;
5937
5938     default:
5939       break;
5940     }
5941 }
5942
5943 /* Calculate the checksum of a DIE.  */
5944
5945 static void
5946 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5947 {
5948   dw_die_ref c;
5949   dw_attr_ref a;
5950
5951   /* To avoid infinite recursion.  */
5952   if (die->die_mark)
5953     {
5954       CHECKSUM (die->die_mark);
5955       return;
5956     }
5957   die->die_mark = ++(*mark);
5958
5959   CHECKSUM (die->die_tag);
5960
5961   for (a = die->die_attr; a; a = a->dw_attr_next)
5962     attr_checksum (a, ctx, mark);
5963
5964   for (c = die->die_child; c; c = c->die_sib)
5965     die_checksum (c, ctx, mark);
5966 }
5967
5968 #undef CHECKSUM
5969 #undef CHECKSUM_STRING
5970
5971 /* Do the location expressions look same?  */
5972 static inline int
5973 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
5974 {
5975   return loc1->dw_loc_opc == loc2->dw_loc_opc
5976          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
5977          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
5978 }
5979
5980 /* Do the values look the same?  */
5981 static int
5982 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
5983 {
5984   dw_loc_descr_ref loc1, loc2;
5985   rtx r1, r2;
5986
5987   if (v1->val_class != v2->val_class)
5988     return 0;
5989
5990   switch (v1->val_class)
5991     {
5992     case dw_val_class_const:
5993       return v1->v.val_int == v2->v.val_int;
5994     case dw_val_class_unsigned_const:
5995       return v1->v.val_unsigned == v2->v.val_unsigned;
5996     case dw_val_class_long_long:
5997       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
5998              && v1->v.val_long_long.low == v2->v.val_long_long.low;
5999     case dw_val_class_vec:
6000       if (v1->v.val_vec.length != v2->v.val_vec.length
6001           || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6002         return 0;
6003       if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6004                   v1->v.val_vec.length * v1->v.val_vec.elt_size))
6005         return 0;
6006       return 1;
6007     case dw_val_class_flag:
6008       return v1->v.val_flag == v2->v.val_flag;
6009     case dw_val_class_str:
6010       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6011
6012     case dw_val_class_addr:
6013       r1 = v1->v.val_addr;
6014       r2 = v2->v.val_addr;
6015       if (GET_CODE (r1) != GET_CODE (r2))
6016         return 0;
6017       gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6018       return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6019
6020     case dw_val_class_offset:
6021       return v1->v.val_offset == v2->v.val_offset;
6022
6023     case dw_val_class_loc:
6024       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6025            loc1 && loc2;
6026            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6027         if (!same_loc_p (loc1, loc2, mark))
6028           return 0;
6029       return !loc1 && !loc2;
6030
6031     case dw_val_class_die_ref:
6032       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6033
6034     case dw_val_class_fde_ref:
6035     case dw_val_class_lbl_id:
6036     case dw_val_class_lbl_offset:
6037       return 1;
6038
6039     default:
6040       return 1;
6041     }
6042 }
6043
6044 /* Do the attributes look the same?  */
6045
6046 static int
6047 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6048 {
6049   if (at1->dw_attr != at2->dw_attr)
6050     return 0;
6051
6052   /* We don't care about differences in file numbering.  */
6053   if (at1->dw_attr == DW_AT_decl_file
6054       /* Or that this was compiled with a different compiler snapshot; if
6055          the output is the same, that's what matters.  */
6056       || at1->dw_attr == DW_AT_producer)
6057     return 1;
6058
6059   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6060 }
6061
6062 /* Do the dies look the same?  */
6063
6064 static int
6065 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6066 {
6067   dw_die_ref c1, c2;
6068   dw_attr_ref a1, a2;
6069
6070   /* To avoid infinite recursion.  */
6071   if (die1->die_mark)
6072     return die1->die_mark == die2->die_mark;
6073   die1->die_mark = die2->die_mark = ++(*mark);
6074
6075   if (die1->die_tag != die2->die_tag)
6076     return 0;
6077
6078   for (a1 = die1->die_attr, a2 = die2->die_attr;
6079        a1 && a2;
6080        a1 = a1->dw_attr_next, a2 = a2->dw_attr_next)
6081     if (!same_attr_p (a1, a2, mark))
6082       return 0;
6083   if (a1 || a2)
6084     return 0;
6085
6086   for (c1 = die1->die_child, c2 = die2->die_child;
6087        c1 && c2;
6088        c1 = c1->die_sib, c2 = c2->die_sib)
6089     if (!same_die_p (c1, c2, mark))
6090       return 0;
6091   if (c1 || c2)
6092     return 0;
6093
6094   return 1;
6095 }
6096
6097 /* Do the dies look the same?  Wrapper around same_die_p.  */
6098
6099 static int
6100 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6101 {
6102   int mark = 0;
6103   int ret = same_die_p (die1, die2, &mark);
6104
6105   unmark_all_dies (die1);
6106   unmark_all_dies (die2);
6107
6108   return ret;
6109 }
6110
6111 /* The prefix to attach to symbols on DIEs in the current comdat debug
6112    info section.  */
6113 static char *comdat_symbol_id;
6114
6115 /* The index of the current symbol within the current comdat CU.  */
6116 static unsigned int comdat_symbol_number;
6117
6118 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6119    children, and set comdat_symbol_id accordingly.  */
6120
6121 static void
6122 compute_section_prefix (dw_die_ref unit_die)
6123 {
6124   const char *die_name = get_AT_string (unit_die, DW_AT_name);
6125   const char *base = die_name ? lbasename (die_name) : "anonymous";
6126   char *name = alloca (strlen (base) + 64);
6127   char *p;
6128   int i, mark;
6129   unsigned char checksum[16];
6130   struct md5_ctx ctx;
6131
6132   /* Compute the checksum of the DIE, then append part of it as hex digits to
6133      the name filename of the unit.  */
6134
6135   md5_init_ctx (&ctx);
6136   mark = 0;
6137   die_checksum (unit_die, &ctx, &mark);
6138   unmark_all_dies (unit_die);
6139   md5_finish_ctx (&ctx, checksum);
6140
6141   sprintf (name, "%s.", base);
6142   clean_symbol_name (name);
6143
6144   p = name + strlen (name);
6145   for (i = 0; i < 4; i++)
6146     {
6147       sprintf (p, "%.2x", checksum[i]);
6148       p += 2;
6149     }
6150
6151   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6152   comdat_symbol_number = 0;
6153 }
6154
6155 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
6156
6157 static int
6158 is_type_die (dw_die_ref die)
6159 {
6160   switch (die->die_tag)
6161     {
6162     case DW_TAG_array_type:
6163     case DW_TAG_class_type:
6164     case DW_TAG_enumeration_type:
6165     case DW_TAG_pointer_type:
6166     case DW_TAG_reference_type:
6167     case DW_TAG_string_type:
6168     case DW_TAG_structure_type:
6169     case DW_TAG_subroutine_type:
6170     case DW_TAG_union_type:
6171     case DW_TAG_ptr_to_member_type:
6172     case DW_TAG_set_type:
6173     case DW_TAG_subrange_type:
6174     case DW_TAG_base_type:
6175     case DW_TAG_const_type:
6176     case DW_TAG_file_type:
6177     case DW_TAG_packed_type:
6178     case DW_TAG_volatile_type:
6179     case DW_TAG_typedef:
6180       return 1;
6181     default:
6182       return 0;
6183     }
6184 }
6185
6186 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6187    Basically, we want to choose the bits that are likely to be shared between
6188    compilations (types) and leave out the bits that are specific to individual
6189    compilations (functions).  */
6190
6191 static int
6192 is_comdat_die (dw_die_ref c)
6193 {
6194   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6195      we do for stabs.  The advantage is a greater likelihood of sharing between
6196      objects that don't include headers in the same order (and therefore would
6197      put the base types in a different comdat).  jason 8/28/00 */
6198
6199   if (c->die_tag == DW_TAG_base_type)
6200     return 0;
6201
6202   if (c->die_tag == DW_TAG_pointer_type
6203       || c->die_tag == DW_TAG_reference_type
6204       || c->die_tag == DW_TAG_const_type
6205       || c->die_tag == DW_TAG_volatile_type)
6206     {
6207       dw_die_ref t = get_AT_ref (c, DW_AT_type);
6208
6209       return t ? is_comdat_die (t) : 0;
6210     }
6211
6212   return is_type_die (c);
6213 }
6214
6215 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6216    compilation unit.  */
6217
6218 static int
6219 is_symbol_die (dw_die_ref c)
6220 {
6221   return (is_type_die (c)
6222           || (get_AT (c, DW_AT_declaration)
6223               && !get_AT (c, DW_AT_specification)));
6224 }
6225
6226 static char *
6227 gen_internal_sym (const char *prefix)
6228 {
6229   char buf[256];
6230
6231   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6232   return xstrdup (buf);
6233 }
6234
6235 /* Assign symbols to all worthy DIEs under DIE.  */
6236
6237 static void
6238 assign_symbol_names (dw_die_ref die)
6239 {
6240   dw_die_ref c;
6241
6242   if (is_symbol_die (die))
6243     {
6244       if (comdat_symbol_id)
6245         {
6246           char *p = alloca (strlen (comdat_symbol_id) + 64);
6247
6248           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6249                    comdat_symbol_id, comdat_symbol_number++);
6250           die->die_symbol = xstrdup (p);
6251         }
6252       else
6253         die->die_symbol = gen_internal_sym ("LDIE");
6254     }
6255
6256   for (c = die->die_child; c != NULL; c = c->die_sib)
6257     assign_symbol_names (c);
6258 }
6259
6260 struct cu_hash_table_entry
6261 {
6262   dw_die_ref cu;
6263   unsigned min_comdat_num, max_comdat_num;
6264   struct cu_hash_table_entry *next;
6265 };
6266
6267 /* Routines to manipulate hash table of CUs.  */
6268 static hashval_t
6269 htab_cu_hash (const void *of)
6270 {
6271   const struct cu_hash_table_entry *entry = of;
6272
6273   return htab_hash_string (entry->cu->die_symbol);
6274 }
6275
6276 static int
6277 htab_cu_eq (const void *of1, const void *of2)
6278 {
6279   const struct cu_hash_table_entry *entry1 = of1;
6280   const struct die_struct *entry2 = of2;
6281
6282   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6283 }
6284
6285 static void
6286 htab_cu_del (void *what)
6287 {
6288   struct cu_hash_table_entry *next, *entry = what;
6289
6290   while (entry)
6291     {
6292       next = entry->next;
6293       free (entry);
6294       entry = next;
6295     }
6296 }
6297
6298 /* Check whether we have already seen this CU and set up SYM_NUM
6299    accordingly.  */
6300 static int
6301 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6302 {
6303   struct cu_hash_table_entry dummy;
6304   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6305
6306   dummy.max_comdat_num = 0;
6307
6308   slot = (struct cu_hash_table_entry **)
6309     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6310         INSERT);
6311   entry = *slot;
6312
6313   for (; entry; last = entry, entry = entry->next)
6314     {
6315       if (same_die_p_wrap (cu, entry->cu))
6316         break;
6317     }
6318
6319   if (entry)
6320     {
6321       *sym_num = entry->min_comdat_num;
6322       return 1;
6323     }
6324
6325   entry = XCNEW (struct cu_hash_table_entry);
6326   entry->cu = cu;
6327   entry->min_comdat_num = *sym_num = last->max_comdat_num;
6328   entry->next = *slot;
6329   *slot = entry;
6330
6331   return 0;
6332 }
6333
6334 /* Record SYM_NUM to record of CU in HTABLE.  */
6335 static void
6336 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6337 {
6338   struct cu_hash_table_entry **slot, *entry;
6339
6340   slot = (struct cu_hash_table_entry **)
6341     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6342         NO_INSERT);
6343   entry = *slot;
6344
6345   entry->max_comdat_num = sym_num;
6346 }
6347
6348 /* Traverse the DIE (which is always comp_unit_die), and set up
6349    additional compilation units for each of the include files we see
6350    bracketed by BINCL/EINCL.  */
6351
6352 static void
6353 break_out_includes (dw_die_ref die)
6354 {
6355   dw_die_ref *ptr;
6356   dw_die_ref unit = NULL;
6357   limbo_die_node *node, **pnode;
6358   htab_t cu_hash_table;
6359
6360   for (ptr = &(die->die_child); *ptr;)
6361     {
6362       dw_die_ref c = *ptr;
6363
6364       if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6365           || (unit && is_comdat_die (c)))
6366         {
6367           /* This DIE is for a secondary CU; remove it from the main one.  */
6368           *ptr = c->die_sib;
6369
6370           if (c->die_tag == DW_TAG_GNU_BINCL)
6371             {
6372               unit = push_new_compile_unit (unit, c);
6373               free_die (c);
6374             }
6375           else if (c->die_tag == DW_TAG_GNU_EINCL)
6376             {
6377               unit = pop_compile_unit (unit);
6378               free_die (c);
6379             }
6380           else
6381             add_child_die (unit, c);
6382         }
6383       else
6384         {
6385           /* Leave this DIE in the main CU.  */
6386           ptr = &(c->die_sib);
6387           continue;
6388         }
6389     }
6390
6391 #if 0
6392   /* We can only use this in debugging, since the frontend doesn't check
6393      to make sure that we leave every include file we enter.  */
6394   gcc_assert (!unit);
6395 #endif
6396
6397   assign_symbol_names (die);
6398   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6399   for (node = limbo_die_list, pnode = &limbo_die_list;
6400        node;
6401        node = node->next)
6402     {
6403       int is_dupl;
6404
6405       compute_section_prefix (node->die);
6406       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6407                         &comdat_symbol_number);
6408       assign_symbol_names (node->die);
6409       if (is_dupl)
6410         *pnode = node->next;
6411       else
6412         {
6413           pnode = &node->next;
6414           record_comdat_symbol_number (node->die, cu_hash_table,
6415                 comdat_symbol_number);
6416         }
6417     }
6418   htab_delete (cu_hash_table);
6419 }
6420
6421 /* Traverse the DIE and add a sibling attribute if it may have the
6422    effect of speeding up access to siblings.  To save some space,
6423    avoid generating sibling attributes for DIE's without children.  */
6424
6425 static void
6426 add_sibling_attributes (dw_die_ref die)
6427 {
6428   dw_die_ref c;
6429
6430   if (die->die_tag != DW_TAG_compile_unit
6431       && die->die_sib && die->die_child != NULL)
6432     /* Add the sibling link to the front of the attribute list.  */
6433     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6434
6435   for (c = die->die_child; c != NULL; c = c->die_sib)
6436     add_sibling_attributes (c);
6437 }
6438
6439 /* Output all location lists for the DIE and its children.  */
6440
6441 static void
6442 output_location_lists (dw_die_ref die)
6443 {
6444   dw_die_ref c;
6445   dw_attr_ref d_attr;
6446
6447   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6448     if (AT_class (d_attr) == dw_val_class_loc_list)
6449       output_loc_list (AT_loc_list (d_attr));
6450
6451   for (c = die->die_child; c != NULL; c = c->die_sib)
6452     output_location_lists (c);
6453
6454 }
6455
6456 /* The format of each DIE (and its attribute value pairs) is encoded in an
6457    abbreviation table.  This routine builds the abbreviation table and assigns
6458    a unique abbreviation id for each abbreviation entry.  The children of each
6459    die are visited recursively.  */
6460
6461 static void
6462 build_abbrev_table (dw_die_ref die)
6463 {
6464   unsigned long abbrev_id;
6465   unsigned int n_alloc;
6466   dw_die_ref c;
6467   dw_attr_ref d_attr, a_attr;
6468
6469   /* Scan the DIE references, and mark as external any that refer to
6470      DIEs from other CUs (i.e. those which are not marked).  */
6471   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6472     if (AT_class (d_attr) == dw_val_class_die_ref
6473         && AT_ref (d_attr)->die_mark == 0)
6474       {
6475         gcc_assert (AT_ref (d_attr)->die_symbol);
6476
6477         set_AT_ref_external (d_attr, 1);
6478       }
6479
6480   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6481     {
6482       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6483
6484       if (abbrev->die_tag == die->die_tag)
6485         {
6486           if ((abbrev->die_child != NULL) == (die->die_child != NULL))
6487             {
6488               a_attr = abbrev->die_attr;
6489               d_attr = die->die_attr;
6490
6491               while (a_attr != NULL && d_attr != NULL)
6492                 {
6493                   if ((a_attr->dw_attr != d_attr->dw_attr)
6494                       || (value_format (a_attr) != value_format (d_attr)))
6495                     break;
6496
6497                   a_attr = a_attr->dw_attr_next;
6498                   d_attr = d_attr->dw_attr_next;
6499                 }
6500
6501               if (a_attr == NULL && d_attr == NULL)
6502                 break;
6503             }
6504         }
6505     }
6506
6507   if (abbrev_id >= abbrev_die_table_in_use)
6508     {
6509       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6510         {
6511           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6512           abbrev_die_table = ggc_realloc (abbrev_die_table,
6513                                           sizeof (dw_die_ref) * n_alloc);
6514
6515           memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6516                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6517           abbrev_die_table_allocated = n_alloc;
6518         }
6519
6520       ++abbrev_die_table_in_use;
6521       abbrev_die_table[abbrev_id] = die;
6522     }
6523
6524   die->die_abbrev = abbrev_id;
6525   for (c = die->die_child; c != NULL; c = c->die_sib)
6526     build_abbrev_table (c);
6527 }
6528 \f
6529 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6530
6531 static int
6532 constant_size (long unsigned int value)
6533 {
6534   int log;
6535
6536   if (value == 0)
6537     log = 0;
6538   else
6539     log = floor_log2 (value);
6540
6541   log = log / 8;
6542   log = 1 << (floor_log2 (log) + 1);
6543
6544   return log;
6545 }
6546
6547 /* Return the size of a DIE as it is represented in the
6548    .debug_info section.  */
6549
6550 static unsigned long
6551 size_of_die (dw_die_ref die)
6552 {
6553   unsigned long size = 0;
6554   dw_attr_ref a;
6555
6556   size += size_of_uleb128 (die->die_abbrev);
6557   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6558     {
6559       switch (AT_class (a))
6560         {
6561         case dw_val_class_addr:
6562           size += DWARF2_ADDR_SIZE;
6563           break;
6564         case dw_val_class_offset:
6565           size += DWARF_OFFSET_SIZE;
6566           break;
6567         case dw_val_class_loc:
6568           {
6569             unsigned long lsize = size_of_locs (AT_loc (a));
6570
6571             /* Block length.  */
6572             size += constant_size (lsize);
6573             size += lsize;
6574           }
6575           break;
6576         case dw_val_class_loc_list:
6577           size += DWARF_OFFSET_SIZE;
6578           break;
6579         case dw_val_class_range_list:
6580           size += DWARF_OFFSET_SIZE;
6581           break;
6582         case dw_val_class_const:
6583           size += size_of_sleb128 (AT_int (a));
6584           break;
6585         case dw_val_class_unsigned_const:
6586           size += constant_size (AT_unsigned (a));
6587           break;
6588         case dw_val_class_long_long:
6589           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6590           break;
6591         case dw_val_class_vec:
6592           size += 1 + (a->dw_attr_val.v.val_vec.length
6593                        * a->dw_attr_val.v.val_vec.elt_size); /* block */
6594           break;
6595         case dw_val_class_flag:
6596           size += 1;
6597           break;
6598         case dw_val_class_die_ref:
6599           if (AT_ref_external (a))
6600             size += DWARF2_ADDR_SIZE;
6601           else
6602             size += DWARF_OFFSET_SIZE;
6603           break;
6604         case dw_val_class_fde_ref:
6605           size += DWARF_OFFSET_SIZE;
6606           break;
6607         case dw_val_class_lbl_id:
6608           size += DWARF2_ADDR_SIZE;
6609           break;
6610         case dw_val_class_lbl_offset:
6611           size += DWARF_OFFSET_SIZE;
6612           break;
6613         case dw_val_class_str:
6614           if (AT_string_form (a) == DW_FORM_strp)
6615             size += DWARF_OFFSET_SIZE;
6616           else
6617             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6618           break;
6619         default:
6620           gcc_unreachable ();
6621         }
6622     }
6623
6624   return size;
6625 }
6626
6627 /* Size the debugging information associated with a given DIE.  Visits the
6628    DIE's children recursively.  Updates the global variable next_die_offset, on
6629    each time through.  Uses the current value of next_die_offset to update the
6630    die_offset field in each DIE.  */
6631
6632 static void
6633 calc_die_sizes (dw_die_ref die)
6634 {
6635   dw_die_ref c;
6636
6637   die->die_offset = next_die_offset;
6638   next_die_offset += size_of_die (die);
6639
6640   for (c = die->die_child; c != NULL; c = c->die_sib)
6641     calc_die_sizes (c);
6642
6643   if (die->die_child != NULL)
6644     /* Count the null byte used to terminate sibling lists.  */
6645     next_die_offset += 1;
6646 }
6647
6648 /* Set the marks for a die and its children.  We do this so
6649    that we know whether or not a reference needs to use FORM_ref_addr; only
6650    DIEs in the same CU will be marked.  We used to clear out the offset
6651    and use that as the flag, but ran into ordering problems.  */
6652
6653 static void
6654 mark_dies (dw_die_ref die)
6655 {
6656   dw_die_ref c;
6657
6658   gcc_assert (!die->die_mark);
6659
6660   die->die_mark = 1;
6661   for (c = die->die_child; c; c = c->die_sib)
6662     mark_dies (c);
6663 }
6664
6665 /* Clear the marks for a die and its children.  */
6666
6667 static void
6668 unmark_dies (dw_die_ref die)
6669 {
6670   dw_die_ref c;
6671
6672   gcc_assert (die->die_mark);
6673
6674   die->die_mark = 0;
6675   for (c = die->die_child; c; c = c->die_sib)
6676     unmark_dies (c);
6677 }
6678
6679 /* Clear the marks for a die, its children and referred dies.  */
6680
6681 static void
6682 unmark_all_dies (dw_die_ref die)
6683 {
6684   dw_die_ref c;
6685   dw_attr_ref a;
6686
6687   if (!die->die_mark)
6688     return;
6689   die->die_mark = 0;
6690
6691   for (c = die->die_child; c; c = c->die_sib)
6692     unmark_all_dies (c);
6693
6694   for (a = die->die_attr; a; a = a->dw_attr_next)
6695     if (AT_class (a) == dw_val_class_die_ref)
6696       unmark_all_dies (AT_ref (a));
6697 }
6698
6699 /* Return the size of the .debug_pubnames table  generated for the
6700    compilation unit.  */
6701
6702 static unsigned long
6703 size_of_pubnames (void)
6704 {
6705   unsigned long size;
6706   unsigned i;
6707
6708   size = DWARF_PUBNAMES_HEADER_SIZE;
6709   for (i = 0; i < pubname_table_in_use; i++)
6710     {
6711       pubname_ref p = &pubname_table[i];
6712       size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6713     }
6714
6715   size += DWARF_OFFSET_SIZE;
6716   return size;
6717 }
6718
6719 /* Return the size of the information in the .debug_aranges section.  */
6720
6721 static unsigned long
6722 size_of_aranges (void)
6723 {
6724   unsigned long size;
6725
6726   size = DWARF_ARANGES_HEADER_SIZE;
6727
6728   /* Count the address/length pair for this compilation unit.  */
6729   size += 2 * DWARF2_ADDR_SIZE;
6730   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6731
6732   /* Count the two zero words used to terminated the address range table.  */
6733   size += 2 * DWARF2_ADDR_SIZE;
6734   return size;
6735 }
6736 \f
6737 /* Select the encoding of an attribute value.  */
6738
6739 static enum dwarf_form
6740 value_format (dw_attr_ref a)
6741 {
6742   switch (a->dw_attr_val.val_class)
6743     {
6744     case dw_val_class_addr:
6745       return DW_FORM_addr;
6746     case dw_val_class_range_list:
6747     case dw_val_class_offset:
6748       switch (DWARF_OFFSET_SIZE)
6749         {
6750         case 4:
6751           return DW_FORM_data4;
6752         case 8:
6753           return DW_FORM_data8;
6754         default:
6755           gcc_unreachable ();
6756         }
6757     case dw_val_class_loc_list:
6758       /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6759          .debug_loc section */
6760       return DW_FORM_data4;
6761     case dw_val_class_loc:
6762       switch (constant_size (size_of_locs (AT_loc (a))))
6763         {
6764         case 1:
6765           return DW_FORM_block1;
6766         case 2:
6767           return DW_FORM_block2;
6768         default:
6769           gcc_unreachable ();
6770         }
6771     case dw_val_class_const:
6772       return DW_FORM_sdata;
6773     case dw_val_class_unsigned_const:
6774       switch (constant_size (AT_unsigned (a)))
6775         {
6776         case 1:
6777           return DW_FORM_data1;
6778         case 2:
6779           return DW_FORM_data2;
6780         case 4:
6781           return DW_FORM_data4;
6782         case 8:
6783           return DW_FORM_data8;
6784         default:
6785           gcc_unreachable ();
6786         }
6787     case dw_val_class_long_long:
6788       return DW_FORM_block1;
6789     case dw_val_class_vec:
6790       return DW_FORM_block1;
6791     case dw_val_class_flag:
6792       return DW_FORM_flag;
6793     case dw_val_class_die_ref:
6794       if (AT_ref_external (a))
6795         return DW_FORM_ref_addr;
6796       else
6797         return DW_FORM_ref;
6798     case dw_val_class_fde_ref:
6799       return DW_FORM_data;
6800     case dw_val_class_lbl_id:
6801       return DW_FORM_addr;
6802     case dw_val_class_lbl_offset:
6803       return DW_FORM_data;
6804     case dw_val_class_str:
6805       return AT_string_form (a);
6806
6807     default:
6808       gcc_unreachable ();
6809     }
6810 }
6811
6812 /* Output the encoding of an attribute value.  */
6813
6814 static void
6815 output_value_format (dw_attr_ref a)
6816 {
6817   enum dwarf_form form = value_format (a);
6818
6819   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6820 }
6821
6822 /* Output the .debug_abbrev section which defines the DIE abbreviation
6823    table.  */
6824
6825 static void
6826 output_abbrev_section (void)
6827 {
6828   unsigned long abbrev_id;
6829
6830   dw_attr_ref a_attr;
6831
6832   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6833     {
6834       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6835
6836       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6837       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6838                                    dwarf_tag_name (abbrev->die_tag));
6839
6840       if (abbrev->die_child != NULL)
6841         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6842       else
6843         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6844
6845       for (a_attr = abbrev->die_attr; a_attr != NULL;
6846            a_attr = a_attr->dw_attr_next)
6847         {
6848           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6849                                        dwarf_attr_name (a_attr->dw_attr));
6850           output_value_format (a_attr);
6851         }
6852
6853       dw2_asm_output_data (1, 0, NULL);
6854       dw2_asm_output_data (1, 0, NULL);
6855     }
6856
6857   /* Terminate the table.  */
6858   dw2_asm_output_data (1, 0, NULL);
6859 }
6860
6861 /* Output a symbol we can use to refer to this DIE from another CU.  */
6862
6863 static inline void
6864 output_die_symbol (dw_die_ref die)
6865 {
6866   char *sym = die->die_symbol;
6867
6868   if (sym == 0)
6869     return;
6870
6871   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6872     /* We make these global, not weak; if the target doesn't support
6873        .linkonce, it doesn't support combining the sections, so debugging
6874        will break.  */
6875     targetm.asm_out.globalize_label (asm_out_file, sym);
6876
6877   ASM_OUTPUT_LABEL (asm_out_file, sym);
6878 }
6879
6880 /* Return a new location list, given the begin and end range, and the
6881    expression. gensym tells us whether to generate a new internal symbol for
6882    this location list node, which is done for the head of the list only.  */
6883
6884 static inline dw_loc_list_ref
6885 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6886               const char *section, unsigned int gensym)
6887 {
6888   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6889
6890   retlist->begin = begin;
6891   retlist->end = end;
6892   retlist->expr = expr;
6893   retlist->section = section;
6894   if (gensym)
6895     retlist->ll_symbol = gen_internal_sym ("LLST");
6896
6897   return retlist;
6898 }
6899
6900 /* Add a location description expression to a location list.  */
6901
6902 static inline void
6903 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6904                            const char *begin, const char *end,
6905                            const char *section)
6906 {
6907   dw_loc_list_ref *d;
6908
6909   /* Find the end of the chain.  */
6910   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6911     ;
6912
6913   /* Add a new location list node to the list.  */
6914   *d = new_loc_list (descr, begin, end, section, 0);
6915 }
6916
6917 static void
6918 dwarf2out_switch_text_section (void)
6919 {
6920   dw_fde_ref fde;
6921
6922   gcc_assert (cfun);
6923
6924   fde = &fde_table[fde_table_in_use - 1];
6925   fde->dw_fde_switched_sections = true;
6926   fde->dw_fde_hot_section_label = cfun->hot_section_label;
6927   fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
6928   fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
6929   fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
6930   have_multiple_function_sections = true;
6931 }
6932
6933 /* Output the location list given to us.  */
6934
6935 static void
6936 output_loc_list (dw_loc_list_ref list_head)
6937 {
6938   dw_loc_list_ref curr = list_head;
6939
6940   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
6941
6942   /* Walk the location list, and output each range + expression.  */
6943   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
6944     {
6945       unsigned long size;
6946       if (!have_multiple_function_sections)
6947         {
6948           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
6949                                 "Location list begin address (%s)",
6950                                 list_head->ll_symbol);
6951           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
6952                                 "Location list end address (%s)",
6953                                 list_head->ll_symbol);
6954         }
6955       else
6956         {
6957           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
6958                                "Location list begin address (%s)",
6959                                list_head->ll_symbol);
6960           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
6961                                "Location list end address (%s)",
6962                                list_head->ll_symbol);
6963         }
6964       size = size_of_locs (curr->expr);
6965
6966       /* Output the block length for this list of location operations.  */
6967       gcc_assert (size <= 0xffff);
6968       dw2_asm_output_data (2, size, "%s", "Location expression size");
6969
6970       output_loc_sequence (curr->expr);
6971     }
6972
6973   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
6974                        "Location list terminator begin (%s)",
6975                        list_head->ll_symbol);
6976   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
6977                        "Location list terminator end (%s)",
6978                        list_head->ll_symbol);
6979 }
6980
6981 /* Output the DIE and its attributes.  Called recursively to generate
6982    the definitions of each child DIE.  */
6983
6984 static void
6985 output_die (dw_die_ref die)
6986 {
6987   dw_attr_ref a;
6988   dw_die_ref c;
6989   unsigned long size;
6990
6991   /* If someone in another CU might refer to us, set up a symbol for
6992      them to point to.  */
6993   if (die->die_symbol)
6994     output_die_symbol (die);
6995
6996   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
6997                                die->die_offset, dwarf_tag_name (die->die_tag));
6998
6999   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
7000     {
7001       const char *name = dwarf_attr_name (a->dw_attr);
7002
7003       switch (AT_class (a))
7004         {
7005         case dw_val_class_addr:
7006           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7007           break;
7008
7009         case dw_val_class_offset:
7010           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7011                                "%s", name);
7012           break;
7013
7014         case dw_val_class_range_list:
7015           {
7016             char *p = strchr (ranges_section_label, '\0');
7017
7018             sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7019                      a->dw_attr_val.v.val_offset);
7020             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7021                                    "%s", name);
7022             *p = '\0';
7023           }
7024           break;
7025
7026         case dw_val_class_loc:
7027           size = size_of_locs (AT_loc (a));
7028
7029           /* Output the block length for this list of location operations.  */
7030           dw2_asm_output_data (constant_size (size), size, "%s", name);
7031
7032           output_loc_sequence (AT_loc (a));
7033           break;
7034
7035         case dw_val_class_const:
7036           /* ??? It would be slightly more efficient to use a scheme like is
7037              used for unsigned constants below, but gdb 4.x does not sign
7038              extend.  Gdb 5.x does sign extend.  */
7039           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7040           break;
7041
7042         case dw_val_class_unsigned_const:
7043           dw2_asm_output_data (constant_size (AT_unsigned (a)),
7044                                AT_unsigned (a), "%s", name);
7045           break;
7046
7047         case dw_val_class_long_long:
7048           {
7049             unsigned HOST_WIDE_INT first, second;
7050
7051             dw2_asm_output_data (1,
7052                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7053                                  "%s", name);
7054
7055             if (WORDS_BIG_ENDIAN)
7056               {
7057                 first = a->dw_attr_val.v.val_long_long.hi;
7058                 second = a->dw_attr_val.v.val_long_long.low;
7059               }
7060             else
7061               {
7062                 first = a->dw_attr_val.v.val_long_long.low;
7063                 second = a->dw_attr_val.v.val_long_long.hi;
7064               }
7065
7066             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7067                                  first, "long long constant");
7068             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7069                                  second, NULL);
7070           }
7071           break;
7072
7073         case dw_val_class_vec:
7074           {
7075             unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7076             unsigned int len = a->dw_attr_val.v.val_vec.length;
7077             unsigned int i;
7078             unsigned char *p;
7079
7080             dw2_asm_output_data (1, len * elt_size, "%s", name);
7081             if (elt_size > sizeof (HOST_WIDE_INT))
7082               {
7083                 elt_size /= 2;
7084                 len *= 2;
7085               }
7086             for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7087                  i < len;
7088                  i++, p += elt_size)
7089               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7090                                    "fp or vector constant word %u", i);
7091             break;
7092           }
7093
7094         case dw_val_class_flag:
7095           dw2_asm_output_data (1, AT_flag (a), "%s", name);
7096           break;
7097
7098         case dw_val_class_loc_list:
7099           {
7100             char *sym = AT_loc_list (a)->ll_symbol;
7101
7102             gcc_assert (sym);
7103             dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, "%s", name);
7104           }
7105           break;
7106
7107         case dw_val_class_die_ref:
7108           if (AT_ref_external (a))
7109             {
7110               char *sym = AT_ref (a)->die_symbol;
7111
7112               gcc_assert (sym);
7113               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
7114             }
7115           else
7116             {
7117               gcc_assert (AT_ref (a)->die_offset);
7118               dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7119                                    "%s", name);
7120             }
7121           break;
7122
7123         case dw_val_class_fde_ref:
7124           {
7125             char l1[20];
7126
7127             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7128                                          a->dw_attr_val.v.val_fde_index * 2);
7129             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name);
7130           }
7131           break;
7132
7133         case dw_val_class_lbl_id:
7134           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7135           break;
7136
7137         case dw_val_class_lbl_offset:
7138           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name);
7139           break;
7140
7141         case dw_val_class_str:
7142           if (AT_string_form (a) == DW_FORM_strp)
7143             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7144                                    a->dw_attr_val.v.val_str->label,
7145                                    "%s: \"%s\"", name, AT_string (a));
7146           else
7147             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7148           break;
7149
7150         default:
7151           gcc_unreachable ();
7152         }
7153     }
7154
7155   for (c = die->die_child; c != NULL; c = c->die_sib)
7156     output_die (c);
7157
7158   /* Add null byte to terminate sibling list.  */
7159   if (die->die_child != NULL)
7160     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7161                          die->die_offset);
7162 }
7163
7164 /* Output the compilation unit that appears at the beginning of the
7165    .debug_info section, and precedes the DIE descriptions.  */
7166
7167 static void
7168 output_compilation_unit_header (void)
7169 {
7170   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7171     dw2_asm_output_data (4, 0xffffffff,
7172       "Initial length escape value indicating 64-bit DWARF extension");
7173   dw2_asm_output_data (DWARF_OFFSET_SIZE,
7174                        next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7175                        "Length of Compilation Unit Info");
7176   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7177   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7178                          "Offset Into Abbrev. Section");
7179   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7180 }
7181
7182 /* Output the compilation unit DIE and its children.  */
7183
7184 static void
7185 output_comp_unit (dw_die_ref die, int output_if_empty)
7186 {
7187   const char *secname;
7188   char *oldsym, *tmp;
7189
7190   /* Unless we are outputting main CU, we may throw away empty ones.  */
7191   if (!output_if_empty && die->die_child == NULL)
7192     return;
7193
7194   /* Even if there are no children of this DIE, we must output the information
7195      about the compilation unit.  Otherwise, on an empty translation unit, we
7196      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
7197      will then complain when examining the file.  First mark all the DIEs in
7198      this CU so we know which get local refs.  */
7199   mark_dies (die);
7200
7201   build_abbrev_table (die);
7202
7203   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
7204   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7205   calc_die_sizes (die);
7206
7207   oldsym = die->die_symbol;
7208   if (oldsym)
7209     {
7210       tmp = alloca (strlen (oldsym) + 24);
7211
7212       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7213       secname = tmp;
7214       die->die_symbol = NULL;
7215       switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7216     }
7217   else
7218     switch_to_section (debug_info_section);
7219
7220   /* Output debugging information.  */
7221   output_compilation_unit_header ();
7222   output_die (die);
7223
7224   /* Leave the marks on the main CU, so we can check them in
7225      output_pubnames.  */
7226   if (oldsym)
7227     {
7228       unmark_dies (die);
7229       die->die_symbol = oldsym;
7230     }
7231 }
7232
7233 /* The DWARF2 pubname for a nested thingy looks like "A::f".  The
7234    output of lang_hooks.decl_printable_name for C++ looks like
7235    "A::f(int)".  Let's drop the argument list, and maybe the scope.  */
7236
7237 static const char *
7238 dwarf2_name (tree decl, int scope)
7239 {
7240   return lang_hooks.decl_printable_name (decl, scope ? 1 : 0);
7241 }
7242
7243 /* Add a new entry to .debug_pubnames if appropriate.  */
7244
7245 static void
7246 add_pubname (tree decl, dw_die_ref die)
7247 {
7248   pubname_ref p;
7249
7250   if (! TREE_PUBLIC (decl))
7251     return;
7252
7253   if (pubname_table_in_use == pubname_table_allocated)
7254     {
7255       pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
7256       pubname_table
7257         = ggc_realloc (pubname_table,
7258                        (pubname_table_allocated * sizeof (pubname_entry)));
7259       memset (pubname_table + pubname_table_in_use, 0,
7260               PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7261     }
7262
7263   p = &pubname_table[pubname_table_in_use++];
7264   p->die = die;
7265   p->name = xstrdup (dwarf2_name (decl, 1));
7266 }
7267
7268 /* Output the public names table used to speed up access to externally
7269    visible names.  For now, only generate entries for externally
7270    visible procedures.  */
7271
7272 static void
7273 output_pubnames (void)
7274 {
7275   unsigned i;
7276   unsigned long pubnames_length = size_of_pubnames ();
7277
7278   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7279     dw2_asm_output_data (4, 0xffffffff,
7280       "Initial length escape value indicating 64-bit DWARF extension");
7281   dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7282                        "Length of Public Names Info");
7283   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7284   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7285                          "Offset of Compilation Unit Info");
7286   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7287                        "Compilation Unit Length");
7288
7289   for (i = 0; i < pubname_table_in_use; i++)
7290     {
7291       pubname_ref pub = &pubname_table[i];
7292
7293       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
7294       gcc_assert (pub->die->die_mark);
7295
7296       dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7297                            "DIE offset");
7298
7299       dw2_asm_output_nstring (pub->name, -1, "external name");
7300     }
7301
7302   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7303 }
7304
7305 /* Add a new entry to .debug_aranges if appropriate.  */
7306
7307 static void
7308 add_arange (tree decl, dw_die_ref die)
7309 {
7310   if (! DECL_SECTION_NAME (decl))
7311     return;
7312
7313   if (arange_table_in_use == arange_table_allocated)
7314     {
7315       arange_table_allocated += ARANGE_TABLE_INCREMENT;
7316       arange_table = ggc_realloc (arange_table,
7317                                   (arange_table_allocated
7318                                    * sizeof (dw_die_ref)));
7319       memset (arange_table + arange_table_in_use, 0,
7320               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7321     }
7322
7323   arange_table[arange_table_in_use++] = die;
7324 }
7325
7326 /* Output the information that goes into the .debug_aranges table.
7327    Namely, define the beginning and ending address range of the
7328    text section generated for this compilation unit.  */
7329
7330 static void
7331 output_aranges (void)
7332 {
7333   unsigned i;
7334   unsigned long aranges_length = size_of_aranges ();
7335
7336   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7337     dw2_asm_output_data (4, 0xffffffff,
7338       "Initial length escape value indicating 64-bit DWARF extension");
7339   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7340                        "Length of Address Ranges Info");
7341   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7342   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7343                          "Offset of Compilation Unit Info");
7344   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7345   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7346
7347   /* We need to align to twice the pointer size here.  */
7348   if (DWARF_ARANGES_PAD_SIZE)
7349     {
7350       /* Pad using a 2 byte words so that padding is correct for any
7351          pointer size.  */
7352       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7353                            2 * DWARF2_ADDR_SIZE);
7354       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7355         dw2_asm_output_data (2, 0, NULL);
7356     }
7357
7358   dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7359   dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7360                         text_section_label, "Length");
7361   if (flag_reorder_blocks_and_partition)
7362     {
7363       dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7364                            "Address");
7365       dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7366                             cold_text_section_label, "Length");
7367     }
7368
7369   for (i = 0; i < arange_table_in_use; i++)
7370     {
7371       dw_die_ref die = arange_table[i];
7372
7373       /* We shouldn't see aranges for DIEs outside of the main CU.  */
7374       gcc_assert (die->die_mark);
7375
7376       if (die->die_tag == DW_TAG_subprogram)
7377         {
7378           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7379                                "Address");
7380           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7381                                 get_AT_low_pc (die), "Length");
7382         }
7383       else
7384         {
7385           /* A static variable; extract the symbol from DW_AT_location.
7386              Note that this code isn't currently hit, as we only emit
7387              aranges for functions (jason 9/23/99).  */
7388           dw_attr_ref a = get_AT (die, DW_AT_location);
7389           dw_loc_descr_ref loc;
7390
7391           gcc_assert (a && AT_class (a) == dw_val_class_loc);
7392
7393           loc = AT_loc (a);
7394           gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7395
7396           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7397                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
7398           dw2_asm_output_data (DWARF2_ADDR_SIZE,
7399                                get_AT_unsigned (die, DW_AT_byte_size),
7400                                "Length");
7401         }
7402     }
7403
7404   /* Output the terminator words.  */
7405   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7406   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7407 }
7408
7409 /* Add a new entry to .debug_ranges.  Return the offset at which it
7410    was placed.  */
7411
7412 static unsigned int
7413 add_ranges (tree block)
7414 {
7415   unsigned int in_use = ranges_table_in_use;
7416
7417   if (in_use == ranges_table_allocated)
7418     {
7419       ranges_table_allocated += RANGES_TABLE_INCREMENT;
7420       ranges_table
7421         = ggc_realloc (ranges_table, (ranges_table_allocated
7422                                       * sizeof (struct dw_ranges_struct)));
7423       memset (ranges_table + ranges_table_in_use, 0,
7424               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7425     }
7426
7427   ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7428   ranges_table_in_use = in_use + 1;
7429
7430   return in_use * 2 * DWARF2_ADDR_SIZE;
7431 }
7432
7433 static void
7434 output_ranges (void)
7435 {
7436   unsigned i;
7437   static const char *const start_fmt = "Offset 0x%x";
7438   const char *fmt = start_fmt;
7439
7440   for (i = 0; i < ranges_table_in_use; i++)
7441     {
7442       int block_num = ranges_table[i].block_num;
7443
7444       if (block_num)
7445         {
7446           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7447           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7448
7449           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7450           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7451
7452           /* If all code is in the text section, then the compilation
7453              unit base address defaults to DW_AT_low_pc, which is the
7454              base of the text section.  */
7455           if (!have_multiple_function_sections)
7456             {
7457               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7458                                     text_section_label,
7459                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7460               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7461                                     text_section_label, NULL);
7462             }
7463
7464           /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7465              compilation unit base address to zero, which allows us to
7466              use absolute addresses, and not worry about whether the
7467              target supports cross-section arithmetic.  */
7468           else
7469             {
7470               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7471                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7472               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7473             }
7474
7475           fmt = NULL;
7476         }
7477       else
7478         {
7479           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7480           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7481           fmt = start_fmt;
7482         }
7483     }
7484 }
7485
7486 /* Data structure containing information about input files.  */
7487 struct file_info
7488 {
7489   char *path;           /* Complete file name.  */
7490   char *fname;          /* File name part.  */
7491   int length;           /* Length of entire string.  */
7492   int file_idx;         /* Index in input file table.  */
7493   int dir_idx;          /* Index in directory table.  */
7494 };
7495
7496 /* Data structure containing information about directories with source
7497    files.  */
7498 struct dir_info
7499 {
7500   char *path;           /* Path including directory name.  */
7501   int length;           /* Path length.  */
7502   int prefix;           /* Index of directory entry which is a prefix.  */
7503   int count;            /* Number of files in this directory.  */
7504   int dir_idx;          /* Index of directory used as base.  */
7505   int used;             /* Used in the end?  */
7506 };
7507
7508 /* Callback function for file_info comparison.  We sort by looking at
7509    the directories in the path.  */
7510
7511 static int
7512 file_info_cmp (const void *p1, const void *p2)
7513 {
7514   const struct file_info *s1 = p1;
7515   const struct file_info *s2 = p2;
7516   unsigned char *cp1;
7517   unsigned char *cp2;
7518
7519   /* Take care of file names without directories.  We need to make sure that
7520      we return consistent values to qsort since some will get confused if
7521      we return the same value when identical operands are passed in opposite
7522      orders.  So if neither has a directory, return 0 and otherwise return
7523      1 or -1 depending on which one has the directory.  */
7524   if ((s1->path == s1->fname || s2->path == s2->fname))
7525     return (s2->path == s2->fname) - (s1->path == s1->fname);
7526
7527   cp1 = (unsigned char *) s1->path;
7528   cp2 = (unsigned char *) s2->path;
7529
7530   while (1)
7531     {
7532       ++cp1;
7533       ++cp2;
7534       /* Reached the end of the first path?  If so, handle like above.  */
7535       if ((cp1 == (unsigned char *) s1->fname)
7536           || (cp2 == (unsigned char *) s2->fname))
7537         return ((cp2 == (unsigned char *) s2->fname)
7538                 - (cp1 == (unsigned char *) s1->fname));
7539
7540       /* Character of current path component the same?  */
7541       else if (*cp1 != *cp2)
7542         return *cp1 - *cp2;
7543     }
7544 }
7545
7546 /* Output the directory table and the file name table.  We try to minimize
7547    the total amount of memory needed.  A heuristic is used to avoid large
7548    slowdowns with many input files.  */
7549
7550 static void
7551 output_file_names (void)
7552 {
7553   struct file_info *files;
7554   struct dir_info *dirs;
7555   int *saved;
7556   int *savehere;
7557   int *backmap;
7558   size_t ndirs;
7559   int idx_offset;
7560   size_t i;
7561   int idx;
7562
7563   /* Handle the case where file_table is empty.  */
7564   if (VARRAY_ACTIVE_SIZE (file_table) <= 1)
7565     {
7566       dw2_asm_output_data (1, 0, "End directory table");
7567       dw2_asm_output_data (1, 0, "End file name table");
7568       return;
7569     }
7570
7571   /* Allocate the various arrays we need.  */
7572   files = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct file_info));
7573   dirs = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct dir_info));
7574
7575   /* Sort the file names.  */
7576   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7577     {
7578       char *f;
7579
7580       /* Skip all leading "./".  */
7581       f = VARRAY_CHAR_PTR (file_table, i);
7582       while (f[0] == '.' && f[1] == '/')
7583         f += 2;
7584
7585       /* Create a new array entry.  */
7586       files[i].path = f;
7587       files[i].length = strlen (f);
7588       files[i].file_idx = i;
7589
7590       /* Search for the file name part.  */
7591       f = strrchr (f, '/');
7592       files[i].fname = f == NULL ? files[i].path : f + 1;
7593     }
7594
7595   qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1,
7596          sizeof (files[0]), file_info_cmp);
7597
7598   /* Find all the different directories used.  */
7599   dirs[0].path = files[1].path;
7600   dirs[0].length = files[1].fname - files[1].path;
7601   dirs[0].prefix = -1;
7602   dirs[0].count = 1;
7603   dirs[0].dir_idx = 0;
7604   dirs[0].used = 0;
7605   files[1].dir_idx = 0;
7606   ndirs = 1;
7607
7608   for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7609     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7610         && memcmp (dirs[ndirs - 1].path, files[i].path,
7611                    dirs[ndirs - 1].length) == 0)
7612       {
7613         /* Same directory as last entry.  */
7614         files[i].dir_idx = ndirs - 1;
7615         ++dirs[ndirs - 1].count;
7616       }
7617     else
7618       {
7619         size_t j;
7620
7621         /* This is a new directory.  */
7622         dirs[ndirs].path = files[i].path;
7623         dirs[ndirs].length = files[i].fname - files[i].path;
7624         dirs[ndirs].count = 1;
7625         dirs[ndirs].dir_idx = ndirs;
7626         dirs[ndirs].used = 0;
7627         files[i].dir_idx = ndirs;
7628
7629         /* Search for a prefix.  */
7630         dirs[ndirs].prefix = -1;
7631         for (j = 0; j < ndirs; j++)
7632           if (dirs[j].length < dirs[ndirs].length
7633               && dirs[j].length > 1
7634               && (dirs[ndirs].prefix == -1
7635                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7636               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7637             dirs[ndirs].prefix = j;
7638
7639         ++ndirs;
7640       }
7641
7642   /* Now to the actual work.  We have to find a subset of the directories which
7643      allow expressing the file name using references to the directory table
7644      with the least amount of characters.  We do not do an exhaustive search
7645      where we would have to check out every combination of every single
7646      possible prefix.  Instead we use a heuristic which provides nearly optimal
7647      results in most cases and never is much off.  */
7648   saved = alloca (ndirs * sizeof (int));
7649   savehere = alloca (ndirs * sizeof (int));
7650
7651   memset (saved, '\0', ndirs * sizeof (saved[0]));
7652   for (i = 0; i < ndirs; i++)
7653     {
7654       size_t j;
7655       int total;
7656
7657       /* We can always save some space for the current directory.  But this
7658          does not mean it will be enough to justify adding the directory.  */
7659       savehere[i] = dirs[i].length;
7660       total = (savehere[i] - saved[i]) * dirs[i].count;
7661
7662       for (j = i + 1; j < ndirs; j++)
7663         {
7664           savehere[j] = 0;
7665           if (saved[j] < dirs[i].length)
7666             {
7667               /* Determine whether the dirs[i] path is a prefix of the
7668                  dirs[j] path.  */
7669               int k;
7670
7671               k = dirs[j].prefix;
7672               while (k != -1 && k != (int) i)
7673                 k = dirs[k].prefix;
7674
7675               if (k == (int) i)
7676                 {
7677                   /* Yes it is.  We can possibly safe some memory but
7678                      writing the filenames in dirs[j] relative to
7679                      dirs[i].  */
7680                   savehere[j] = dirs[i].length;
7681                   total += (savehere[j] - saved[j]) * dirs[j].count;
7682                 }
7683             }
7684         }
7685
7686       /* Check whether we can safe enough to justify adding the dirs[i]
7687          directory.  */
7688       if (total > dirs[i].length + 1)
7689         {
7690           /* It's worthwhile adding.  */
7691           for (j = i; j < ndirs; j++)
7692             if (savehere[j] > 0)
7693               {
7694                 /* Remember how much we saved for this directory so far.  */
7695                 saved[j] = savehere[j];
7696
7697                 /* Remember the prefix directory.  */
7698                 dirs[j].dir_idx = i;
7699               }
7700         }
7701     }
7702
7703   /* We have to emit them in the order they appear in the file_table array
7704      since the index is used in the debug info generation.  To do this
7705      efficiently we generate a back-mapping of the indices first.  */
7706   backmap = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int));
7707   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7708     {
7709       backmap[files[i].file_idx] = i;
7710
7711       /* Mark this directory as used.  */
7712       dirs[dirs[files[i].dir_idx].dir_idx].used = 1;
7713     }
7714
7715   /* That was it.  We are ready to emit the information.  First emit the
7716      directory name table.  We have to make sure the first actually emitted
7717      directory name has index one; zero is reserved for the current working
7718      directory.  Make sure we do not confuse these indices with the one for the
7719      constructed table (even though most of the time they are identical).  */
7720   idx = 1;
7721   idx_offset = dirs[0].length > 0 ? 1 : 0;
7722   for (i = 1 - idx_offset; i < ndirs; i++)
7723     if (dirs[i].used != 0)
7724       {
7725         dirs[i].used = idx++;
7726         dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7727                                 "Directory Entry: 0x%x", dirs[i].used);
7728       }
7729
7730   dw2_asm_output_data (1, 0, "End directory table");
7731
7732   /* Correct the index for the current working directory entry if it
7733      exists.  */
7734   if (idx_offset == 0)
7735     dirs[0].used = 0;
7736
7737   /* Now write all the file names.  */
7738   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7739     {
7740       int file_idx = backmap[i];
7741       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7742
7743       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7744                               "File Entry: 0x%lx", (unsigned long) i);
7745
7746       /* Include directory index.  */
7747       dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL);
7748
7749       /* Modification time.  */
7750       dw2_asm_output_data_uleb128 (0, NULL);
7751
7752       /* File length in bytes.  */
7753       dw2_asm_output_data_uleb128 (0, NULL);
7754     }
7755
7756   dw2_asm_output_data (1, 0, "End file name table");
7757 }
7758
7759
7760 /* Output the source line number correspondence information.  This
7761    information goes into the .debug_line section.  */
7762
7763 static void
7764 output_line_info (void)
7765 {
7766   char l1[20], l2[20], p1[20], p2[20];
7767   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7768   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7769   unsigned opc;
7770   unsigned n_op_args;
7771   unsigned long lt_index;
7772   unsigned long current_line;
7773   long line_offset;
7774   long line_delta;
7775   unsigned long current_file;
7776   unsigned long function;
7777
7778   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7779   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7780   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7781   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7782
7783   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7784     dw2_asm_output_data (4, 0xffffffff,
7785       "Initial length escape value indicating 64-bit DWARF extension");
7786   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7787                         "Length of Source Line Info");
7788   ASM_OUTPUT_LABEL (asm_out_file, l1);
7789
7790   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7791   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7792   ASM_OUTPUT_LABEL (asm_out_file, p1);
7793
7794   /* Define the architecture-dependent minimum instruction length (in
7795    bytes).  In this implementation of DWARF, this field is used for
7796    information purposes only.  Since GCC generates assembly language,
7797    we have no a priori knowledge of how many instruction bytes are
7798    generated for each source line, and therefore can use only the
7799    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7800    commands.  Accordingly, we fix this as `1', which is "correct
7801    enough" for all architectures, and don't let the target override.  */
7802   dw2_asm_output_data (1, 1,
7803                        "Minimum Instruction Length");
7804
7805   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7806                        "Default is_stmt_start flag");
7807   dw2_asm_output_data (1, DWARF_LINE_BASE,
7808                        "Line Base Value (Special Opcodes)");
7809   dw2_asm_output_data (1, DWARF_LINE_RANGE,
7810                        "Line Range Value (Special Opcodes)");
7811   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7812                        "Special Opcode Base");
7813
7814   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7815     {
7816       switch (opc)
7817         {
7818         case DW_LNS_advance_pc:
7819         case DW_LNS_advance_line:
7820         case DW_LNS_set_file:
7821         case DW_LNS_set_column:
7822         case DW_LNS_fixed_advance_pc:
7823           n_op_args = 1;
7824           break;
7825         default:
7826           n_op_args = 0;
7827           break;
7828         }
7829
7830       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7831                            opc, n_op_args);
7832     }
7833
7834   /* Write out the information about the files we use.  */
7835   output_file_names ();
7836   ASM_OUTPUT_LABEL (asm_out_file, p2);
7837
7838   /* We used to set the address register to the first location in the text
7839      section here, but that didn't accomplish anything since we already
7840      have a line note for the opening brace of the first function.  */
7841
7842   /* Generate the line number to PC correspondence table, encoded as
7843      a series of state machine operations.  */
7844   current_file = 1;
7845   current_line = 1;
7846
7847   if (cfun && in_cold_section_p)
7848     strcpy (prev_line_label, cfun->cold_section_label);
7849   else
7850     strcpy (prev_line_label, text_section_label);
7851   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7852     {
7853       dw_line_info_ref line_info = &line_info_table[lt_index];
7854
7855 #if 0
7856       /* Disable this optimization for now; GDB wants to see two line notes
7857          at the beginning of a function so it can find the end of the
7858          prologue.  */
7859
7860       /* Don't emit anything for redundant notes.  Just updating the
7861          address doesn't accomplish anything, because we already assume
7862          that anything after the last address is this line.  */
7863       if (line_info->dw_line_num == current_line
7864           && line_info->dw_file_num == current_file)
7865         continue;
7866 #endif
7867
7868       /* Emit debug info for the address of the current line.
7869
7870          Unfortunately, we have little choice here currently, and must always
7871          use the most general form.  GCC does not know the address delta
7872          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
7873          attributes which will give an upper bound on the address range.  We
7874          could perhaps use length attributes to determine when it is safe to
7875          use DW_LNS_fixed_advance_pc.  */
7876
7877       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7878       if (0)
7879         {
7880           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
7881           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7882                                "DW_LNS_fixed_advance_pc");
7883           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7884         }
7885       else
7886         {
7887           /* This can handle any delta.  This takes
7888              4+DWARF2_ADDR_SIZE bytes.  */
7889           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7890           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7891           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7892           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7893         }
7894
7895       strcpy (prev_line_label, line_label);
7896
7897       /* Emit debug info for the source file of the current line, if
7898          different from the previous line.  */
7899       if (line_info->dw_file_num != current_file)
7900         {
7901           current_file = line_info->dw_file_num;
7902           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7903           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7904                                        VARRAY_CHAR_PTR (file_table,
7905                                                         current_file));
7906         }
7907
7908       /* Emit debug info for the current line number, choosing the encoding
7909          that uses the least amount of space.  */
7910       if (line_info->dw_line_num != current_line)
7911         {
7912           line_offset = line_info->dw_line_num - current_line;
7913           line_delta = line_offset - DWARF_LINE_BASE;
7914           current_line = line_info->dw_line_num;
7915           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7916             /* This can handle deltas from -10 to 234, using the current
7917                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
7918                takes 1 byte.  */
7919             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7920                                  "line %lu", current_line);
7921           else
7922             {
7923               /* This can handle any delta.  This takes at least 4 bytes,
7924                  depending on the value being encoded.  */
7925               dw2_asm_output_data (1, DW_LNS_advance_line,
7926                                    "advance to line %lu", current_line);
7927               dw2_asm_output_data_sleb128 (line_offset, NULL);
7928               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7929             }
7930         }
7931       else
7932         /* We still need to start a new row, so output a copy insn.  */
7933         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7934     }
7935
7936   /* Emit debug info for the address of the end of the function.  */
7937   if (0)
7938     {
7939       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7940                            "DW_LNS_fixed_advance_pc");
7941       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
7942     }
7943   else
7944     {
7945       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7946       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7947       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7948       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
7949     }
7950
7951   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7952   dw2_asm_output_data_uleb128 (1, NULL);
7953   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7954
7955   function = 0;
7956   current_file = 1;
7957   current_line = 1;
7958   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
7959     {
7960       dw_separate_line_info_ref line_info
7961         = &separate_line_info_table[lt_index];
7962
7963 #if 0
7964       /* Don't emit anything for redundant notes.  */
7965       if (line_info->dw_line_num == current_line
7966           && line_info->dw_file_num == current_file
7967           && line_info->function == function)
7968         goto cont;
7969 #endif
7970
7971       /* Emit debug info for the address of the current line.  If this is
7972          a new function, or the first line of a function, then we need
7973          to handle it differently.  */
7974       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
7975                                    lt_index);
7976       if (function != line_info->function)
7977         {
7978           function = line_info->function;
7979
7980           /* Set the address register to the first line in the function.  */
7981           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7982           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7983           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7984           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7985         }
7986       else
7987         {
7988           /* ??? See the DW_LNS_advance_pc comment above.  */
7989           if (0)
7990             {
7991               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7992                                    "DW_LNS_fixed_advance_pc");
7993               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7994             }
7995           else
7996             {
7997               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7998               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7999               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8000               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8001             }
8002         }
8003
8004       strcpy (prev_line_label, line_label);
8005
8006       /* Emit debug info for the source file of the current line, if
8007          different from the previous line.  */
8008       if (line_info->dw_file_num != current_file)
8009         {
8010           current_file = line_info->dw_file_num;
8011           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8012           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
8013                                        VARRAY_CHAR_PTR (file_table,
8014                                                         current_file));
8015         }
8016
8017       /* Emit debug info for the current line number, choosing the encoding
8018          that uses the least amount of space.  */
8019       if (line_info->dw_line_num != current_line)
8020         {
8021           line_offset = line_info->dw_line_num - current_line;
8022           line_delta = line_offset - DWARF_LINE_BASE;
8023           current_line = line_info->dw_line_num;
8024           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8025             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8026                                  "line %lu", current_line);
8027           else
8028             {
8029               dw2_asm_output_data (1, DW_LNS_advance_line,
8030                                    "advance to line %lu", current_line);
8031               dw2_asm_output_data_sleb128 (line_offset, NULL);
8032               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8033             }
8034         }
8035       else
8036         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8037
8038 #if 0
8039     cont:
8040 #endif
8041
8042       lt_index++;
8043
8044       /* If we're done with a function, end its sequence.  */
8045       if (lt_index == separate_line_info_table_in_use
8046           || separate_line_info_table[lt_index].function != function)
8047         {
8048           current_file = 1;
8049           current_line = 1;
8050
8051           /* Emit debug info for the address of the end of the function.  */
8052           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8053           if (0)
8054             {
8055               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8056                                    "DW_LNS_fixed_advance_pc");
8057               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8058             }
8059           else
8060             {
8061               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8062               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8063               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8064               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8065             }
8066
8067           /* Output the marker for the end of this sequence.  */
8068           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8069           dw2_asm_output_data_uleb128 (1, NULL);
8070           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8071         }
8072     }
8073
8074   /* Output the marker for the end of the line number info.  */
8075   ASM_OUTPUT_LABEL (asm_out_file, l2);
8076 }
8077 \f
8078 /* Given a pointer to a tree node for some base type, return a pointer to
8079    a DIE that describes the given type.
8080
8081    This routine must only be called for GCC type nodes that correspond to
8082    Dwarf base (fundamental) types.  */
8083
8084 static dw_die_ref
8085 base_type_die (tree type)
8086 {
8087   dw_die_ref base_type_result;
8088   enum dwarf_type encoding;
8089
8090   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8091     return 0;
8092
8093   switch (TREE_CODE (type))
8094     {
8095     case INTEGER_TYPE:
8096       if (TYPE_STRING_FLAG (type))
8097         {
8098           if (TYPE_UNSIGNED (type))
8099             encoding = DW_ATE_unsigned_char;
8100           else
8101             encoding = DW_ATE_signed_char;
8102         }
8103       else if (TYPE_UNSIGNED (type))
8104         encoding = DW_ATE_unsigned;
8105       else
8106         encoding = DW_ATE_signed;
8107       break;
8108
8109     case REAL_TYPE:
8110       if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8111         encoding = DW_ATE_decimal_float;
8112       else
8113         encoding = DW_ATE_float;
8114       break;
8115
8116       /* Dwarf2 doesn't know anything about complex ints, so use
8117          a user defined type for it.  */
8118     case COMPLEX_TYPE:
8119       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8120         encoding = DW_ATE_complex_float;
8121       else
8122         encoding = DW_ATE_lo_user;
8123       break;
8124
8125     case BOOLEAN_TYPE:
8126       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
8127       encoding = DW_ATE_boolean;
8128       break;
8129
8130     default:
8131       /* No other TREE_CODEs are Dwarf fundamental types.  */
8132       gcc_unreachable ();
8133     }
8134
8135   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8136
8137   /* This probably indicates a bug.  */
8138   if (! TYPE_NAME (type))
8139     add_name_attribute (base_type_result, "__unknown__");
8140
8141   add_AT_unsigned (base_type_result, DW_AT_byte_size,
8142                    int_size_in_bytes (type));
8143   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8144
8145   return base_type_result;
8146 }
8147
8148 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8149    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
8150    a given type is generally the same as the given type, except that if the
8151    given type is a pointer or reference type, then the root type of the given
8152    type is the root type of the "basis" type for the pointer or reference
8153    type.  (This definition of the "root" type is recursive.) Also, the root
8154    type of a `const' qualified type or a `volatile' qualified type is the
8155    root type of the given type without the qualifiers.  */
8156
8157 static tree
8158 root_type (tree type)
8159 {
8160   if (TREE_CODE (type) == ERROR_MARK)
8161     return error_mark_node;
8162
8163   switch (TREE_CODE (type))
8164     {
8165     case ERROR_MARK:
8166       return error_mark_node;
8167
8168     case POINTER_TYPE:
8169     case REFERENCE_TYPE:
8170       return type_main_variant (root_type (TREE_TYPE (type)));
8171
8172     default:
8173       return type_main_variant (type);
8174     }
8175 }
8176
8177 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8178    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
8179
8180 static inline int
8181 is_base_type (tree type)
8182 {
8183   switch (TREE_CODE (type))
8184     {
8185     case ERROR_MARK:
8186     case VOID_TYPE:
8187     case INTEGER_TYPE:
8188     case REAL_TYPE:
8189     case COMPLEX_TYPE:
8190     case BOOLEAN_TYPE:
8191       return 1;
8192
8193     case ARRAY_TYPE:
8194     case RECORD_TYPE:
8195     case UNION_TYPE:
8196     case QUAL_UNION_TYPE:
8197     case ENUMERAL_TYPE:
8198     case FUNCTION_TYPE:
8199     case METHOD_TYPE:
8200     case POINTER_TYPE:
8201     case REFERENCE_TYPE:
8202     case OFFSET_TYPE:
8203     case LANG_TYPE:
8204     case VECTOR_TYPE:
8205       return 0;
8206
8207     default:
8208       gcc_unreachable ();
8209     }
8210
8211   return 0;
8212 }
8213
8214 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8215    node, return the size in bits for the type if it is a constant, or else
8216    return the alignment for the type if the type's size is not constant, or
8217    else return BITS_PER_WORD if the type actually turns out to be an
8218    ERROR_MARK node.  */
8219
8220 static inline unsigned HOST_WIDE_INT
8221 simple_type_size_in_bits (tree type)
8222 {
8223   if (TREE_CODE (type) == ERROR_MARK)
8224     return BITS_PER_WORD;
8225   else if (TYPE_SIZE (type) == NULL_TREE)
8226     return 0;
8227   else if (host_integerp (TYPE_SIZE (type), 1))
8228     return tree_low_cst (TYPE_SIZE (type), 1);
8229   else
8230     return TYPE_ALIGN (type);
8231 }
8232
8233 /* Return true if the debug information for the given type should be
8234    emitted as a subrange type.  */
8235
8236 static inline bool
8237 is_subrange_type (tree type)
8238 {
8239   tree subtype = TREE_TYPE (type);
8240
8241   /* Subrange types are identified by the fact that they are integer
8242      types, and that they have a subtype which is either an integer type
8243      or an enumeral type.  */
8244
8245   if (TREE_CODE (type) != INTEGER_TYPE
8246       || subtype == NULL_TREE)
8247     return false;
8248
8249   if (TREE_CODE (subtype) != INTEGER_TYPE
8250       && TREE_CODE (subtype) != ENUMERAL_TYPE)
8251     return false;
8252
8253   if (TREE_CODE (type) == TREE_CODE (subtype)
8254       && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8255       && TYPE_MIN_VALUE (type) != NULL
8256       && TYPE_MIN_VALUE (subtype) != NULL
8257       && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8258       && TYPE_MAX_VALUE (type) != NULL
8259       && TYPE_MAX_VALUE (subtype) != NULL
8260       && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8261     {
8262       /* The type and its subtype have the same representation.  If in
8263          addition the two types also have the same name, then the given
8264          type is not a subrange type, but rather a plain base type.  */
8265       /* FIXME: brobecker/2004-03-22:
8266          Sizetype INTEGER_CSTs nodes are canonicalized.  It should
8267          therefore be sufficient to check the TYPE_SIZE node pointers
8268          rather than checking the actual size.  Unfortunately, we have
8269          found some cases, such as in the Ada "integer" type, where
8270          this is not the case.  Until this problem is solved, we need to
8271          keep checking the actual size.  */
8272       tree type_name = TYPE_NAME (type);
8273       tree subtype_name = TYPE_NAME (subtype);
8274
8275       if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8276         type_name = DECL_NAME (type_name);
8277
8278       if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8279         subtype_name = DECL_NAME (subtype_name);
8280
8281       if (type_name == subtype_name)
8282         return false;
8283     }
8284
8285   return true;
8286 }
8287
8288 /*  Given a pointer to a tree node for a subrange type, return a pointer
8289     to a DIE that describes the given type.  */
8290
8291 static dw_die_ref
8292 subrange_type_die (tree type, dw_die_ref context_die)
8293 {
8294   dw_die_ref subrange_die;
8295   const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8296
8297   if (context_die == NULL)
8298     context_die = comp_unit_die;
8299
8300   subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8301
8302   if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8303     {
8304       /* The size of the subrange type and its base type do not match,
8305          so we need to generate a size attribute for the subrange type.  */
8306       add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8307     }
8308
8309   if (TYPE_MIN_VALUE (type) != NULL)
8310     add_bound_info (subrange_die, DW_AT_lower_bound,
8311                     TYPE_MIN_VALUE (type));
8312   if (TYPE_MAX_VALUE (type) != NULL)
8313     add_bound_info (subrange_die, DW_AT_upper_bound,
8314                     TYPE_MAX_VALUE (type));
8315
8316   return subrange_die;
8317 }
8318
8319 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8320    entry that chains various modifiers in front of the given type.  */
8321
8322 static dw_die_ref
8323 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8324                    dw_die_ref context_die)
8325 {
8326   enum tree_code code = TREE_CODE (type);
8327   dw_die_ref mod_type_die;
8328   dw_die_ref sub_die = NULL;
8329   tree item_type = NULL;
8330   tree qualified_type;
8331   tree name;
8332
8333   if (code == ERROR_MARK)
8334     return NULL;
8335
8336   /* See if we already have the appropriately qualified variant of
8337      this type.  */
8338   qualified_type
8339     = get_qualified_type (type,
8340                           ((is_const_type ? TYPE_QUAL_CONST : 0)
8341                            | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8342
8343   /* If we do, then we can just use its DIE, if it exists.  */
8344   if (qualified_type)
8345     {
8346       mod_type_die = lookup_type_die (qualified_type);
8347       if (mod_type_die)
8348         return mod_type_die;
8349     }
8350
8351   name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8352
8353   /* Handle C typedef types.  */
8354   if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8355     {
8356       tree dtype = TREE_TYPE (name);
8357
8358       if (qualified_type == dtype)
8359         {
8360           /* For a named type, use the typedef.  */
8361           gen_type_die (qualified_type, context_die);
8362           return lookup_type_die (qualified_type);
8363         }
8364       else if (DECL_ORIGINAL_TYPE (name)
8365                && (is_const_type < TYPE_READONLY (dtype)
8366                    || is_volatile_type < TYPE_VOLATILE (dtype)))
8367         /* cv-unqualified version of named type.  Just use the unnamed
8368            type to which it refers.  */
8369         return modified_type_die (DECL_ORIGINAL_TYPE (name),
8370                                   is_const_type, is_volatile_type,
8371                                   context_die);
8372       /* Else cv-qualified version of named type; fall through.  */
8373     }
8374
8375   if (is_const_type)
8376     {
8377       mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8378       sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8379     }
8380   else if (is_volatile_type)
8381     {
8382       mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8383       sub_die = modified_type_die (type, 0, 0, context_die);
8384     }
8385   else if (code == POINTER_TYPE)
8386     {
8387       mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8388       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8389                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8390       item_type = TREE_TYPE (type);
8391     }
8392   else if (code == REFERENCE_TYPE)
8393     {
8394       mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8395       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8396                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8397       item_type = TREE_TYPE (type);
8398     }
8399   else if (is_subrange_type (type))
8400     {
8401       mod_type_die = subrange_type_die (type, context_die);
8402       item_type = TREE_TYPE (type);
8403     }
8404   else if (is_base_type (type))
8405     mod_type_die = base_type_die (type);
8406   else
8407     {
8408       gen_type_die (type, context_die);
8409
8410       /* We have to get the type_main_variant here (and pass that to the
8411          `lookup_type_die' routine) because the ..._TYPE node we have
8412          might simply be a *copy* of some original type node (where the
8413          copy was created to help us keep track of typedef names) and
8414          that copy might have a different TYPE_UID from the original
8415          ..._TYPE node.  */
8416       if (TREE_CODE (type) != VECTOR_TYPE)
8417         return lookup_type_die (type_main_variant (type));
8418       else
8419         /* Vectors have the debugging information in the type,
8420            not the main variant.  */
8421         return lookup_type_die (type);
8422     }
8423
8424   /* Builtin types don't have a DECL_ORIGINAL_TYPE.  For those,
8425      don't output a DW_TAG_typedef, since there isn't one in the
8426      user's program; just attach a DW_AT_name to the type.  */
8427   if (name
8428       && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type))
8429     {
8430       if (TREE_CODE (name) == TYPE_DECL)
8431         /* Could just call add_name_and_src_coords_attributes here,
8432            but since this is a builtin type it doesn't have any
8433            useful source coordinates anyway.  */
8434         name = DECL_NAME (name);
8435       add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8436     }
8437
8438   if (qualified_type)
8439     equate_type_number_to_die (qualified_type, mod_type_die);
8440
8441   if (item_type)
8442     /* We must do this after the equate_type_number_to_die call, in case
8443        this is a recursive type.  This ensures that the modified_type_die
8444        recursion will terminate even if the type is recursive.  Recursive
8445        types are possible in Ada.  */
8446     sub_die = modified_type_die (item_type,
8447                                  TYPE_READONLY (item_type),
8448                                  TYPE_VOLATILE (item_type),
8449                                  context_die);
8450
8451   if (sub_die != NULL)
8452     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8453
8454   return mod_type_die;
8455 }
8456
8457 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8458    an enumerated type.  */
8459
8460 static inline int
8461 type_is_enum (tree type)
8462 {
8463   return TREE_CODE (type) == ENUMERAL_TYPE;
8464 }
8465
8466 /* Return the DBX register number described by a given RTL node.  */
8467
8468 static unsigned int
8469 dbx_reg_number (rtx rtl)
8470 {
8471   unsigned regno = REGNO (rtl);
8472
8473   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8474
8475 #ifdef LEAF_REG_REMAP
8476   regno = LEAF_REG_REMAP (regno);
8477 #endif
8478
8479   return DBX_REGISTER_NUMBER (regno);
8480 }
8481
8482 /* Optionally add a DW_OP_piece term to a location description expression.
8483    DW_OP_piece is only added if the location description expression already
8484    doesn't end with DW_OP_piece.  */
8485
8486 static void
8487 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8488 {
8489   dw_loc_descr_ref loc;
8490
8491   if (*list_head != NULL)
8492     {
8493       /* Find the end of the chain.  */
8494       for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8495         ;
8496
8497       if (loc->dw_loc_opc != DW_OP_piece)
8498         loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8499     }
8500 }
8501
8502 /* Return a location descriptor that designates a machine register or
8503    zero if there is none.  */
8504
8505 static dw_loc_descr_ref
8506 reg_loc_descriptor (rtx rtl)
8507 {
8508   rtx regs;
8509
8510   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8511     return 0;
8512
8513   regs = targetm.dwarf_register_span (rtl);
8514
8515   if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8516     return multiple_reg_loc_descriptor (rtl, regs);
8517   else
8518     return one_reg_loc_descriptor (dbx_reg_number (rtl));
8519 }
8520
8521 /* Return a location descriptor that designates a machine register for
8522    a given hard register number.  */
8523
8524 static dw_loc_descr_ref
8525 one_reg_loc_descriptor (unsigned int regno)
8526 {
8527   if (regno <= 31)
8528     return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8529   else
8530     return new_loc_descr (DW_OP_regx, regno, 0);
8531 }
8532
8533 /* Given an RTL of a register, return a location descriptor that
8534    designates a value that spans more than one register.  */
8535
8536 static dw_loc_descr_ref
8537 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8538 {
8539   int nregs, size, i;
8540   unsigned reg;
8541   dw_loc_descr_ref loc_result = NULL;
8542
8543   reg = REGNO (rtl);
8544 #ifdef LEAF_REG_REMAP
8545   reg = LEAF_REG_REMAP (reg);
8546 #endif
8547   gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8548   nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8549
8550   /* Simple, contiguous registers.  */
8551   if (regs == NULL_RTX)
8552     {
8553       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8554
8555       loc_result = NULL;
8556       while (nregs--)
8557         {
8558           dw_loc_descr_ref t;
8559
8560           t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8561           add_loc_descr (&loc_result, t);
8562           add_loc_descr_op_piece (&loc_result, size);
8563           ++reg;
8564         }
8565       return loc_result;
8566     }
8567
8568   /* Now onto stupid register sets in non contiguous locations.  */
8569
8570   gcc_assert (GET_CODE (regs) == PARALLEL);
8571
8572   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8573   loc_result = NULL;
8574
8575   for (i = 0; i < XVECLEN (regs, 0); ++i)
8576     {
8577       dw_loc_descr_ref t;
8578
8579       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8580       add_loc_descr (&loc_result, t);
8581       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8582       add_loc_descr_op_piece (&loc_result, size);
8583     }
8584   return loc_result;
8585 }
8586
8587 /* Return a location descriptor that designates a constant.  */
8588
8589 static dw_loc_descr_ref
8590 int_loc_descriptor (HOST_WIDE_INT i)
8591 {
8592   enum dwarf_location_atom op;
8593
8594   /* Pick the smallest representation of a constant, rather than just
8595      defaulting to the LEB encoding.  */
8596   if (i >= 0)
8597     {
8598       if (i <= 31)
8599         op = DW_OP_lit0 + i;
8600       else if (i <= 0xff)
8601         op = DW_OP_const1u;
8602       else if (i <= 0xffff)
8603         op = DW_OP_const2u;
8604       else if (HOST_BITS_PER_WIDE_INT == 32
8605                || i <= 0xffffffff)
8606         op = DW_OP_const4u;
8607       else
8608         op = DW_OP_constu;
8609     }
8610   else
8611     {
8612       if (i >= -0x80)
8613         op = DW_OP_const1s;
8614       else if (i >= -0x8000)
8615         op = DW_OP_const2s;
8616       else if (HOST_BITS_PER_WIDE_INT == 32
8617                || i >= -0x80000000)
8618         op = DW_OP_const4s;
8619       else
8620         op = DW_OP_consts;
8621     }
8622
8623   return new_loc_descr (op, i, 0);
8624 }
8625
8626 /* Return a location descriptor that designates a base+offset location.  */
8627
8628 static dw_loc_descr_ref
8629 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8630 {
8631   unsigned int regno;
8632
8633   /* We only use "frame base" when we're sure we're talking about the
8634      post-prologue local stack frame.  We do this by *not* running
8635      register elimination until this point, and recognizing the special
8636      argument pointer and soft frame pointer rtx's.  */
8637   if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8638     {
8639       rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8640
8641       if (elim != reg)
8642         {
8643           if (GET_CODE (elim) == PLUS)
8644             {
8645               offset += INTVAL (XEXP (elim, 1));
8646               elim = XEXP (elim, 0);
8647             }
8648           gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8649                       : stack_pointer_rtx));
8650           offset += frame_pointer_fb_offset;
8651
8652           return new_loc_descr (DW_OP_fbreg, offset, 0);
8653         }
8654     }
8655
8656   regno = dbx_reg_number (reg);
8657   if (regno <= 31)
8658     return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8659   else
8660     return new_loc_descr (DW_OP_bregx, regno, offset);
8661 }
8662
8663 /* Return true if this RTL expression describes a base+offset calculation.  */
8664
8665 static inline int
8666 is_based_loc (rtx rtl)
8667 {
8668   return (GET_CODE (rtl) == PLUS
8669           && ((REG_P (XEXP (rtl, 0))
8670                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8671                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8672 }
8673
8674 /* The following routine converts the RTL for a variable or parameter
8675    (resident in memory) into an equivalent Dwarf representation of a
8676    mechanism for getting the address of that same variable onto the top of a
8677    hypothetical "address evaluation" stack.
8678
8679    When creating memory location descriptors, we are effectively transforming
8680    the RTL for a memory-resident object into its Dwarf postfix expression
8681    equivalent.  This routine recursively descends an RTL tree, turning
8682    it into Dwarf postfix code as it goes.
8683
8684    MODE is the mode of the memory reference, needed to handle some
8685    autoincrement addressing modes.
8686
8687    CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8688    location list for RTL.
8689
8690    Return 0 if we can't represent the location.  */
8691
8692 static dw_loc_descr_ref
8693 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8694 {
8695   dw_loc_descr_ref mem_loc_result = NULL;
8696   enum dwarf_location_atom op;
8697
8698   /* Note that for a dynamically sized array, the location we will generate a
8699      description of here will be the lowest numbered location which is
8700      actually within the array.  That's *not* necessarily the same as the
8701      zeroth element of the array.  */
8702
8703   rtl = targetm.delegitimize_address (rtl);
8704
8705   switch (GET_CODE (rtl))
8706     {
8707     case POST_INC:
8708     case POST_DEC:
8709     case POST_MODIFY:
8710       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8711          just fall into the SUBREG code.  */
8712
8713       /* ... fall through ...  */
8714
8715     case SUBREG:
8716       /* The case of a subreg may arise when we have a local (register)
8717          variable or a formal (register) parameter which doesn't quite fill
8718          up an entire register.  For now, just assume that it is
8719          legitimate to make the Dwarf info refer to the whole register which
8720          contains the given subreg.  */
8721       rtl = XEXP (rtl, 0);
8722
8723       /* ... fall through ...  */
8724
8725     case REG:
8726       /* Whenever a register number forms a part of the description of the
8727          method for calculating the (dynamic) address of a memory resident
8728          object, DWARF rules require the register number be referred to as
8729          a "base register".  This distinction is not based in any way upon
8730          what category of register the hardware believes the given register
8731          belongs to.  This is strictly DWARF terminology we're dealing with
8732          here. Note that in cases where the location of a memory-resident
8733          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8734          OP_CONST (0)) the actual DWARF location descriptor that we generate
8735          may just be OP_BASEREG (basereg).  This may look deceptively like
8736          the object in question was allocated to a register (rather than in
8737          memory) so DWARF consumers need to be aware of the subtle
8738          distinction between OP_REG and OP_BASEREG.  */
8739       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8740         mem_loc_result = based_loc_descr (rtl, 0);
8741       break;
8742
8743     case MEM:
8744       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8745       if (mem_loc_result != 0)
8746         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8747       break;
8748
8749     case LO_SUM:
8750          rtl = XEXP (rtl, 1);
8751
8752       /* ... fall through ...  */
8753
8754     case LABEL_REF:
8755       /* Some ports can transform a symbol ref into a label ref, because
8756          the symbol ref is too far away and has to be dumped into a constant
8757          pool.  */
8758     case CONST:
8759     case SYMBOL_REF:
8760       /* Alternatively, the symbol in the constant pool might be referenced
8761          by a different symbol.  */
8762       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8763         {
8764           bool marked;
8765           rtx tmp = get_pool_constant_mark (rtl, &marked);
8766
8767           if (GET_CODE (tmp) == SYMBOL_REF)
8768             {
8769               rtl = tmp;
8770               if (CONSTANT_POOL_ADDRESS_P (tmp))
8771                 get_pool_constant_mark (tmp, &marked);
8772               else
8773                 marked = true;
8774             }
8775
8776           /* If all references to this pool constant were optimized away,
8777              it was not output and thus we can't represent it.
8778              FIXME: might try to use DW_OP_const_value here, though
8779              DW_OP_piece complicates it.  */
8780           if (!marked)
8781             return 0;
8782         }
8783
8784       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8785       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8786       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8787       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8788       break;
8789
8790     case PRE_MODIFY:
8791       /* Extract the PLUS expression nested inside and fall into
8792          PLUS code below.  */
8793       rtl = XEXP (rtl, 1);
8794       goto plus;
8795
8796     case PRE_INC:
8797     case PRE_DEC:
8798       /* Turn these into a PLUS expression and fall into the PLUS code
8799          below.  */
8800       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8801                           GEN_INT (GET_CODE (rtl) == PRE_INC
8802                                    ? GET_MODE_UNIT_SIZE (mode)
8803                                    : -GET_MODE_UNIT_SIZE (mode)));
8804
8805       /* ... fall through ...  */
8806
8807     case PLUS:
8808     plus:
8809       if (is_based_loc (rtl))
8810         mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8811                                           INTVAL (XEXP (rtl, 1)));
8812       else
8813         {
8814           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8815           if (mem_loc_result == 0)
8816             break;
8817
8818           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8819               && INTVAL (XEXP (rtl, 1)) >= 0)
8820             add_loc_descr (&mem_loc_result,
8821                            new_loc_descr (DW_OP_plus_uconst,
8822                                           INTVAL (XEXP (rtl, 1)), 0));
8823           else
8824             {
8825               add_loc_descr (&mem_loc_result,
8826                              mem_loc_descriptor (XEXP (rtl, 1), mode));
8827               add_loc_descr (&mem_loc_result,
8828                              new_loc_descr (DW_OP_plus, 0, 0));
8829             }
8830         }
8831       break;
8832
8833     /* If a pseudo-reg is optimized away, it is possible for it to
8834        be replaced with a MEM containing a multiply or shift.  */
8835     case MULT:
8836       op = DW_OP_mul;
8837       goto do_binop;
8838
8839     case ASHIFT:
8840       op = DW_OP_shl;
8841       goto do_binop;
8842
8843     case ASHIFTRT:
8844       op = DW_OP_shra;
8845       goto do_binop;
8846
8847     case LSHIFTRT:
8848       op = DW_OP_shr;
8849       goto do_binop;
8850
8851     do_binop:
8852       {
8853         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8854         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8855
8856         if (op0 == 0 || op1 == 0)
8857           break;
8858
8859         mem_loc_result = op0;
8860         add_loc_descr (&mem_loc_result, op1);
8861         add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
8862         break;
8863       }
8864
8865     case CONST_INT:
8866       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8867       break;
8868
8869     default:
8870       gcc_unreachable ();
8871     }
8872
8873   return mem_loc_result;
8874 }
8875
8876 /* Return a descriptor that describes the concatenation of two locations.
8877    This is typically a complex variable.  */
8878
8879 static dw_loc_descr_ref
8880 concat_loc_descriptor (rtx x0, rtx x1)
8881 {
8882   dw_loc_descr_ref cc_loc_result = NULL;
8883   dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8884   dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8885
8886   if (x0_ref == 0 || x1_ref == 0)
8887     return 0;
8888
8889   cc_loc_result = x0_ref;
8890   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
8891
8892   add_loc_descr (&cc_loc_result, x1_ref);
8893   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
8894
8895   return cc_loc_result;
8896 }
8897
8898 /* Output a proper Dwarf location descriptor for a variable or parameter
8899    which is either allocated in a register or in a memory location.  For a
8900    register, we just generate an OP_REG and the register number.  For a
8901    memory location we provide a Dwarf postfix expression describing how to
8902    generate the (dynamic) address of the object onto the address stack.
8903
8904    If we don't know how to describe it, return 0.  */
8905
8906 static dw_loc_descr_ref
8907 loc_descriptor (rtx rtl)
8908 {
8909   dw_loc_descr_ref loc_result = NULL;
8910
8911   switch (GET_CODE (rtl))
8912     {
8913     case SUBREG:
8914       /* The case of a subreg may arise when we have a local (register)
8915          variable or a formal (register) parameter which doesn't quite fill
8916          up an entire register.  For now, just assume that it is
8917          legitimate to make the Dwarf info refer to the whole register which
8918          contains the given subreg.  */
8919       rtl = SUBREG_REG (rtl);
8920
8921       /* ... fall through ...  */
8922
8923     case REG:
8924       loc_result = reg_loc_descriptor (rtl);
8925       break;
8926
8927     case MEM:
8928       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8929       break;
8930
8931     case CONCAT:
8932       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8933       break;
8934
8935     case VAR_LOCATION:
8936       /* Single part.  */
8937       if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
8938         {
8939           loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
8940           break;
8941         }
8942
8943       rtl = XEXP (rtl, 1);
8944       /* FALLTHRU */
8945
8946     case PARALLEL:
8947       {
8948         rtvec par_elems = XVEC (rtl, 0);
8949         int num_elem = GET_NUM_ELEM (par_elems);
8950         enum machine_mode mode;
8951         int i;
8952
8953         /* Create the first one, so we have something to add to.  */
8954         loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
8955         mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
8956         add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
8957         for (i = 1; i < num_elem; i++)
8958           {
8959             dw_loc_descr_ref temp;
8960
8961             temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
8962             add_loc_descr (&loc_result, temp);
8963             mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
8964             add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
8965           }
8966       }
8967       break;
8968
8969     default:
8970       gcc_unreachable ();
8971     }
8972
8973   return loc_result;
8974 }
8975
8976 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
8977    up particularly with variable length arrays.  WANT_ADDRESS is 2 if this is
8978    a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
8979    top-level invocation, and we require the address of LOC; is 0 if we require
8980    the value of LOC.  */
8981
8982 static dw_loc_descr_ref
8983 loc_descriptor_from_tree_1 (tree loc, int want_address)
8984 {
8985   dw_loc_descr_ref ret, ret1;
8986   int have_address = 0;
8987   enum dwarf_location_atom op;
8988
8989   /* ??? Most of the time we do not take proper care for sign/zero
8990      extending the values properly.  Hopefully this won't be a real
8991      problem...  */
8992
8993   switch (TREE_CODE (loc))
8994     {
8995     case ERROR_MARK:
8996       return 0;
8997
8998     case PLACEHOLDER_EXPR:
8999       /* This case involves extracting fields from an object to determine the
9000          position of other fields.  We don't try to encode this here.  The
9001          only user of this is Ada, which encodes the needed information using
9002          the names of types.  */
9003       return 0;
9004
9005     case CALL_EXPR:
9006       return 0;
9007
9008     case PREINCREMENT_EXPR:
9009     case PREDECREMENT_EXPR:
9010     case POSTINCREMENT_EXPR:
9011     case POSTDECREMENT_EXPR:
9012       /* There are no opcodes for these operations.  */
9013       return 0;
9014
9015     case ADDR_EXPR:
9016       /* If we already want an address, there's nothing we can do.  */
9017       if (want_address)
9018         return 0;
9019
9020       /* Otherwise, process the argument and look for the address.  */
9021       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9022
9023     case VAR_DECL:
9024       if (DECL_THREAD_LOCAL_P (loc))
9025         {
9026           rtx rtl;
9027
9028           /* If this is not defined, we have no way to emit the data.  */
9029           if (!targetm.asm_out.output_dwarf_dtprel)
9030             return 0;
9031
9032           /* The way DW_OP_GNU_push_tls_address is specified, we can only
9033              look up addresses of objects in the current module.  */
9034           if (DECL_EXTERNAL (loc))
9035             return 0;
9036
9037           rtl = rtl_for_decl_location (loc);
9038           if (rtl == NULL_RTX)
9039             return 0;
9040
9041           if (!MEM_P (rtl))
9042             return 0;
9043           rtl = XEXP (rtl, 0);
9044           if (! CONSTANT_P (rtl))
9045             return 0;
9046
9047           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9048           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9049           ret->dw_loc_oprnd1.v.val_addr = rtl;
9050
9051           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9052           add_loc_descr (&ret, ret1);
9053
9054           have_address = 1;
9055           break;
9056         }
9057       /* FALLTHRU */
9058
9059     case PARM_DECL:
9060       if (DECL_HAS_VALUE_EXPR_P (loc))
9061         return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9062                                            want_address);
9063       /* FALLTHRU */
9064
9065     case RESULT_DECL:
9066       {
9067         rtx rtl = rtl_for_decl_location (loc);
9068
9069         if (rtl == NULL_RTX)
9070           return 0;
9071         else if (GET_CODE (rtl) == CONST_INT)
9072           {
9073             HOST_WIDE_INT val = INTVAL (rtl);
9074             if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9075               val &= GET_MODE_MASK (DECL_MODE (loc));
9076             ret = int_loc_descriptor (val);
9077           }
9078         else if (GET_CODE (rtl) == CONST_STRING)
9079           return 0;
9080         else if (CONSTANT_P (rtl))
9081           {
9082             ret = new_loc_descr (DW_OP_addr, 0, 0);
9083             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9084             ret->dw_loc_oprnd1.v.val_addr = rtl;
9085           }
9086         else
9087           {
9088             enum machine_mode mode;
9089
9090             /* Certain constructs can only be represented at top-level.  */
9091             if (want_address == 2)
9092               return loc_descriptor (rtl);
9093
9094             mode = GET_MODE (rtl);
9095             if (MEM_P (rtl))
9096               {
9097                 rtl = XEXP (rtl, 0);
9098                 have_address = 1;
9099               }
9100             ret = mem_loc_descriptor (rtl, mode);
9101           }
9102       }
9103       break;
9104
9105     case INDIRECT_REF:
9106       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9107       have_address = 1;
9108       break;
9109
9110     case COMPOUND_EXPR:
9111       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9112
9113     case NOP_EXPR:
9114     case CONVERT_EXPR:
9115     case NON_LVALUE_EXPR:
9116     case VIEW_CONVERT_EXPR:
9117     case SAVE_EXPR:
9118     case MODIFY_EXPR:
9119       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9120
9121     case COMPONENT_REF:
9122     case BIT_FIELD_REF:
9123     case ARRAY_REF:
9124     case ARRAY_RANGE_REF:
9125       {
9126         tree obj, offset;
9127         HOST_WIDE_INT bitsize, bitpos, bytepos;
9128         enum machine_mode mode;
9129         int volatilep;
9130         int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9131
9132         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9133                                    &unsignedp, &volatilep, false);
9134
9135         if (obj == loc)
9136           return 0;
9137
9138         ret = loc_descriptor_from_tree_1 (obj, 1);
9139         if (ret == 0
9140             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9141           return 0;
9142
9143         if (offset != NULL_TREE)
9144           {
9145             /* Variable offset.  */
9146             add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9147             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9148           }
9149
9150         bytepos = bitpos / BITS_PER_UNIT;
9151         if (bytepos > 0)
9152           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9153         else if (bytepos < 0)
9154           {
9155             add_loc_descr (&ret, int_loc_descriptor (bytepos));
9156             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9157           }
9158
9159         have_address = 1;
9160         break;
9161       }
9162
9163     case INTEGER_CST:
9164       if (host_integerp (loc, 0))
9165         ret = int_loc_descriptor (tree_low_cst (loc, 0));
9166       else
9167         return 0;
9168       break;
9169
9170     case CONSTRUCTOR:
9171       {
9172         /* Get an RTL for this, if something has been emitted.  */
9173         rtx rtl = lookup_constant_def (loc);
9174         enum machine_mode mode;
9175
9176         if (!rtl || !MEM_P (rtl))
9177           return 0;
9178         mode = GET_MODE (rtl);
9179         rtl = XEXP (rtl, 0);
9180         ret = mem_loc_descriptor (rtl, mode);
9181         have_address = 1;
9182         break;
9183       }
9184
9185     case TRUTH_AND_EXPR:
9186     case TRUTH_ANDIF_EXPR:
9187     case BIT_AND_EXPR:
9188       op = DW_OP_and;
9189       goto do_binop;
9190
9191     case TRUTH_XOR_EXPR:
9192     case BIT_XOR_EXPR:
9193       op = DW_OP_xor;
9194       goto do_binop;
9195
9196     case TRUTH_OR_EXPR:
9197     case TRUTH_ORIF_EXPR:
9198     case BIT_IOR_EXPR:
9199       op = DW_OP_or;
9200       goto do_binop;
9201
9202     case FLOOR_DIV_EXPR:
9203     case CEIL_DIV_EXPR:
9204     case ROUND_DIV_EXPR:
9205     case TRUNC_DIV_EXPR:
9206       op = DW_OP_div;
9207       goto do_binop;
9208
9209     case MINUS_EXPR:
9210       op = DW_OP_minus;
9211       goto do_binop;
9212
9213     case FLOOR_MOD_EXPR:
9214     case CEIL_MOD_EXPR:
9215     case ROUND_MOD_EXPR:
9216     case TRUNC_MOD_EXPR:
9217       op = DW_OP_mod;
9218       goto do_binop;
9219
9220     case MULT_EXPR:
9221       op = DW_OP_mul;
9222       goto do_binop;
9223
9224     case LSHIFT_EXPR:
9225       op = DW_OP_shl;
9226       goto do_binop;
9227
9228     case RSHIFT_EXPR:
9229       op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9230       goto do_binop;
9231
9232     case PLUS_EXPR:
9233       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9234           && host_integerp (TREE_OPERAND (loc, 1), 0))
9235         {
9236           ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9237           if (ret == 0)
9238             return 0;
9239
9240           add_loc_descr (&ret,
9241                          new_loc_descr (DW_OP_plus_uconst,
9242                                         tree_low_cst (TREE_OPERAND (loc, 1),
9243                                                       0),
9244                                         0));
9245           break;
9246         }
9247
9248       op = DW_OP_plus;
9249       goto do_binop;
9250
9251     case LE_EXPR:
9252       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9253         return 0;
9254
9255       op = DW_OP_le;
9256       goto do_binop;
9257
9258     case GE_EXPR:
9259       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9260         return 0;
9261
9262       op = DW_OP_ge;
9263       goto do_binop;
9264
9265     case LT_EXPR:
9266       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9267         return 0;
9268
9269       op = DW_OP_lt;
9270       goto do_binop;
9271
9272     case GT_EXPR:
9273       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9274         return 0;
9275
9276       op = DW_OP_gt;
9277       goto do_binop;
9278
9279     case EQ_EXPR:
9280       op = DW_OP_eq;
9281       goto do_binop;
9282
9283     case NE_EXPR:
9284       op = DW_OP_ne;
9285       goto do_binop;
9286
9287     do_binop:
9288       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9289       ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9290       if (ret == 0 || ret1 == 0)
9291         return 0;
9292
9293       add_loc_descr (&ret, ret1);
9294       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9295       break;
9296
9297     case TRUTH_NOT_EXPR:
9298     case BIT_NOT_EXPR:
9299       op = DW_OP_not;
9300       goto do_unop;
9301
9302     case ABS_EXPR:
9303       op = DW_OP_abs;
9304       goto do_unop;
9305
9306     case NEGATE_EXPR:
9307       op = DW_OP_neg;
9308       goto do_unop;
9309
9310     do_unop:
9311       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9312       if (ret == 0)
9313         return 0;
9314
9315       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9316       break;
9317
9318     case MIN_EXPR:
9319     case MAX_EXPR:
9320       {
9321         const enum tree_code code =
9322           TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9323
9324         loc = build3 (COND_EXPR, TREE_TYPE (loc),
9325                       build2 (code, integer_type_node,
9326                               TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9327                       TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9328       }
9329
9330       /* ... fall through ...  */
9331
9332     case COND_EXPR:
9333       {
9334         dw_loc_descr_ref lhs
9335           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9336         dw_loc_descr_ref rhs
9337           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9338         dw_loc_descr_ref bra_node, jump_node, tmp;
9339
9340         ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9341         if (ret == 0 || lhs == 0 || rhs == 0)
9342           return 0;
9343
9344         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9345         add_loc_descr (&ret, bra_node);
9346
9347         add_loc_descr (&ret, rhs);
9348         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9349         add_loc_descr (&ret, jump_node);
9350
9351         add_loc_descr (&ret, lhs);
9352         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9353         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9354
9355         /* ??? Need a node to point the skip at.  Use a nop.  */
9356         tmp = new_loc_descr (DW_OP_nop, 0, 0);
9357         add_loc_descr (&ret, tmp);
9358         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9359         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9360       }
9361       break;
9362
9363     case FIX_TRUNC_EXPR:
9364     case FIX_CEIL_EXPR:
9365     case FIX_FLOOR_EXPR:
9366     case FIX_ROUND_EXPR:
9367       return 0;
9368
9369     default:
9370       /* Leave front-end specific codes as simply unknown.  This comes
9371          up, for instance, with the C STMT_EXPR.  */
9372       if ((unsigned int) TREE_CODE (loc)
9373           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9374         return 0;
9375
9376 #ifdef ENABLE_CHECKING
9377       /* Otherwise this is a generic code; we should just lists all of
9378          these explicitly.  We forgot one.  */
9379       gcc_unreachable ();
9380 #else
9381       /* In a release build, we want to degrade gracefully: better to
9382          generate incomplete debugging information than to crash.  */
9383       return NULL;
9384 #endif
9385     }
9386
9387   /* Show if we can't fill the request for an address.  */
9388   if (want_address && !have_address)
9389     return 0;
9390
9391   /* If we've got an address and don't want one, dereference.  */
9392   if (!want_address && have_address && ret)
9393     {
9394       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9395
9396       if (size > DWARF2_ADDR_SIZE || size == -1)
9397         return 0;
9398       else if (size == DWARF2_ADDR_SIZE)
9399         op = DW_OP_deref;
9400       else
9401         op = DW_OP_deref_size;
9402
9403       add_loc_descr (&ret, new_loc_descr (op, size, 0));
9404     }
9405
9406   return ret;
9407 }
9408
9409 static inline dw_loc_descr_ref
9410 loc_descriptor_from_tree (tree loc)
9411 {
9412   return loc_descriptor_from_tree_1 (loc, 2);
9413 }
9414
9415 /* Given a value, round it up to the lowest multiple of `boundary'
9416    which is not less than the value itself.  */
9417
9418 static inline HOST_WIDE_INT
9419 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9420 {
9421   return (((value + boundary - 1) / boundary) * boundary);
9422 }
9423
9424 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9425    pointer to the declared type for the relevant field variable, or return
9426    `integer_type_node' if the given node turns out to be an
9427    ERROR_MARK node.  */
9428
9429 static inline tree
9430 field_type (tree decl)
9431 {
9432   tree type;
9433
9434   if (TREE_CODE (decl) == ERROR_MARK)
9435     return integer_type_node;
9436
9437   type = DECL_BIT_FIELD_TYPE (decl);
9438   if (type == NULL_TREE)
9439     type = TREE_TYPE (decl);
9440
9441   return type;
9442 }
9443
9444 /* Given a pointer to a tree node, return the alignment in bits for
9445    it, or else return BITS_PER_WORD if the node actually turns out to
9446    be an ERROR_MARK node.  */
9447
9448 static inline unsigned
9449 simple_type_align_in_bits (tree type)
9450 {
9451   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9452 }
9453
9454 static inline unsigned
9455 simple_decl_align_in_bits (tree decl)
9456 {
9457   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9458 }
9459
9460 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9461    lowest addressed byte of the "containing object" for the given FIELD_DECL,
9462    or return 0 if we are unable to determine what that offset is, either
9463    because the argument turns out to be a pointer to an ERROR_MARK node, or
9464    because the offset is actually variable.  (We can't handle the latter case
9465    just yet).  */
9466
9467 static HOST_WIDE_INT
9468 field_byte_offset (tree decl)
9469 {
9470   unsigned int type_align_in_bits;
9471   unsigned int decl_align_in_bits;
9472   unsigned HOST_WIDE_INT type_size_in_bits;
9473   HOST_WIDE_INT object_offset_in_bits;
9474   tree type;
9475   tree field_size_tree;
9476   HOST_WIDE_INT bitpos_int;
9477   HOST_WIDE_INT deepest_bitpos;
9478   unsigned HOST_WIDE_INT field_size_in_bits;
9479
9480   if (TREE_CODE (decl) == ERROR_MARK)
9481     return 0;
9482
9483   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9484
9485   type = field_type (decl);
9486   field_size_tree = DECL_SIZE (decl);
9487
9488   /* The size could be unspecified if there was an error, or for
9489      a flexible array member.  */
9490   if (! field_size_tree)
9491     field_size_tree = bitsize_zero_node;
9492
9493   /* We cannot yet cope with fields whose positions are variable, so
9494      for now, when we see such things, we simply return 0.  Someday, we may
9495      be able to handle such cases, but it will be damn difficult.  */
9496   if (! host_integerp (bit_position (decl), 0))
9497     return 0;
9498
9499   bitpos_int = int_bit_position (decl);
9500
9501   /* If we don't know the size of the field, pretend it's a full word.  */
9502   if (host_integerp (field_size_tree, 1))
9503     field_size_in_bits = tree_low_cst (field_size_tree, 1);
9504   else
9505     field_size_in_bits = BITS_PER_WORD;
9506
9507   type_size_in_bits = simple_type_size_in_bits (type);
9508   type_align_in_bits = simple_type_align_in_bits (type);
9509   decl_align_in_bits = simple_decl_align_in_bits (decl);
9510
9511   /* The GCC front-end doesn't make any attempt to keep track of the starting
9512      bit offset (relative to the start of the containing structure type) of the
9513      hypothetical "containing object" for a bit-field.  Thus, when computing
9514      the byte offset value for the start of the "containing object" of a
9515      bit-field, we must deduce this information on our own. This can be rather
9516      tricky to do in some cases.  For example, handling the following structure
9517      type definition when compiling for an i386/i486 target (which only aligns
9518      long long's to 32-bit boundaries) can be very tricky:
9519
9520          struct S { int field1; long long field2:31; };
9521
9522      Fortunately, there is a simple rule-of-thumb which can be used in such
9523      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
9524      structure shown above.  It decides to do this based upon one simple rule
9525      for bit-field allocation.  GCC allocates each "containing object" for each
9526      bit-field at the first (i.e. lowest addressed) legitimate alignment
9527      boundary (based upon the required minimum alignment for the declared type
9528      of the field) which it can possibly use, subject to the condition that
9529      there is still enough available space remaining in the containing object
9530      (when allocated at the selected point) to fully accommodate all of the
9531      bits of the bit-field itself.
9532
9533      This simple rule makes it obvious why GCC allocates 8 bytes for each
9534      object of the structure type shown above.  When looking for a place to
9535      allocate the "containing object" for `field2', the compiler simply tries
9536      to allocate a 64-bit "containing object" at each successive 32-bit
9537      boundary (starting at zero) until it finds a place to allocate that 64-
9538      bit field such that at least 31 contiguous (and previously unallocated)
9539      bits remain within that selected 64 bit field.  (As it turns out, for the
9540      example above, the compiler finds it is OK to allocate the "containing
9541      object" 64-bit field at bit-offset zero within the structure type.)
9542
9543      Here we attempt to work backwards from the limited set of facts we're
9544      given, and we try to deduce from those facts, where GCC must have believed
9545      that the containing object started (within the structure type). The value
9546      we deduce is then used (by the callers of this routine) to generate
9547      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9548      and, in the case of DW_AT_location, regular fields as well).  */
9549
9550   /* Figure out the bit-distance from the start of the structure to the
9551      "deepest" bit of the bit-field.  */
9552   deepest_bitpos = bitpos_int + field_size_in_bits;
9553
9554   /* This is the tricky part.  Use some fancy footwork to deduce where the
9555      lowest addressed bit of the containing object must be.  */
9556   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9557
9558   /* Round up to type_align by default.  This works best for bitfields.  */
9559   object_offset_in_bits += type_align_in_bits - 1;
9560   object_offset_in_bits /= type_align_in_bits;
9561   object_offset_in_bits *= type_align_in_bits;
9562
9563   if (object_offset_in_bits > bitpos_int)
9564     {
9565       /* Sigh, the decl must be packed.  */
9566       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9567
9568       /* Round up to decl_align instead.  */
9569       object_offset_in_bits += decl_align_in_bits - 1;
9570       object_offset_in_bits /= decl_align_in_bits;
9571       object_offset_in_bits *= decl_align_in_bits;
9572     }
9573
9574   return object_offset_in_bits / BITS_PER_UNIT;
9575 }
9576 \f
9577 /* The following routines define various Dwarf attributes and any data
9578    associated with them.  */
9579
9580 /* Add a location description attribute value to a DIE.
9581
9582    This emits location attributes suitable for whole variables and
9583    whole parameters.  Note that the location attributes for struct fields are
9584    generated by the routine `data_member_location_attribute' below.  */
9585
9586 static inline void
9587 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9588                              dw_loc_descr_ref descr)
9589 {
9590   if (descr != 0)
9591     add_AT_loc (die, attr_kind, descr);
9592 }
9593
9594 /* Attach the specialized form of location attribute used for data members of
9595    struct and union types.  In the special case of a FIELD_DECL node which
9596    represents a bit-field, the "offset" part of this special location
9597    descriptor must indicate the distance in bytes from the lowest-addressed
9598    byte of the containing struct or union type to the lowest-addressed byte of
9599    the "containing object" for the bit-field.  (See the `field_byte_offset'
9600    function above).
9601
9602    For any given bit-field, the "containing object" is a hypothetical object
9603    (of some integral or enum type) within which the given bit-field lives.  The
9604    type of this hypothetical "containing object" is always the same as the
9605    declared type of the individual bit-field itself (for GCC anyway... the
9606    DWARF spec doesn't actually mandate this).  Note that it is the size (in
9607    bytes) of the hypothetical "containing object" which will be given in the
9608    DW_AT_byte_size attribute for this bit-field.  (See the
9609    `byte_size_attribute' function below.)  It is also used when calculating the
9610    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
9611    function below.)  */
9612
9613 static void
9614 add_data_member_location_attribute (dw_die_ref die, tree decl)
9615 {
9616   HOST_WIDE_INT offset;
9617   dw_loc_descr_ref loc_descr = 0;
9618
9619   if (TREE_CODE (decl) == TREE_BINFO)
9620     {
9621       /* We're working on the TAG_inheritance for a base class.  */
9622       if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9623         {
9624           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9625              aren't at a fixed offset from all (sub)objects of the same
9626              type.  We need to extract the appropriate offset from our
9627              vtable.  The following dwarf expression means
9628
9629                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9630
9631              This is specific to the V3 ABI, of course.  */
9632
9633           dw_loc_descr_ref tmp;
9634
9635           /* Make a copy of the object address.  */
9636           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9637           add_loc_descr (&loc_descr, tmp);
9638
9639           /* Extract the vtable address.  */
9640           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9641           add_loc_descr (&loc_descr, tmp);
9642
9643           /* Calculate the address of the offset.  */
9644           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9645           gcc_assert (offset < 0);
9646
9647           tmp = int_loc_descriptor (-offset);
9648           add_loc_descr (&loc_descr, tmp);
9649           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9650           add_loc_descr (&loc_descr, tmp);
9651
9652           /* Extract the offset.  */
9653           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9654           add_loc_descr (&loc_descr, tmp);
9655
9656           /* Add it to the object address.  */
9657           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9658           add_loc_descr (&loc_descr, tmp);
9659         }
9660       else
9661         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9662     }
9663   else
9664     offset = field_byte_offset (decl);
9665
9666   if (! loc_descr)
9667     {
9668       enum dwarf_location_atom op;
9669
9670       /* The DWARF2 standard says that we should assume that the structure
9671          address is already on the stack, so we can specify a structure field
9672          address by using DW_OP_plus_uconst.  */
9673
9674 #ifdef MIPS_DEBUGGING_INFO
9675       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9676          operator correctly.  It works only if we leave the offset on the
9677          stack.  */
9678       op = DW_OP_constu;
9679 #else
9680       op = DW_OP_plus_uconst;
9681 #endif
9682
9683       loc_descr = new_loc_descr (op, offset, 0);
9684     }
9685
9686   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9687 }
9688
9689 /* Writes integer values to dw_vec_const array.  */
9690
9691 static void
9692 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9693 {
9694   while (size != 0)
9695     {
9696       *dest++ = val & 0xff;
9697       val >>= 8;
9698       --size;
9699     }
9700 }
9701
9702 /* Reads integers from dw_vec_const array.  Inverse of insert_int.  */
9703
9704 static HOST_WIDE_INT
9705 extract_int (const unsigned char *src, unsigned int size)
9706 {
9707   HOST_WIDE_INT val = 0;
9708
9709   src += size;
9710   while (size != 0)
9711     {
9712       val <<= 8;
9713       val |= *--src & 0xff;
9714       --size;
9715     }
9716   return val;
9717 }
9718
9719 /* Writes floating point values to dw_vec_const array.  */
9720
9721 static void
9722 insert_float (rtx rtl, unsigned char *array)
9723 {
9724   REAL_VALUE_TYPE rv;
9725   long val[4];
9726   int i;
9727
9728   REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9729   real_to_target (val, &rv, GET_MODE (rtl));
9730
9731   /* real_to_target puts 32-bit pieces in each long.  Pack them.  */
9732   for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9733     {
9734       insert_int (val[i], 4, array);
9735       array += 4;
9736     }
9737 }
9738
9739 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9740    does not have a "location" either in memory or in a register.  These
9741    things can arise in GNU C when a constant is passed as an actual parameter
9742    to an inlined function.  They can also arise in C++ where declared
9743    constants do not necessarily get memory "homes".  */
9744
9745 static void
9746 add_const_value_attribute (dw_die_ref die, rtx rtl)
9747 {
9748   switch (GET_CODE (rtl))
9749     {
9750     case CONST_INT:
9751       {
9752         HOST_WIDE_INT val = INTVAL (rtl);
9753
9754         if (val < 0)
9755           add_AT_int (die, DW_AT_const_value, val);
9756         else
9757           add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9758       }
9759       break;
9760
9761     case CONST_DOUBLE:
9762       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9763          floating-point constant.  A CONST_DOUBLE is used whenever the
9764          constant requires more than one word in order to be adequately
9765          represented.  We output CONST_DOUBLEs as blocks.  */
9766       {
9767         enum machine_mode mode = GET_MODE (rtl);
9768
9769         if (SCALAR_FLOAT_MODE_P (mode))
9770           {
9771             unsigned int length = GET_MODE_SIZE (mode);
9772             unsigned char *array = ggc_alloc (length);
9773
9774             insert_float (rtl, array);
9775             add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9776           }
9777         else
9778           {
9779             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9780             gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9781
9782             add_AT_long_long (die, DW_AT_const_value,
9783                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9784           }
9785       }
9786       break;
9787
9788     case CONST_VECTOR:
9789       {
9790         enum machine_mode mode = GET_MODE (rtl);
9791         unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9792         unsigned int length = CONST_VECTOR_NUNITS (rtl);
9793         unsigned char *array = ggc_alloc (length * elt_size);
9794         unsigned int i;
9795         unsigned char *p;
9796
9797         switch (GET_MODE_CLASS (mode))
9798           {
9799           case MODE_VECTOR_INT:
9800             for (i = 0, p = array; i < length; i++, p += elt_size)
9801               {
9802                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9803                 HOST_WIDE_INT lo, hi;
9804
9805                 switch (GET_CODE (elt))
9806                   {
9807                   case CONST_INT:
9808                     lo = INTVAL (elt);
9809                     hi = -(lo < 0);
9810                     break;
9811
9812                   case CONST_DOUBLE:
9813                     lo = CONST_DOUBLE_LOW (elt);
9814                     hi = CONST_DOUBLE_HIGH (elt);
9815                     break;
9816
9817                   default:
9818                     gcc_unreachable ();
9819                   }
9820
9821                 if (elt_size <= sizeof (HOST_WIDE_INT))
9822                   insert_int (lo, elt_size, p);
9823                 else
9824                   {
9825                     unsigned char *p0 = p;
9826                     unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9827
9828                     gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9829                     if (WORDS_BIG_ENDIAN)
9830                       {
9831                         p0 = p1;
9832                         p1 = p;
9833                       }
9834                     insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9835                     insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9836                   }
9837               }
9838             break;
9839
9840           case MODE_VECTOR_FLOAT:
9841             for (i = 0, p = array; i < length; i++, p += elt_size)
9842               {
9843                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9844                 insert_float (elt, p);
9845               }
9846             break;
9847
9848           default:
9849             gcc_unreachable ();
9850           }
9851
9852         add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
9853       }
9854       break;
9855
9856     case CONST_STRING:
9857       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9858       break;
9859
9860     case SYMBOL_REF:
9861     case LABEL_REF:
9862     case CONST:
9863       add_AT_addr (die, DW_AT_const_value, rtl);
9864       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
9865       break;
9866
9867     case PLUS:
9868       /* In cases where an inlined instance of an inline function is passed
9869          the address of an `auto' variable (which is local to the caller) we
9870          can get a situation where the DECL_RTL of the artificial local
9871          variable (for the inlining) which acts as a stand-in for the
9872          corresponding formal parameter (of the inline function) will look
9873          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
9874          exactly a compile-time constant expression, but it isn't the address
9875          of the (artificial) local variable either.  Rather, it represents the
9876          *value* which the artificial local variable always has during its
9877          lifetime.  We currently have no way to represent such quasi-constant
9878          values in Dwarf, so for now we just punt and generate nothing.  */
9879       break;
9880
9881     default:
9882       /* No other kinds of rtx should be possible here.  */
9883       gcc_unreachable ();
9884     }
9885
9886 }
9887
9888 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
9889    for use in a later add_const_value_attribute call.  */
9890
9891 static rtx
9892 rtl_for_decl_init (tree init, tree type)
9893 {
9894   rtx rtl = NULL_RTX;
9895
9896   /* If a variable is initialized with a string constant without embedded
9897      zeros, build CONST_STRING.  */
9898   if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
9899     {
9900       tree enttype = TREE_TYPE (type);
9901       tree domain = TYPE_DOMAIN (type);
9902       enum machine_mode mode = TYPE_MODE (enttype);
9903
9904       if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9905           && domain
9906           && integer_zerop (TYPE_MIN_VALUE (domain))
9907           && compare_tree_int (TYPE_MAX_VALUE (domain),
9908                                TREE_STRING_LENGTH (init) - 1) == 0
9909           && ((size_t) TREE_STRING_LENGTH (init)
9910               == strlen (TREE_STRING_POINTER (init)) + 1))
9911         rtl = gen_rtx_CONST_STRING (VOIDmode,
9912                                     ggc_strdup (TREE_STRING_POINTER (init)));
9913     }
9914   /* If the initializer is something that we know will expand into an
9915      immediate RTL constant, expand it now.  Expanding anything else
9916      tends to produce unresolved symbols; see debug/5770 and c++/6381.  */
9917   /* Aggregate, vector, and complex types may contain constructors that may
9918      result in code being generated when expand_expr is called, so we can't
9919      handle them here.  Integer and float are useful and safe types to handle
9920      here.  */
9921   else if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
9922            && initializer_constant_valid_p (init, type) == null_pointer_node)
9923     {
9924       rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
9925
9926       /* If expand_expr returns a MEM, it wasn't immediate.  */
9927       gcc_assert (!rtl || !MEM_P (rtl));
9928     }
9929
9930   return rtl;
9931 }
9932
9933 /* Generate RTL for the variable DECL to represent its location.  */
9934
9935 static rtx
9936 rtl_for_decl_location (tree decl)
9937 {
9938   rtx rtl;
9939
9940   /* Here we have to decide where we are going to say the parameter "lives"
9941      (as far as the debugger is concerned).  We only have a couple of
9942      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9943
9944      DECL_RTL normally indicates where the parameter lives during most of the
9945      activation of the function.  If optimization is enabled however, this
9946      could be either NULL or else a pseudo-reg.  Both of those cases indicate
9947      that the parameter doesn't really live anywhere (as far as the code
9948      generation parts of GCC are concerned) during most of the function's
9949      activation.  That will happen (for example) if the parameter is never
9950      referenced within the function.
9951
9952      We could just generate a location descriptor here for all non-NULL
9953      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9954      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9955      where DECL_RTL is NULL or is a pseudo-reg.
9956
9957      Note however that we can only get away with using DECL_INCOMING_RTL as
9958      a backup substitute for DECL_RTL in certain limited cases.  In cases
9959      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9960      we can be sure that the parameter was passed using the same type as it is
9961      declared to have within the function, and that its DECL_INCOMING_RTL
9962      points us to a place where a value of that type is passed.
9963
9964      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9965      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9966      because in these cases DECL_INCOMING_RTL points us to a value of some
9967      type which is *different* from the type of the parameter itself.  Thus,
9968      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9969      such cases, the debugger would end up (for example) trying to fetch a
9970      `float' from a place which actually contains the first part of a
9971      `double'.  That would lead to really incorrect and confusing
9972      output at debug-time.
9973
9974      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9975      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
9976      are a couple of exceptions however.  On little-endian machines we can
9977      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9978      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9979      an integral type that is smaller than TREE_TYPE (decl). These cases arise
9980      when (on a little-endian machine) a non-prototyped function has a
9981      parameter declared to be of type `short' or `char'.  In such cases,
9982      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9983      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9984      passed `int' value.  If the debugger then uses that address to fetch
9985      a `short' or a `char' (on a little-endian machine) the result will be
9986      the correct data, so we allow for such exceptional cases below.
9987
9988      Note that our goal here is to describe the place where the given formal
9989      parameter lives during most of the function's activation (i.e. between the
9990      end of the prologue and the start of the epilogue).  We'll do that as best
9991      as we can. Note however that if the given formal parameter is modified
9992      sometime during the execution of the function, then a stack backtrace (at
9993      debug-time) will show the function as having been called with the *new*
9994      value rather than the value which was originally passed in.  This happens
9995      rarely enough that it is not a major problem, but it *is* a problem, and
9996      I'd like to fix it.
9997
9998      A future version of dwarf2out.c may generate two additional attributes for
9999      any given DW_TAG_formal_parameter DIE which will describe the "passed
10000      type" and the "passed location" for the given formal parameter in addition
10001      to the attributes we now generate to indicate the "declared type" and the
10002      "active location" for each parameter.  This additional set of attributes
10003      could be used by debuggers for stack backtraces. Separately, note that
10004      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10005      This happens (for example) for inlined-instances of inline function formal
10006      parameters which are never referenced.  This really shouldn't be
10007      happening.  All PARM_DECL nodes should get valid non-NULL
10008      DECL_INCOMING_RTL values.  FIXME.  */
10009
10010   /* Use DECL_RTL as the "location" unless we find something better.  */
10011   rtl = DECL_RTL_IF_SET (decl);
10012
10013   /* When generating abstract instances, ignore everything except
10014      constants, symbols living in memory, and symbols living in
10015      fixed registers.  */
10016   if (! reload_completed)
10017     {
10018       if (rtl
10019           && (CONSTANT_P (rtl)
10020               || (MEM_P (rtl)
10021                   && CONSTANT_P (XEXP (rtl, 0)))
10022               || (REG_P (rtl)
10023                   && TREE_CODE (decl) == VAR_DECL
10024                   && TREE_STATIC (decl))))
10025         {
10026           rtl = targetm.delegitimize_address (rtl);
10027           return rtl;
10028         }
10029       rtl = NULL_RTX;
10030     }
10031   else if (TREE_CODE (decl) == PARM_DECL)
10032     {
10033       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10034         {
10035           tree declared_type = TREE_TYPE (decl);
10036           tree passed_type = DECL_ARG_TYPE (decl);
10037           enum machine_mode dmode = TYPE_MODE (declared_type);
10038           enum machine_mode pmode = TYPE_MODE (passed_type);
10039
10040           /* This decl represents a formal parameter which was optimized out.
10041              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10042              all cases where (rtl == NULL_RTX) just below.  */
10043           if (dmode == pmode)
10044             rtl = DECL_INCOMING_RTL (decl);
10045           else if (SCALAR_INT_MODE_P (dmode)
10046                    && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10047                    && DECL_INCOMING_RTL (decl))
10048             {
10049               rtx inc = DECL_INCOMING_RTL (decl);
10050               if (REG_P (inc))
10051                 rtl = inc;
10052               else if (MEM_P (inc))
10053                 {
10054                   if (BYTES_BIG_ENDIAN)
10055                     rtl = adjust_address_nv (inc, dmode,
10056                                              GET_MODE_SIZE (pmode)
10057                                              - GET_MODE_SIZE (dmode));
10058                   else
10059                     rtl = inc;
10060                 }
10061             }
10062         }
10063
10064       /* If the parm was passed in registers, but lives on the stack, then
10065          make a big endian correction if the mode of the type of the
10066          parameter is not the same as the mode of the rtl.  */
10067       /* ??? This is the same series of checks that are made in dbxout.c before
10068          we reach the big endian correction code there.  It isn't clear if all
10069          of these checks are necessary here, but keeping them all is the safe
10070          thing to do.  */
10071       else if (MEM_P (rtl)
10072                && XEXP (rtl, 0) != const0_rtx
10073                && ! CONSTANT_P (XEXP (rtl, 0))
10074                /* Not passed in memory.  */
10075                && !MEM_P (DECL_INCOMING_RTL (decl))
10076                /* Not passed by invisible reference.  */
10077                && (!REG_P (XEXP (rtl, 0))
10078                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10079                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10080 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10081                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10082 #endif
10083                      )
10084                /* Big endian correction check.  */
10085                && BYTES_BIG_ENDIAN
10086                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10087                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10088                    < UNITS_PER_WORD))
10089         {
10090           int offset = (UNITS_PER_WORD
10091                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10092
10093           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10094                              plus_constant (XEXP (rtl, 0), offset));
10095         }
10096     }
10097   else if (TREE_CODE (decl) == VAR_DECL
10098            && rtl
10099            && MEM_P (rtl)
10100            && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10101            && BYTES_BIG_ENDIAN)
10102     {
10103       int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10104       int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10105
10106       /* If a variable is declared "register" yet is smaller than
10107          a register, then if we store the variable to memory, it
10108          looks like we're storing a register-sized value, when in
10109          fact we are not.  We need to adjust the offset of the
10110          storage location to reflect the actual value's bytes,
10111          else gdb will not be able to display it.  */
10112       if (rsize > dsize)
10113         rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10114                            plus_constant (XEXP (rtl, 0), rsize-dsize));
10115     }
10116
10117   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10118      and will have been substituted directly into all expressions that use it.
10119      C does not have such a concept, but C++ and other languages do.  */
10120   if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10121     rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10122
10123   if (rtl)
10124     rtl = targetm.delegitimize_address (rtl);
10125
10126   /* If we don't look past the constant pool, we risk emitting a
10127      reference to a constant pool entry that isn't referenced from
10128      code, and thus is not emitted.  */
10129   if (rtl)
10130     rtl = avoid_constant_pool_reference (rtl);
10131
10132   return rtl;
10133 }
10134
10135 /* We need to figure out what section we should use as the base for the
10136    address ranges where a given location is valid.
10137    1. If this particular DECL has a section associated with it, use that.
10138    2. If this function has a section associated with it, use that.
10139    3. Otherwise, use the text section.
10140    XXX: If you split a variable across multiple sections, we won't notice.  */
10141
10142 static const char *
10143 secname_for_decl (tree decl)
10144 {
10145   const char *secname;
10146
10147   if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10148     {
10149       tree sectree = DECL_SECTION_NAME (decl);
10150       secname = TREE_STRING_POINTER (sectree);
10151     }
10152   else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10153     {
10154       tree sectree = DECL_SECTION_NAME (current_function_decl);
10155       secname = TREE_STRING_POINTER (sectree);
10156     }
10157   else if (cfun && in_cold_section_p)
10158     secname = cfun->cold_section_label;
10159   else
10160     secname = text_section_label;
10161
10162   return secname;
10163 }
10164
10165 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10166    data attribute for a variable or a parameter.  We generate the
10167    DW_AT_const_value attribute only in those cases where the given variable
10168    or parameter does not have a true "location" either in memory or in a
10169    register.  This can happen (for example) when a constant is passed as an
10170    actual argument in a call to an inline function.  (It's possible that
10171    these things can crop up in other ways also.)  Note that one type of
10172    constant value which can be passed into an inlined function is a constant
10173    pointer.  This can happen for example if an actual argument in an inlined
10174    function call evaluates to a compile-time constant address.  */
10175
10176 static void
10177 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10178                                        enum dwarf_attribute attr)
10179 {
10180   rtx rtl;
10181   dw_loc_descr_ref descr;
10182   var_loc_list *loc_list;
10183   struct var_loc_node *node;
10184   if (TREE_CODE (decl) == ERROR_MARK)
10185     return;
10186
10187   gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10188               || TREE_CODE (decl) == RESULT_DECL);
10189
10190   /* See if we possibly have multiple locations for this variable.  */
10191   loc_list = lookup_decl_loc (decl);
10192
10193   /* If it truly has multiple locations, the first and last node will
10194      differ.  */
10195   if (loc_list && loc_list->first != loc_list->last)
10196     {
10197       const char *endname, *secname;
10198       dw_loc_list_ref list;
10199       rtx varloc;
10200
10201       /* Now that we know what section we are using for a base,
10202          actually construct the list of locations.
10203          The first location information is what is passed to the
10204          function that creates the location list, and the remaining
10205          locations just get added on to that list.
10206          Note that we only know the start address for a location
10207          (IE location changes), so to build the range, we use
10208          the range [current location start, next location start].
10209          This means we have to special case the last node, and generate
10210          a range of [last location start, end of function label].  */
10211
10212       node = loc_list->first;
10213       varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10214       secname = secname_for_decl (decl);
10215
10216       list = new_loc_list (loc_descriptor (varloc),
10217                            node->label, node->next->label, secname, 1);
10218       node = node->next;
10219
10220       for (; node->next; node = node->next)
10221         if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10222           {
10223             /* The variable has a location between NODE->LABEL and
10224                NODE->NEXT->LABEL.  */
10225             varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10226             add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10227                                        node->label, node->next->label, secname);
10228           }
10229
10230       /* If the variable has a location at the last label
10231          it keeps its location until the end of function.  */
10232       if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10233         {
10234           char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10235
10236           varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10237           if (!current_function_decl)
10238             endname = text_end_label;
10239           else
10240             {
10241               ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10242                                            current_function_funcdef_no);
10243               endname = ggc_strdup (label_id);
10244             }
10245           add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10246                                      node->label, endname, secname);
10247         }
10248
10249       /* Finally, add the location list to the DIE, and we are done.  */
10250       add_AT_loc_list (die, attr, list);
10251       return;
10252     }
10253
10254   /* Try to get some constant RTL for this decl, and use that as the value of
10255      the location.  */
10256
10257   rtl = rtl_for_decl_location (decl);
10258   if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10259     {
10260       add_const_value_attribute (die, rtl);
10261       return;
10262     }
10263
10264   /* If we have tried to generate the location otherwise, and it
10265      didn't work out (we wouldn't be here if we did), and we have a one entry
10266      location list, try generating a location from that.  */
10267   if (loc_list && loc_list->first)
10268     {
10269       node = loc_list->first;
10270       descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10271       if (descr)
10272         {
10273           add_AT_location_description (die, attr, descr);
10274           return;
10275         }
10276     }
10277
10278   /* We couldn't get any rtl, so try directly generating the location
10279      description from the tree.  */
10280   descr = loc_descriptor_from_tree (decl);
10281   if (descr)
10282     {
10283       add_AT_location_description (die, attr, descr);
10284       return;
10285     }
10286 }
10287
10288 /* If we don't have a copy of this variable in memory for some reason (such
10289    as a C++ member constant that doesn't have an out-of-line definition),
10290    we should tell the debugger about the constant value.  */
10291
10292 static void
10293 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10294 {
10295   tree init = DECL_INITIAL (decl);
10296   tree type = TREE_TYPE (decl);
10297   rtx rtl;
10298
10299   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10300     /* OK */;
10301   else
10302     return;
10303
10304   rtl = rtl_for_decl_init (init, type);
10305   if (rtl)
10306     add_const_value_attribute (var_die, rtl);
10307 }
10308
10309 /* Convert the CFI instructions for the current function into a
10310    location list.  This is used for DW_AT_frame_base when we targeting
10311    a dwarf2 consumer that does not support the dwarf3
10312    DW_OP_call_frame_cfa.  OFFSET is a constant to be added to all CFA
10313    expressions.  */
10314
10315 static dw_loc_list_ref
10316 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10317 {
10318   dw_fde_ref fde;
10319   dw_loc_list_ref list, *list_tail;
10320   dw_cfi_ref cfi;
10321   dw_cfa_location last_cfa, next_cfa;
10322   const char *start_label, *last_label, *section;
10323
10324   fde = &fde_table[fde_table_in_use - 1];
10325
10326   section = secname_for_decl (current_function_decl);
10327   list_tail = &list;
10328   list = NULL;
10329
10330   next_cfa.reg = INVALID_REGNUM;
10331   next_cfa.offset = 0;
10332   next_cfa.indirect = 0;
10333   next_cfa.base_offset = 0;
10334
10335   start_label = fde->dw_fde_begin;
10336
10337   /* ??? Bald assumption that the CIE opcode list does not contain
10338      advance opcodes.  */
10339   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10340     lookup_cfa_1 (cfi, &next_cfa);
10341
10342   last_cfa = next_cfa;
10343   last_label = start_label;
10344
10345   for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10346     switch (cfi->dw_cfi_opc)
10347       {
10348       case DW_CFA_advance_loc1:
10349       case DW_CFA_advance_loc2:
10350       case DW_CFA_advance_loc4:
10351         if (!cfa_equal_p (&last_cfa, &next_cfa))
10352           {
10353             *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10354                                        start_label, last_label, section,
10355                                        list == NULL);
10356
10357             list_tail = &(*list_tail)->dw_loc_next;
10358             last_cfa = next_cfa;
10359             start_label = last_label;
10360           }
10361         last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10362         break;
10363
10364       case DW_CFA_advance_loc:
10365         /* The encoding is complex enough that we should never emit this.  */
10366       case DW_CFA_remember_state:
10367       case DW_CFA_restore_state:
10368         /* We don't handle these two in this function.  It would be possible
10369            if it were to be required.  */
10370         gcc_unreachable ();
10371
10372       default:
10373         lookup_cfa_1 (cfi, &next_cfa);
10374         break;
10375       }
10376
10377   if (!cfa_equal_p (&last_cfa, &next_cfa))
10378     {
10379       *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10380                                  start_label, last_label, section,
10381                                  list == NULL);
10382       list_tail = &(*list_tail)->dw_loc_next;
10383       start_label = last_label;
10384     }
10385   *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10386                              start_label, fde->dw_fde_end, section,
10387                              list == NULL);
10388
10389   return list;
10390 }
10391
10392 /* Compute a displacement from the "steady-state frame pointer" to the
10393    frame base (often the same as the CFA), and store it in
10394    frame_pointer_fb_offset.  OFFSET is added to the displacement
10395    before the latter is negated.  */
10396
10397 static void
10398 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10399 {
10400   rtx reg, elim;
10401
10402 #ifdef FRAME_POINTER_CFA_OFFSET
10403   reg = frame_pointer_rtx;
10404   offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10405 #else
10406   reg = arg_pointer_rtx;
10407   offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10408 #endif
10409
10410   elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10411   if (GET_CODE (elim) == PLUS)
10412     {
10413       offset += INTVAL (XEXP (elim, 1));
10414       elim = XEXP (elim, 0);
10415     }
10416   gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10417                        : stack_pointer_rtx));
10418
10419   frame_pointer_fb_offset = -offset;
10420 }
10421
10422 /* Generate a DW_AT_name attribute given some string value to be included as
10423    the value of the attribute.  */
10424
10425 static void
10426 add_name_attribute (dw_die_ref die, const char *name_string)
10427 {
10428   if (name_string != NULL && *name_string != 0)
10429     {
10430       if (demangle_name_func)
10431         name_string = (*demangle_name_func) (name_string);
10432
10433       add_AT_string (die, DW_AT_name, name_string);
10434     }
10435 }
10436
10437 /* Generate a DW_AT_comp_dir attribute for DIE.  */
10438
10439 static void
10440 add_comp_dir_attribute (dw_die_ref die)
10441 {
10442   const char *wd = get_src_pwd ();
10443   if (wd != NULL)
10444     add_AT_string (die, DW_AT_comp_dir, wd);
10445 }
10446
10447 /* Given a tree node describing an array bound (either lower or upper) output
10448    a representation for that bound.  */
10449
10450 static void
10451 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10452 {
10453   switch (TREE_CODE (bound))
10454     {
10455     case ERROR_MARK:
10456       return;
10457
10458     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
10459     case INTEGER_CST:
10460       if (! host_integerp (bound, 0)
10461           || (bound_attr == DW_AT_lower_bound
10462               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
10463                   || (is_fortran () && integer_onep (bound)))))
10464         /* Use the default.  */
10465         ;
10466       else
10467         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10468       break;
10469
10470     case CONVERT_EXPR:
10471     case NOP_EXPR:
10472     case NON_LVALUE_EXPR:
10473     case VIEW_CONVERT_EXPR:
10474       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10475       break;
10476
10477     case SAVE_EXPR:
10478       break;
10479
10480     case VAR_DECL:
10481     case PARM_DECL:
10482     case RESULT_DECL:
10483       {
10484         dw_die_ref decl_die = lookup_decl_die (bound);
10485
10486         /* ??? Can this happen, or should the variable have been bound
10487            first?  Probably it can, since I imagine that we try to create
10488            the types of parameters in the order in which they exist in
10489            the list, and won't have created a forward reference to a
10490            later parameter.  */
10491         if (decl_die != NULL)
10492           add_AT_die_ref (subrange_die, bound_attr, decl_die);
10493         break;
10494       }
10495
10496     default:
10497       {
10498         /* Otherwise try to create a stack operation procedure to
10499            evaluate the value of the array bound.  */
10500
10501         dw_die_ref ctx, decl_die;
10502         dw_loc_descr_ref loc;
10503
10504         loc = loc_descriptor_from_tree (bound);
10505         if (loc == NULL)
10506           break;
10507
10508         if (current_function_decl == 0)
10509           ctx = comp_unit_die;
10510         else
10511           ctx = lookup_decl_die (current_function_decl);
10512
10513         decl_die = new_die (DW_TAG_variable, ctx, bound);
10514         add_AT_flag (decl_die, DW_AT_artificial, 1);
10515         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10516         add_AT_loc (decl_die, DW_AT_location, loc);
10517
10518         add_AT_die_ref (subrange_die, bound_attr, decl_die);
10519         break;
10520       }
10521     }
10522 }
10523
10524 /* Note that the block of subscript information for an array type also
10525    includes information about the element type of type given array type.  */
10526
10527 static void
10528 add_subscript_info (dw_die_ref type_die, tree type)
10529 {
10530 #ifndef MIPS_DEBUGGING_INFO
10531   unsigned dimension_number;
10532 #endif
10533   tree lower, upper;
10534   dw_die_ref subrange_die;
10535
10536   /* The GNU compilers represent multidimensional array types as sequences of
10537      one dimensional array types whose element types are themselves array
10538      types.  Here we squish that down, so that each multidimensional array
10539      type gets only one array_type DIE in the Dwarf debugging info. The draft
10540      Dwarf specification say that we are allowed to do this kind of
10541      compression in C (because there is no difference between an array or
10542      arrays and a multidimensional array in C) but for other source languages
10543      (e.g. Ada) we probably shouldn't do this.  */
10544
10545   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10546      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10547      We work around this by disabling this feature.  See also
10548      gen_array_type_die.  */
10549 #ifndef MIPS_DEBUGGING_INFO
10550   for (dimension_number = 0;
10551        TREE_CODE (type) == ARRAY_TYPE;
10552        type = TREE_TYPE (type), dimension_number++)
10553 #endif
10554     {
10555       tree domain = TYPE_DOMAIN (type);
10556
10557       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10558          and (in GNU C only) variable bounds.  Handle all three forms
10559          here.  */
10560       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10561       if (domain)
10562         {
10563           /* We have an array type with specified bounds.  */
10564           lower = TYPE_MIN_VALUE (domain);
10565           upper = TYPE_MAX_VALUE (domain);
10566
10567           /* Define the index type.  */
10568           if (TREE_TYPE (domain))
10569             {
10570               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
10571                  TREE_TYPE field.  We can't emit debug info for this
10572                  because it is an unnamed integral type.  */
10573               if (TREE_CODE (domain) == INTEGER_TYPE
10574                   && TYPE_NAME (domain) == NULL_TREE
10575                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10576                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10577                 ;
10578               else
10579                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10580                                     type_die);
10581             }
10582
10583           /* ??? If upper is NULL, the array has unspecified length,
10584              but it does have a lower bound.  This happens with Fortran
10585                dimension arr(N:*)
10586              Since the debugger is definitely going to need to know N
10587              to produce useful results, go ahead and output the lower
10588              bound solo, and hope the debugger can cope.  */
10589
10590           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10591           if (upper)
10592             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10593         }
10594
10595       /* Otherwise we have an array type with an unspecified length.  The
10596          DWARF-2 spec does not say how to handle this; let's just leave out the
10597          bounds.  */
10598     }
10599 }
10600
10601 static void
10602 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10603 {
10604   unsigned size;
10605
10606   switch (TREE_CODE (tree_node))
10607     {
10608     case ERROR_MARK:
10609       size = 0;
10610       break;
10611     case ENUMERAL_TYPE:
10612     case RECORD_TYPE:
10613     case UNION_TYPE:
10614     case QUAL_UNION_TYPE:
10615       size = int_size_in_bytes (tree_node);
10616       break;
10617     case FIELD_DECL:
10618       /* For a data member of a struct or union, the DW_AT_byte_size is
10619          generally given as the number of bytes normally allocated for an
10620          object of the *declared* type of the member itself.  This is true
10621          even for bit-fields.  */
10622       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10623       break;
10624     default:
10625       gcc_unreachable ();
10626     }
10627
10628   /* Note that `size' might be -1 when we get to this point.  If it is, that
10629      indicates that the byte size of the entity in question is variable.  We
10630      have no good way of expressing this fact in Dwarf at the present time,
10631      so just let the -1 pass on through.  */
10632   add_AT_unsigned (die, DW_AT_byte_size, size);
10633 }
10634
10635 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10636    which specifies the distance in bits from the highest order bit of the
10637    "containing object" for the bit-field to the highest order bit of the
10638    bit-field itself.
10639
10640    For any given bit-field, the "containing object" is a hypothetical object
10641    (of some integral or enum type) within which the given bit-field lives.  The
10642    type of this hypothetical "containing object" is always the same as the
10643    declared type of the individual bit-field itself.  The determination of the
10644    exact location of the "containing object" for a bit-field is rather
10645    complicated.  It's handled by the `field_byte_offset' function (above).
10646
10647    Note that it is the size (in bytes) of the hypothetical "containing object"
10648    which will be given in the DW_AT_byte_size attribute for this bit-field.
10649    (See `byte_size_attribute' above).  */
10650
10651 static inline void
10652 add_bit_offset_attribute (dw_die_ref die, tree decl)
10653 {
10654   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10655   tree type = DECL_BIT_FIELD_TYPE (decl);
10656   HOST_WIDE_INT bitpos_int;
10657   HOST_WIDE_INT highest_order_object_bit_offset;
10658   HOST_WIDE_INT highest_order_field_bit_offset;
10659   HOST_WIDE_INT unsigned bit_offset;
10660
10661   /* Must be a field and a bit field.  */
10662   gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10663
10664   /* We can't yet handle bit-fields whose offsets are variable, so if we
10665      encounter such things, just return without generating any attribute
10666      whatsoever.  Likewise for variable or too large size.  */
10667   if (! host_integerp (bit_position (decl), 0)
10668       || ! host_integerp (DECL_SIZE (decl), 1))
10669     return;
10670
10671   bitpos_int = int_bit_position (decl);
10672
10673   /* Note that the bit offset is always the distance (in bits) from the
10674      highest-order bit of the "containing object" to the highest-order bit of
10675      the bit-field itself.  Since the "high-order end" of any object or field
10676      is different on big-endian and little-endian machines, the computation
10677      below must take account of these differences.  */
10678   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10679   highest_order_field_bit_offset = bitpos_int;
10680
10681   if (! BYTES_BIG_ENDIAN)
10682     {
10683       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10684       highest_order_object_bit_offset += simple_type_size_in_bits (type);
10685     }
10686
10687   bit_offset
10688     = (! BYTES_BIG_ENDIAN
10689        ? highest_order_object_bit_offset - highest_order_field_bit_offset
10690        : highest_order_field_bit_offset - highest_order_object_bit_offset);
10691
10692   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10693 }
10694
10695 /* For a FIELD_DECL node which represents a bit field, output an attribute
10696    which specifies the length in bits of the given field.  */
10697
10698 static inline void
10699 add_bit_size_attribute (dw_die_ref die, tree decl)
10700 {
10701   /* Must be a field and a bit field.  */
10702   gcc_assert (TREE_CODE (decl) == FIELD_DECL
10703               && DECL_BIT_FIELD_TYPE (decl));
10704
10705   if (host_integerp (DECL_SIZE (decl), 1))
10706     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10707 }
10708
10709 /* If the compiled language is ANSI C, then add a 'prototyped'
10710    attribute, if arg types are given for the parameters of a function.  */
10711
10712 static inline void
10713 add_prototyped_attribute (dw_die_ref die, tree func_type)
10714 {
10715   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10716       && TYPE_ARG_TYPES (func_type) != NULL)
10717     add_AT_flag (die, DW_AT_prototyped, 1);
10718 }
10719
10720 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
10721    by looking in either the type declaration or object declaration
10722    equate table.  */
10723
10724 static inline void
10725 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10726 {
10727   dw_die_ref origin_die = NULL;
10728
10729   if (TREE_CODE (origin) != FUNCTION_DECL)
10730     {
10731       /* We may have gotten separated from the block for the inlined
10732          function, if we're in an exception handler or some such; make
10733          sure that the abstract function has been written out.
10734
10735          Doing this for nested functions is wrong, however; functions are
10736          distinct units, and our context might not even be inline.  */
10737       tree fn = origin;
10738
10739       if (TYPE_P (fn))
10740         fn = TYPE_STUB_DECL (fn);
10741
10742       fn = decl_function_context (fn);
10743       if (fn)
10744         dwarf2out_abstract_function (fn);
10745     }
10746
10747   if (DECL_P (origin))
10748     origin_die = lookup_decl_die (origin);
10749   else if (TYPE_P (origin))
10750     origin_die = lookup_type_die (origin);
10751
10752   /* XXX: Functions that are never lowered don't always have correct block
10753      trees (in the case of java, they simply have no block tree, in some other
10754      languages).  For these functions, there is nothing we can really do to
10755      output correct debug info for inlined functions in all cases.  Rather
10756      than die, we'll just produce deficient debug info now, in that we will
10757      have variables without a proper abstract origin.  In the future, when all
10758      functions are lowered, we should re-add a gcc_assert (origin_die)
10759      here.  */
10760
10761   if (origin_die)
10762       add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10763 }
10764
10765 /* We do not currently support the pure_virtual attribute.  */
10766
10767 static inline void
10768 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10769 {
10770   if (DECL_VINDEX (func_decl))
10771     {
10772       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10773
10774       if (host_integerp (DECL_VINDEX (func_decl), 0))
10775         add_AT_loc (die, DW_AT_vtable_elem_location,
10776                     new_loc_descr (DW_OP_constu,
10777                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
10778                                    0));
10779
10780       /* GNU extension: Record what type this method came from originally.  */
10781       if (debug_info_level > DINFO_LEVEL_TERSE)
10782         add_AT_die_ref (die, DW_AT_containing_type,
10783                         lookup_type_die (DECL_CONTEXT (func_decl)));
10784     }
10785 }
10786 \f
10787 /* Add source coordinate attributes for the given decl.  */
10788
10789 static void
10790 add_src_coords_attributes (dw_die_ref die, tree decl)
10791 {
10792   expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
10793   unsigned file_index = lookup_filename (s.file);
10794
10795   add_AT_unsigned (die, DW_AT_decl_file, file_index);
10796   add_AT_unsigned (die, DW_AT_decl_line, s.line);
10797 }
10798
10799 /* Add a DW_AT_name attribute and source coordinate attribute for the
10800    given decl, but only if it actually has a name.  */
10801
10802 static void
10803 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
10804 {
10805   tree decl_name;
10806
10807   decl_name = DECL_NAME (decl);
10808   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10809     {
10810       add_name_attribute (die, dwarf2_name (decl, 0));
10811       if (! DECL_ARTIFICIAL (decl))
10812         add_src_coords_attributes (die, decl);
10813
10814       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10815           && TREE_PUBLIC (decl)
10816           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10817           && !DECL_ABSTRACT (decl)
10818           && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
10819         add_AT_string (die, DW_AT_MIPS_linkage_name,
10820                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10821     }
10822
10823 #ifdef VMS_DEBUGGING_INFO
10824   /* Get the function's name, as described by its RTL.  This may be different
10825      from the DECL_NAME name used in the source file.  */
10826   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10827     {
10828       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10829                    XEXP (DECL_RTL (decl), 0));
10830       VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
10831     }
10832 #endif
10833 }
10834
10835 /* Push a new declaration scope.  */
10836
10837 static void
10838 push_decl_scope (tree scope)
10839 {
10840   VEC_safe_push (tree, gc, decl_scope_table, scope);
10841 }
10842
10843 /* Pop a declaration scope.  */
10844
10845 static inline void
10846 pop_decl_scope (void)
10847 {
10848   VEC_pop (tree, decl_scope_table);
10849 }
10850
10851 /* Return the DIE for the scope that immediately contains this type.
10852    Non-named types get global scope.  Named types nested in other
10853    types get their containing scope if it's open, or global scope
10854    otherwise.  All other types (i.e. function-local named types) get
10855    the current active scope.  */
10856
10857 static dw_die_ref
10858 scope_die_for (tree t, dw_die_ref context_die)
10859 {
10860   dw_die_ref scope_die = NULL;
10861   tree containing_scope;
10862   int i;
10863
10864   /* Non-types always go in the current scope.  */
10865   gcc_assert (TYPE_P (t));
10866
10867   containing_scope = TYPE_CONTEXT (t);
10868
10869   /* Use the containing namespace if it was passed in (for a declaration).  */
10870   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
10871     {
10872       if (context_die == lookup_decl_die (containing_scope))
10873         /* OK */;
10874       else
10875         containing_scope = NULL_TREE;
10876     }
10877
10878   /* Ignore function type "scopes" from the C frontend.  They mean that
10879      a tagged type is local to a parmlist of a function declarator, but
10880      that isn't useful to DWARF.  */
10881   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
10882     containing_scope = NULL_TREE;
10883
10884   if (containing_scope == NULL_TREE)
10885     scope_die = comp_unit_die;
10886   else if (TYPE_P (containing_scope))
10887     {
10888       /* For types, we can just look up the appropriate DIE.  But
10889          first we check to see if we're in the middle of emitting it
10890          so we know where the new DIE should go.  */
10891       for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
10892         if (VEC_index (tree, decl_scope_table, i) == containing_scope)
10893           break;
10894
10895       if (i < 0)
10896         {
10897           gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
10898                       || TREE_ASM_WRITTEN (containing_scope));
10899
10900           /* If none of the current dies are suitable, we get file scope.  */
10901           scope_die = comp_unit_die;
10902         }
10903       else
10904         scope_die = lookup_type_die (containing_scope);
10905     }
10906   else
10907     scope_die = context_die;
10908
10909   return scope_die;
10910 }
10911
10912 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
10913
10914 static inline int
10915 local_scope_p (dw_die_ref context_die)
10916 {
10917   for (; context_die; context_die = context_die->die_parent)
10918     if (context_die->die_tag == DW_TAG_inlined_subroutine
10919         || context_die->die_tag == DW_TAG_subprogram)
10920       return 1;
10921
10922   return 0;
10923 }
10924
10925 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
10926    whether or not to treat a DIE in this context as a declaration.  */
10927
10928 static inline int
10929 class_or_namespace_scope_p (dw_die_ref context_die)
10930 {
10931   return (context_die
10932           && (context_die->die_tag == DW_TAG_structure_type
10933               || context_die->die_tag == DW_TAG_union_type
10934               || context_die->die_tag == DW_TAG_namespace));
10935 }
10936
10937 /* Many forms of DIEs require a "type description" attribute.  This
10938    routine locates the proper "type descriptor" die for the type given
10939    by 'type', and adds a DW_AT_type attribute below the given die.  */
10940
10941 static void
10942 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
10943                     int decl_volatile, dw_die_ref context_die)
10944 {
10945   enum tree_code code  = TREE_CODE (type);
10946   dw_die_ref type_die  = NULL;
10947
10948   /* ??? If this type is an unnamed subrange type of an integral or
10949      floating-point type, use the inner type.  This is because we have no
10950      support for unnamed types in base_type_die.  This can happen if this is
10951      an Ada subrange type.  Correct solution is emit a subrange type die.  */
10952   if ((code == INTEGER_TYPE || code == REAL_TYPE)
10953       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
10954     type = TREE_TYPE (type), code = TREE_CODE (type);
10955
10956   if (code == ERROR_MARK
10957       /* Handle a special case.  For functions whose return type is void, we
10958          generate *no* type attribute.  (Note that no object may have type
10959          `void', so this only applies to function return types).  */
10960       || code == VOID_TYPE)
10961     return;
10962
10963   type_die = modified_type_die (type,
10964                                 decl_const || TYPE_READONLY (type),
10965                                 decl_volatile || TYPE_VOLATILE (type),
10966                                 context_die);
10967
10968   if (type_die != NULL)
10969     add_AT_die_ref (object_die, DW_AT_type, type_die);
10970 }
10971
10972 /* Given an object die, add the calling convention attribute for the
10973    function call type.  */
10974 static void
10975 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
10976 {
10977   enum dwarf_calling_convention value = DW_CC_normal;
10978
10979   value = targetm.dwarf_calling_convention (type);
10980
10981   /* Only add the attribute if the backend requests it, and
10982      is not DW_CC_normal.  */
10983   if (value && (value != DW_CC_normal))
10984     add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
10985 }
10986
10987 /* Given a tree pointer to a struct, class, union, or enum type node, return
10988    a pointer to the (string) tag name for the given type, or zero if the type
10989    was declared without a tag.  */
10990
10991 static const char *
10992 type_tag (tree type)
10993 {
10994   const char *name = 0;
10995
10996   if (TYPE_NAME (type) != 0)
10997     {
10998       tree t = 0;
10999
11000       /* Find the IDENTIFIER_NODE for the type name.  */
11001       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11002         t = TYPE_NAME (type);
11003
11004       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11005          a TYPE_DECL node, regardless of whether or not a `typedef' was
11006          involved.  */
11007       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11008                && ! DECL_IGNORED_P (TYPE_NAME (type)))
11009         t = DECL_NAME (TYPE_NAME (type));
11010
11011       /* Now get the name as a string, or invent one.  */
11012       if (t != 0)
11013         name = IDENTIFIER_POINTER (t);
11014     }
11015
11016   return (name == 0 || *name == '\0') ? 0 : name;
11017 }
11018
11019 /* Return the type associated with a data member, make a special check
11020    for bit field types.  */
11021
11022 static inline tree
11023 member_declared_type (tree member)
11024 {
11025   return (DECL_BIT_FIELD_TYPE (member)
11026           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11027 }
11028
11029 /* Get the decl's label, as described by its RTL. This may be different
11030    from the DECL_NAME name used in the source file.  */
11031
11032 #if 0
11033 static const char *
11034 decl_start_label (tree decl)
11035 {
11036   rtx x;
11037   const char *fnname;
11038
11039   x = DECL_RTL (decl);
11040   gcc_assert (MEM_P (x));
11041
11042   x = XEXP (x, 0);
11043   gcc_assert (GET_CODE (x) == SYMBOL_REF);
11044
11045   fnname = XSTR (x, 0);
11046   return fnname;
11047 }
11048 #endif
11049 \f
11050 /* These routines generate the internal representation of the DIE's for
11051    the compilation unit.  Debugging information is collected by walking
11052    the declaration trees passed in from dwarf2out_decl().  */
11053
11054 static void
11055 gen_array_type_die (tree type, dw_die_ref context_die)
11056 {
11057   dw_die_ref scope_die = scope_die_for (type, context_die);
11058   dw_die_ref array_die;
11059   tree element_type;
11060
11061   /* ??? The SGI dwarf reader fails for array of array of enum types unless
11062      the inner array type comes before the outer array type.  Thus we must
11063      call gen_type_die before we call new_die.  See below also.  */
11064 #ifdef MIPS_DEBUGGING_INFO
11065   gen_type_die (TREE_TYPE (type), context_die);
11066 #endif
11067
11068   array_die = new_die (DW_TAG_array_type, scope_die, type);
11069   add_name_attribute (array_die, type_tag (type));
11070   equate_type_number_to_die (type, array_die);
11071
11072   if (TREE_CODE (type) == VECTOR_TYPE)
11073     {
11074       /* The frontend feeds us a representation for the vector as a struct
11075          containing an array.  Pull out the array type.  */
11076       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11077       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11078     }
11079
11080 #if 0
11081   /* We default the array ordering.  SDB will probably do
11082      the right things even if DW_AT_ordering is not present.  It's not even
11083      an issue until we start to get into multidimensional arrays anyway.  If
11084      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11085      then we'll have to put the DW_AT_ordering attribute back in.  (But if
11086      and when we find out that we need to put these in, we will only do so
11087      for multidimensional arrays.  */
11088   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11089 #endif
11090
11091 #ifdef MIPS_DEBUGGING_INFO
11092   /* The SGI compilers handle arrays of unknown bound by setting
11093      AT_declaration and not emitting any subrange DIEs.  */
11094   if (! TYPE_DOMAIN (type))
11095     add_AT_flag (array_die, DW_AT_declaration, 1);
11096   else
11097 #endif
11098     add_subscript_info (array_die, type);
11099
11100   /* Add representation of the type of the elements of this array type.  */
11101   element_type = TREE_TYPE (type);
11102
11103   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11104      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
11105      We work around this by disabling this feature.  See also
11106      add_subscript_info.  */
11107 #ifndef MIPS_DEBUGGING_INFO
11108   while (TREE_CODE (element_type) == ARRAY_TYPE)
11109     element_type = TREE_TYPE (element_type);
11110
11111   gen_type_die (element_type, context_die);
11112 #endif
11113
11114   add_type_attribute (array_die, element_type, 0, 0, context_die);
11115 }
11116
11117 #if 0
11118 static void
11119 gen_entry_point_die (tree decl, dw_die_ref context_die)
11120 {
11121   tree origin = decl_ultimate_origin (decl);
11122   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11123
11124   if (origin != NULL)
11125     add_abstract_origin_attribute (decl_die, origin);
11126   else
11127     {
11128       add_name_and_src_coords_attributes (decl_die, decl);
11129       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11130                           0, 0, context_die);
11131     }
11132
11133   if (DECL_ABSTRACT (decl))
11134     equate_decl_number_to_die (decl, decl_die);
11135   else
11136     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11137 }
11138 #endif
11139
11140 /* Walk through the list of incomplete types again, trying once more to
11141    emit full debugging info for them.  */
11142
11143 static void
11144 retry_incomplete_types (void)
11145 {
11146   int i;
11147
11148   for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11149     gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11150 }
11151
11152 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
11153
11154 static void
11155 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11156 {
11157   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11158
11159   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11160      be incomplete and such types are not marked.  */
11161   add_abstract_origin_attribute (type_die, type);
11162 }
11163
11164 /* Generate a DIE to represent an inlined instance of a structure type.  */
11165
11166 static void
11167 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11168 {
11169   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11170
11171   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11172      be incomplete and such types are not marked.  */
11173   add_abstract_origin_attribute (type_die, type);
11174 }
11175
11176 /* Generate a DIE to represent an inlined instance of a union type.  */
11177
11178 static void
11179 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11180 {
11181   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11182
11183   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11184      be incomplete and such types are not marked.  */
11185   add_abstract_origin_attribute (type_die, type);
11186 }
11187
11188 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
11189    include all of the information about the enumeration values also. Each
11190    enumerated type name/value is listed as a child of the enumerated type
11191    DIE.  */
11192
11193 static dw_die_ref
11194 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11195 {
11196   dw_die_ref type_die = lookup_type_die (type);
11197
11198   if (type_die == NULL)
11199     {
11200       type_die = new_die (DW_TAG_enumeration_type,
11201                           scope_die_for (type, context_die), type);
11202       equate_type_number_to_die (type, type_die);
11203       add_name_attribute (type_die, type_tag (type));
11204     }
11205   else if (! TYPE_SIZE (type))
11206     return type_die;
11207   else
11208     remove_AT (type_die, DW_AT_declaration);
11209
11210   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
11211      given enum type is incomplete, do not generate the DW_AT_byte_size
11212      attribute or the DW_AT_element_list attribute.  */
11213   if (TYPE_SIZE (type))
11214     {
11215       tree link;
11216
11217       TREE_ASM_WRITTEN (type) = 1;
11218       add_byte_size_attribute (type_die, type);
11219       if (TYPE_STUB_DECL (type) != NULL_TREE)
11220         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11221
11222       /* If the first reference to this type was as the return type of an
11223          inline function, then it may not have a parent.  Fix this now.  */
11224       if (type_die->die_parent == NULL)
11225         add_child_die (scope_die_for (type, context_die), type_die);
11226
11227       for (link = TYPE_VALUES (type);
11228            link != NULL; link = TREE_CHAIN (link))
11229         {
11230           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11231           tree value = TREE_VALUE (link);
11232
11233           add_name_attribute (enum_die,
11234                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11235
11236           if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11237             /* DWARF2 does not provide a way of indicating whether or
11238                not enumeration constants are signed or unsigned.  GDB
11239                always assumes the values are signed, so we output all
11240                values as if they were signed.  That means that
11241                enumeration constants with very large unsigned values
11242                will appear to have negative values in the debugger.  */
11243             add_AT_int (enum_die, DW_AT_const_value,
11244                         tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11245         }
11246     }
11247   else
11248     add_AT_flag (type_die, DW_AT_declaration, 1);
11249
11250   return type_die;
11251 }
11252
11253 /* Generate a DIE to represent either a real live formal parameter decl or to
11254    represent just the type of some formal parameter position in some function
11255    type.
11256
11257    Note that this routine is a bit unusual because its argument may be a
11258    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11259    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11260    node.  If it's the former then this function is being called to output a
11261    DIE to represent a formal parameter object (or some inlining thereof).  If
11262    it's the latter, then this function is only being called to output a
11263    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11264    argument type of some subprogram type.  */
11265
11266 static dw_die_ref
11267 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11268 {
11269   dw_die_ref parm_die
11270     = new_die (DW_TAG_formal_parameter, context_die, node);
11271   tree origin;
11272
11273   switch (TREE_CODE_CLASS (TREE_CODE (node)))
11274     {
11275     case tcc_declaration:
11276       origin = decl_ultimate_origin (node);
11277       if (origin != NULL)
11278         add_abstract_origin_attribute (parm_die, origin);
11279       else
11280         {
11281           add_name_and_src_coords_attributes (parm_die, node);
11282           add_type_attribute (parm_die, TREE_TYPE (node),
11283                               TREE_READONLY (node),
11284                               TREE_THIS_VOLATILE (node),
11285                               context_die);
11286           if (DECL_ARTIFICIAL (node))
11287             add_AT_flag (parm_die, DW_AT_artificial, 1);
11288         }
11289
11290       equate_decl_number_to_die (node, parm_die);
11291       if (! DECL_ABSTRACT (node))
11292         add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11293
11294       break;
11295
11296     case tcc_type:
11297       /* We were called with some kind of a ..._TYPE node.  */
11298       add_type_attribute (parm_die, node, 0, 0, context_die);
11299       break;
11300
11301     default:
11302       gcc_unreachable ();
11303     }
11304
11305   return parm_die;
11306 }
11307
11308 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11309    at the end of an (ANSI prototyped) formal parameters list.  */
11310
11311 static void
11312 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11313 {
11314   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11315 }
11316
11317 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11318    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11319    parameters as specified in some function type specification (except for
11320    those which appear as part of a function *definition*).  */
11321
11322 static void
11323 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11324 {
11325   tree link;
11326   tree formal_type = NULL;
11327   tree first_parm_type;
11328   tree arg;
11329
11330   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11331     {
11332       arg = DECL_ARGUMENTS (function_or_method_type);
11333       function_or_method_type = TREE_TYPE (function_or_method_type);
11334     }
11335   else
11336     arg = NULL_TREE;
11337
11338   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11339
11340   /* Make our first pass over the list of formal parameter types and output a
11341      DW_TAG_formal_parameter DIE for each one.  */
11342   for (link = first_parm_type; link; )
11343     {
11344       dw_die_ref parm_die;
11345
11346       formal_type = TREE_VALUE (link);
11347       if (formal_type == void_type_node)
11348         break;
11349
11350       /* Output a (nameless) DIE to represent the formal parameter itself.  */
11351       parm_die = gen_formal_parameter_die (formal_type, context_die);
11352       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11353            && link == first_parm_type)
11354           || (arg && DECL_ARTIFICIAL (arg)))
11355         add_AT_flag (parm_die, DW_AT_artificial, 1);
11356
11357       link = TREE_CHAIN (link);
11358       if (arg)
11359         arg = TREE_CHAIN (arg);
11360     }
11361
11362   /* If this function type has an ellipsis, add a
11363      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
11364   if (formal_type != void_type_node)
11365     gen_unspecified_parameters_die (function_or_method_type, context_die);
11366
11367   /* Make our second (and final) pass over the list of formal parameter types
11368      and output DIEs to represent those types (as necessary).  */
11369   for (link = TYPE_ARG_TYPES (function_or_method_type);
11370        link && TREE_VALUE (link);
11371        link = TREE_CHAIN (link))
11372     gen_type_die (TREE_VALUE (link), context_die);
11373 }
11374
11375 /* We want to generate the DIE for TYPE so that we can generate the
11376    die for MEMBER, which has been defined; we will need to refer back
11377    to the member declaration nested within TYPE.  If we're trying to
11378    generate minimal debug info for TYPE, processing TYPE won't do the
11379    trick; we need to attach the member declaration by hand.  */
11380
11381 static void
11382 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11383 {
11384   gen_type_die (type, context_die);
11385
11386   /* If we're trying to avoid duplicate debug info, we may not have
11387      emitted the member decl for this function.  Emit it now.  */
11388   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11389       && ! lookup_decl_die (member))
11390     {
11391       dw_die_ref type_die;
11392       gcc_assert (!decl_ultimate_origin (member));
11393
11394       push_decl_scope (type);
11395       type_die = lookup_type_die (type);
11396       if (TREE_CODE (member) == FUNCTION_DECL)
11397         gen_subprogram_die (member, type_die);
11398       else if (TREE_CODE (member) == FIELD_DECL)
11399         {
11400           /* Ignore the nameless fields that are used to skip bits but handle
11401              C++ anonymous unions and structs.  */
11402           if (DECL_NAME (member) != NULL_TREE
11403               || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11404               || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11405             {
11406               gen_type_die (member_declared_type (member), type_die);
11407               gen_field_die (member, type_die);
11408             }
11409         }
11410       else
11411         gen_variable_die (member, type_die);
11412
11413       pop_decl_scope ();
11414     }
11415 }
11416
11417 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11418    may later generate inlined and/or out-of-line instances of.  */
11419
11420 static void
11421 dwarf2out_abstract_function (tree decl)
11422 {
11423   dw_die_ref old_die;
11424   tree save_fn;
11425   tree context;
11426   int was_abstract = DECL_ABSTRACT (decl);
11427
11428   /* Make sure we have the actual abstract inline, not a clone.  */
11429   decl = DECL_ORIGIN (decl);
11430
11431   old_die = lookup_decl_die (decl);
11432   if (old_die && get_AT (old_die, DW_AT_inline))
11433     /* We've already generated the abstract instance.  */
11434     return;
11435
11436   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11437      we don't get confused by DECL_ABSTRACT.  */
11438   if (debug_info_level > DINFO_LEVEL_TERSE)
11439     {
11440       context = decl_class_context (decl);
11441       if (context)
11442         gen_type_die_for_member
11443           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11444     }
11445
11446   /* Pretend we've just finished compiling this function.  */
11447   save_fn = current_function_decl;
11448   current_function_decl = decl;
11449
11450   set_decl_abstract_flags (decl, 1);
11451   dwarf2out_decl (decl);
11452   if (! was_abstract)
11453     set_decl_abstract_flags (decl, 0);
11454
11455   current_function_decl = save_fn;
11456 }
11457
11458 /* Generate a DIE to represent a declared function (either file-scope or
11459    block-local).  */
11460
11461 static void
11462 gen_subprogram_die (tree decl, dw_die_ref context_die)
11463 {
11464   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11465   tree origin = decl_ultimate_origin (decl);
11466   dw_die_ref subr_die;
11467   tree fn_arg_types;
11468   tree outer_scope;
11469   dw_die_ref old_die = lookup_decl_die (decl);
11470   int declaration = (current_function_decl != decl
11471                      || class_or_namespace_scope_p (context_die));
11472
11473   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11474      started to generate the abstract instance of an inline, decided to output
11475      its containing class, and proceeded to emit the declaration of the inline
11476      from the member list for the class.  If so, DECLARATION takes priority;
11477      we'll get back to the abstract instance when done with the class.  */
11478
11479   /* The class-scope declaration DIE must be the primary DIE.  */
11480   if (origin && declaration && class_or_namespace_scope_p (context_die))
11481     {
11482       origin = NULL;
11483       gcc_assert (!old_die);
11484     }
11485
11486   /* Now that the C++ front end lazily declares artificial member fns, we
11487      might need to retrofit the declaration into its class.  */
11488   if (!declaration && !origin && !old_die
11489       && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11490       && !class_or_namespace_scope_p (context_die)
11491       && debug_info_level > DINFO_LEVEL_TERSE)
11492     old_die = force_decl_die (decl);
11493
11494   if (origin != NULL)
11495     {
11496       gcc_assert (!declaration || local_scope_p (context_die));
11497
11498       /* Fixup die_parent for the abstract instance of a nested
11499          inline function.  */
11500       if (old_die && old_die->die_parent == NULL)
11501         add_child_die (context_die, old_die);
11502
11503       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11504       add_abstract_origin_attribute (subr_die, origin);
11505     }
11506   else if (old_die)
11507     {
11508       expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11509       unsigned file_index = lookup_filename (s.file);
11510
11511       if (!get_AT_flag (old_die, DW_AT_declaration)
11512           /* We can have a normal definition following an inline one in the
11513              case of redefinition of GNU C extern inlines.
11514              It seems reasonable to use AT_specification in this case.  */
11515           && !get_AT (old_die, DW_AT_inline))
11516         {
11517           /* Detect and ignore this case, where we are trying to output
11518              something we have already output.  */
11519           return;
11520         }
11521
11522       /* If the definition comes from the same place as the declaration,
11523          maybe use the old DIE.  We always want the DIE for this function
11524          that has the *_pc attributes to be under comp_unit_die so the
11525          debugger can find it.  We also need to do this for abstract
11526          instances of inlines, since the spec requires the out-of-line copy
11527          to have the same parent.  For local class methods, this doesn't
11528          apply; we just use the old DIE.  */
11529       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11530           && (DECL_ARTIFICIAL (decl)
11531               || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
11532                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
11533                       == (unsigned) s.line))))
11534         {
11535           subr_die = old_die;
11536
11537           /* Clear out the declaration attribute and the formal parameters.
11538              Do not remove all children, because it is possible that this
11539              declaration die was forced using force_decl_die(). In such
11540              cases die that forced declaration die (e.g. TAG_imported_module)
11541              is one of the children that we do not want to remove.  */
11542           remove_AT (subr_die, DW_AT_declaration);
11543           remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11544         }
11545       else
11546         {
11547           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11548           add_AT_specification (subr_die, old_die);
11549           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11550             add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
11551           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11552               != (unsigned) s.line)
11553             add_AT_unsigned
11554               (subr_die, DW_AT_decl_line, s.line);
11555         }
11556     }
11557   else
11558     {
11559       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11560
11561       if (TREE_PUBLIC (decl))
11562         add_AT_flag (subr_die, DW_AT_external, 1);
11563
11564       add_name_and_src_coords_attributes (subr_die, decl);
11565       if (debug_info_level > DINFO_LEVEL_TERSE)
11566         {
11567           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11568           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11569                               0, 0, context_die);
11570         }
11571
11572       add_pure_or_virtual_attribute (subr_die, decl);
11573       if (DECL_ARTIFICIAL (decl))
11574         add_AT_flag (subr_die, DW_AT_artificial, 1);
11575
11576       if (TREE_PROTECTED (decl))
11577         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11578       else if (TREE_PRIVATE (decl))
11579         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11580     }
11581
11582   if (declaration)
11583     {
11584       if (!old_die || !get_AT (old_die, DW_AT_inline))
11585         {
11586           add_AT_flag (subr_die, DW_AT_declaration, 1);
11587
11588           /* The first time we see a member function, it is in the context of
11589              the class to which it belongs.  We make sure of this by emitting
11590              the class first.  The next time is the definition, which is
11591              handled above.  The two may come from the same source text.
11592
11593              Note that force_decl_die() forces function declaration die. It is
11594              later reused to represent definition.  */
11595           equate_decl_number_to_die (decl, subr_die);
11596         }
11597     }
11598   else if (DECL_ABSTRACT (decl))
11599     {
11600       if (DECL_DECLARED_INLINE_P (decl))
11601         {
11602           if (cgraph_function_possibly_inlined_p (decl))
11603             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11604           else
11605             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11606         }
11607       else
11608         {
11609           if (cgraph_function_possibly_inlined_p (decl))
11610             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11611           else
11612             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11613         }
11614
11615       equate_decl_number_to_die (decl, subr_die);
11616     }
11617   else if (!DECL_EXTERNAL (decl))
11618     {
11619       HOST_WIDE_INT cfa_fb_offset;
11620
11621       if (!old_die || !get_AT (old_die, DW_AT_inline))
11622         equate_decl_number_to_die (decl, subr_die);
11623
11624       if (!flag_reorder_blocks_and_partition)
11625         {
11626           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11627                                        current_function_funcdef_no);
11628           add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11629           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11630                                        current_function_funcdef_no);
11631           add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11632
11633           add_pubname (decl, subr_die);
11634           add_arange (decl, subr_die);
11635         }
11636       else
11637         {  /* Do nothing for now; maybe need to duplicate die, one for
11638               hot section and ond for cold section, then use the hot/cold
11639               section begin/end labels to generate the aranges...  */
11640           /*
11641             add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11642             add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11643             add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11644             add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11645
11646             add_pubname (decl, subr_die);
11647             add_arange (decl, subr_die);
11648             add_arange (decl, subr_die);
11649            */
11650         }
11651
11652 #ifdef MIPS_DEBUGGING_INFO
11653       /* Add a reference to the FDE for this routine.  */
11654       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11655 #endif
11656
11657       cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
11658
11659       /* We define the "frame base" as the function's CFA.  This is more
11660          convenient for several reasons: (1) It's stable across the prologue
11661          and epilogue, which makes it better than just a frame pointer,
11662          (2) With dwarf3, there exists a one-byte encoding that allows us
11663          to reference the .debug_frame data by proxy, but failing that,
11664          (3) We can at least reuse the code inspection and interpretation
11665          code that determines the CFA position at various points in the
11666          function.  */
11667       /* ??? Use some command-line or configury switch to enable the use
11668          of dwarf3 DW_OP_call_frame_cfa.  At present there are no dwarf
11669          consumers that understand it; fall back to "pure" dwarf2 and
11670          convert the CFA data into a location list.  */
11671       {
11672         dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
11673         if (list->dw_loc_next)
11674           add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11675         else
11676           add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11677       }
11678
11679       /* Compute a displacement from the "steady-state frame pointer" to
11680          the CFA.  The former is what all stack slots and argument slots
11681          will reference in the rtl; the later is what we've told the
11682          debugger about.  We'll need to adjust all frame_base references
11683          by this displacement.  */
11684       compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
11685
11686       if (cfun->static_chain_decl)
11687         add_AT_location_description (subr_die, DW_AT_static_link,
11688                  loc_descriptor_from_tree (cfun->static_chain_decl));
11689     }
11690
11691   /* Now output descriptions of the arguments for this function. This gets
11692      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11693      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11694      `...' at the end of the formal parameter list.  In order to find out if
11695      there was a trailing ellipsis or not, we must instead look at the type
11696      associated with the FUNCTION_DECL.  This will be a node of type
11697      FUNCTION_TYPE. If the chain of type nodes hanging off of this
11698      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11699      an ellipsis at the end.  */
11700
11701   /* In the case where we are describing a mere function declaration, all we
11702      need to do here (and all we *can* do here) is to describe the *types* of
11703      its formal parameters.  */
11704   if (debug_info_level <= DINFO_LEVEL_TERSE)
11705     ;
11706   else if (declaration)
11707     gen_formal_types_die (decl, subr_die);
11708   else
11709     {
11710       /* Generate DIEs to represent all known formal parameters.  */
11711       tree arg_decls = DECL_ARGUMENTS (decl);
11712       tree parm;
11713
11714       /* When generating DIEs, generate the unspecified_parameters DIE
11715          instead if we come across the arg "__builtin_va_alist" */
11716       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11717         if (TREE_CODE (parm) == PARM_DECL)
11718           {
11719             if (DECL_NAME (parm)
11720                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11721                             "__builtin_va_alist"))
11722               gen_unspecified_parameters_die (parm, subr_die);
11723             else
11724               gen_decl_die (parm, subr_die);
11725           }
11726
11727       /* Decide whether we need an unspecified_parameters DIE at the end.
11728          There are 2 more cases to do this for: 1) the ansi ... declaration -
11729          this is detectable when the end of the arg list is not a
11730          void_type_node 2) an unprototyped function declaration (not a
11731          definition).  This just means that we have no info about the
11732          parameters at all.  */
11733       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11734       if (fn_arg_types != NULL)
11735         {
11736           /* This is the prototyped case, check for....  */
11737           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11738             gen_unspecified_parameters_die (decl, subr_die);
11739         }
11740       else if (DECL_INITIAL (decl) == NULL_TREE)
11741         gen_unspecified_parameters_die (decl, subr_die);
11742     }
11743
11744   /* Output Dwarf info for all of the stuff within the body of the function
11745      (if it has one - it may be just a declaration).  */
11746   outer_scope = DECL_INITIAL (decl);
11747
11748   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11749      a function.  This BLOCK actually represents the outermost binding contour
11750      for the function, i.e. the contour in which the function's formal
11751      parameters and labels get declared. Curiously, it appears that the front
11752      end doesn't actually put the PARM_DECL nodes for the current function onto
11753      the BLOCK_VARS list for this outer scope, but are strung off of the
11754      DECL_ARGUMENTS list for the function instead.
11755
11756      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11757      the LABEL_DECL nodes for the function however, and we output DWARF info
11758      for those in decls_for_scope.  Just within the `outer_scope' there will be
11759      a BLOCK node representing the function's outermost pair of curly braces,
11760      and any blocks used for the base and member initializers of a C++
11761      constructor function.  */
11762   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11763     {
11764       /* Emit a DW_TAG_variable DIE for a named return value.  */
11765       if (DECL_NAME (DECL_RESULT (decl)))
11766         gen_decl_die (DECL_RESULT (decl), subr_die);
11767
11768       current_function_has_inlines = 0;
11769       decls_for_scope (outer_scope, subr_die, 0);
11770
11771 #if 0 && defined (MIPS_DEBUGGING_INFO)
11772       if (current_function_has_inlines)
11773         {
11774           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11775           if (! comp_unit_has_inlines)
11776             {
11777               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11778               comp_unit_has_inlines = 1;
11779             }
11780         }
11781 #endif
11782     }
11783   /* Add the calling convention attribute if requested.  */
11784   add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
11785
11786 }
11787
11788 /* Generate a DIE to represent a declared data object.  */
11789
11790 static void
11791 gen_variable_die (tree decl, dw_die_ref context_die)
11792 {
11793   tree origin = decl_ultimate_origin (decl);
11794   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11795
11796   dw_die_ref old_die = lookup_decl_die (decl);
11797   int declaration = (DECL_EXTERNAL (decl)
11798                      /* If DECL is COMDAT and has not actually been
11799                         emitted, we cannot take its address; there
11800                         might end up being no definition anywhere in
11801                         the program.  For example, consider the C++
11802                         test case:
11803
11804                           template <class T>
11805                           struct S { static const int i = 7; };
11806
11807                           template <class T>
11808                           const int S<T>::i;
11809
11810                           int f() { return S<int>::i; }
11811
11812                         Here, S<int>::i is not DECL_EXTERNAL, but no
11813                         definition is required, so the compiler will
11814                         not emit a definition.  */
11815                      || (TREE_CODE (decl) == VAR_DECL
11816                          && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
11817                      || class_or_namespace_scope_p (context_die));
11818
11819   if (origin != NULL)
11820     add_abstract_origin_attribute (var_die, origin);
11821
11822   /* Loop unrolling can create multiple blocks that refer to the same
11823      static variable, so we must test for the DW_AT_declaration flag.
11824
11825      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11826      copy decls and set the DECL_ABSTRACT flag on them instead of
11827      sharing them.
11828
11829      ??? Duplicated blocks have been rewritten to use .debug_ranges.
11830
11831      ??? The declare_in_namespace support causes us to get two DIEs for one
11832      variable, both of which are declarations.  We want to avoid considering
11833      one to be a specification, so we must test that this DIE is not a
11834      declaration.  */
11835   else if (old_die && TREE_STATIC (decl) && ! declaration
11836            && get_AT_flag (old_die, DW_AT_declaration) == 1)
11837     {
11838       /* This is a definition of a C++ class level static.  */
11839       add_AT_specification (var_die, old_die);
11840       if (DECL_NAME (decl))
11841         {
11842           expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11843           unsigned file_index = lookup_filename (s.file);
11844
11845           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11846             add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
11847
11848           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11849               != (unsigned) s.line)
11850
11851             add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
11852         }
11853     }
11854   else
11855     {
11856       add_name_and_src_coords_attributes (var_die, decl);
11857       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
11858                           TREE_THIS_VOLATILE (decl), context_die);
11859
11860       if (TREE_PUBLIC (decl))
11861         add_AT_flag (var_die, DW_AT_external, 1);
11862
11863       if (DECL_ARTIFICIAL (decl))
11864         add_AT_flag (var_die, DW_AT_artificial, 1);
11865
11866       if (TREE_PROTECTED (decl))
11867         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
11868       else if (TREE_PRIVATE (decl))
11869         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
11870     }
11871
11872   if (declaration)
11873     add_AT_flag (var_die, DW_AT_declaration, 1);
11874
11875   if (DECL_ABSTRACT (decl) || declaration)
11876     equate_decl_number_to_die (decl, var_die);
11877
11878   if (! declaration && ! DECL_ABSTRACT (decl))
11879     {
11880       add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
11881       add_pubname (decl, var_die);
11882     }
11883   else
11884     tree_add_const_value_attribute (var_die, decl);
11885 }
11886
11887 /* Generate a DIE to represent a label identifier.  */
11888
11889 static void
11890 gen_label_die (tree decl, dw_die_ref context_die)
11891 {
11892   tree origin = decl_ultimate_origin (decl);
11893   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
11894   rtx insn;
11895   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11896
11897   if (origin != NULL)
11898     add_abstract_origin_attribute (lbl_die, origin);
11899   else
11900     add_name_and_src_coords_attributes (lbl_die, decl);
11901
11902   if (DECL_ABSTRACT (decl))
11903     equate_decl_number_to_die (decl, lbl_die);
11904   else
11905     {
11906       insn = DECL_RTL_IF_SET (decl);
11907
11908       /* Deleted labels are programmer specified labels which have been
11909          eliminated because of various optimizations.  We still emit them
11910          here so that it is possible to put breakpoints on them.  */
11911       if (insn
11912           && (LABEL_P (insn)
11913               || ((NOTE_P (insn)
11914                    && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
11915         {
11916           /* When optimization is enabled (via -O) some parts of the compiler
11917              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11918              represent source-level labels which were explicitly declared by
11919              the user.  This really shouldn't be happening though, so catch
11920              it if it ever does happen.  */
11921           gcc_assert (!INSN_DELETED_P (insn));
11922
11923           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
11924           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
11925         }
11926     }
11927 }
11928
11929 /* A helper function for gen_inlined_subroutine_die.  Add source coordinate
11930    attributes to the DIE for a block STMT, to describe where the inlined
11931    function was called from.  This is similar to add_src_coords_attributes.  */
11932
11933 static inline void
11934 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
11935 {
11936   expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
11937   unsigned file_index = lookup_filename (s.file);
11938
11939   add_AT_unsigned (die, DW_AT_call_file, file_index);
11940   add_AT_unsigned (die, DW_AT_call_line, s.line);
11941 }
11942
11943 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
11944    Add low_pc and high_pc attributes to the DIE for a block STMT.  */
11945
11946 static inline void
11947 add_high_low_attributes (tree stmt, dw_die_ref die)
11948 {
11949   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11950
11951   if (BLOCK_FRAGMENT_CHAIN (stmt))
11952     {
11953       tree chain;
11954
11955       add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
11956
11957       chain = BLOCK_FRAGMENT_CHAIN (stmt);
11958       do
11959         {
11960           add_ranges (chain);
11961           chain = BLOCK_FRAGMENT_CHAIN (chain);
11962         }
11963       while (chain);
11964       add_ranges (NULL);
11965     }
11966   else
11967     {
11968       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11969                                    BLOCK_NUMBER (stmt));
11970       add_AT_lbl_id (die, DW_AT_low_pc, label);
11971       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11972                                    BLOCK_NUMBER (stmt));
11973       add_AT_lbl_id (die, DW_AT_high_pc, label);
11974     }
11975 }
11976
11977 /* Generate a DIE for a lexical block.  */
11978
11979 static void
11980 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
11981 {
11982   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
11983
11984   if (! BLOCK_ABSTRACT (stmt))
11985     add_high_low_attributes (stmt, stmt_die);
11986
11987   decls_for_scope (stmt, stmt_die, depth);
11988 }
11989
11990 /* Generate a DIE for an inlined subprogram.  */
11991
11992 static void
11993 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
11994 {
11995   tree decl = block_ultimate_origin (stmt);
11996
11997   /* Emit info for the abstract instance first, if we haven't yet.  We
11998      must emit this even if the block is abstract, otherwise when we
11999      emit the block below (or elsewhere), we may end up trying to emit
12000      a die whose origin die hasn't been emitted, and crashing.  */
12001   dwarf2out_abstract_function (decl);
12002
12003   if (! BLOCK_ABSTRACT (stmt))
12004     {
12005       dw_die_ref subr_die
12006         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12007
12008       add_abstract_origin_attribute (subr_die, decl);
12009       add_high_low_attributes (stmt, subr_die);
12010       add_call_src_coords_attributes (stmt, subr_die);
12011
12012       decls_for_scope (stmt, subr_die, depth);
12013       current_function_has_inlines = 1;
12014     }
12015   else
12016     /* We may get here if we're the outer block of function A that was
12017        inlined into function B that was inlined into function C.  When
12018        generating debugging info for C, dwarf2out_abstract_function(B)
12019        would mark all inlined blocks as abstract, including this one.
12020        So, we wouldn't (and shouldn't) expect labels to be generated
12021        for this one.  Instead, just emit debugging info for
12022        declarations within the block.  This is particularly important
12023        in the case of initializers of arguments passed from B to us:
12024        if they're statement expressions containing declarations, we
12025        wouldn't generate dies for their abstract variables, and then,
12026        when generating dies for the real variables, we'd die (pun
12027        intended :-)  */
12028     gen_lexical_block_die (stmt, context_die, depth);
12029 }
12030
12031 /* Generate a DIE for a field in a record, or structure.  */
12032
12033 static void
12034 gen_field_die (tree decl, dw_die_ref context_die)
12035 {
12036   dw_die_ref decl_die;
12037
12038   if (TREE_TYPE (decl) == error_mark_node)
12039     return;
12040
12041   decl_die = new_die (DW_TAG_member, context_die, decl);
12042   add_name_and_src_coords_attributes (decl_die, decl);
12043   add_type_attribute (decl_die, member_declared_type (decl),
12044                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12045                       context_die);
12046
12047   if (DECL_BIT_FIELD_TYPE (decl))
12048     {
12049       add_byte_size_attribute (decl_die, decl);
12050       add_bit_size_attribute (decl_die, decl);
12051       add_bit_offset_attribute (decl_die, decl);
12052     }
12053
12054   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12055     add_data_member_location_attribute (decl_die, decl);
12056
12057   if (DECL_ARTIFICIAL (decl))
12058     add_AT_flag (decl_die, DW_AT_artificial, 1);
12059
12060   if (TREE_PROTECTED (decl))
12061     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12062   else if (TREE_PRIVATE (decl))
12063     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12064
12065   /* Equate decl number to die, so that we can look up this decl later on.  */
12066   equate_decl_number_to_die (decl, decl_die);
12067 }
12068
12069 #if 0
12070 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12071    Use modified_type_die instead.
12072    We keep this code here just in case these types of DIEs may be needed to
12073    represent certain things in other languages (e.g. Pascal) someday.  */
12074
12075 static void
12076 gen_pointer_type_die (tree type, dw_die_ref context_die)
12077 {
12078   dw_die_ref ptr_die
12079     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12080
12081   equate_type_number_to_die (type, ptr_die);
12082   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12083   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12084 }
12085
12086 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12087    Use modified_type_die instead.
12088    We keep this code here just in case these types of DIEs may be needed to
12089    represent certain things in other languages (e.g. Pascal) someday.  */
12090
12091 static void
12092 gen_reference_type_die (tree type, dw_die_ref context_die)
12093 {
12094   dw_die_ref ref_die
12095     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12096
12097   equate_type_number_to_die (type, ref_die);
12098   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12099   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12100 }
12101 #endif
12102
12103 /* Generate a DIE for a pointer to a member type.  */
12104
12105 static void
12106 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12107 {
12108   dw_die_ref ptr_die
12109     = new_die (DW_TAG_ptr_to_member_type,
12110                scope_die_for (type, context_die), type);
12111
12112   equate_type_number_to_die (type, ptr_die);
12113   add_AT_die_ref (ptr_die, DW_AT_containing_type,
12114                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12115   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12116 }
12117
12118 /* Generate the DIE for the compilation unit.  */
12119
12120 static dw_die_ref
12121 gen_compile_unit_die (const char *filename)
12122 {
12123   dw_die_ref die;
12124   char producer[250];
12125   const char *language_string = lang_hooks.name;
12126   int language;
12127
12128   die = new_die (DW_TAG_compile_unit, NULL, NULL);
12129
12130   if (filename)
12131     {
12132       add_name_attribute (die, filename);
12133       /* Don't add cwd for <built-in>.  */
12134       if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
12135         add_comp_dir_attribute (die);
12136     }
12137
12138   sprintf (producer, "%s %s", language_string, version_string);
12139
12140 #ifdef MIPS_DEBUGGING_INFO
12141   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12142      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12143      not appear in the producer string, the debugger reaches the conclusion
12144      that the object file is stripped and has no debugging information.
12145      To get the MIPS/SGI debugger to believe that there is debugging
12146      information in the object file, we add a -g to the producer string.  */
12147   if (debug_info_level > DINFO_LEVEL_TERSE)
12148     strcat (producer, " -g");
12149 #endif
12150
12151   add_AT_string (die, DW_AT_producer, producer);
12152
12153   if (strcmp (language_string, "GNU C++") == 0)
12154     language = DW_LANG_C_plus_plus;
12155   else if (strcmp (language_string, "GNU Ada") == 0)
12156     language = DW_LANG_Ada95;
12157   else if (strcmp (language_string, "GNU F77") == 0)
12158     language = DW_LANG_Fortran77;
12159   else if (strcmp (language_string, "GNU F95") == 0)
12160     language = DW_LANG_Fortran95;
12161   else if (strcmp (language_string, "GNU Pascal") == 0)
12162     language = DW_LANG_Pascal83;
12163   else if (strcmp (language_string, "GNU Java") == 0)
12164     language = DW_LANG_Java;
12165   else
12166     language = DW_LANG_C89;
12167
12168   add_AT_unsigned (die, DW_AT_language, language);
12169   return die;
12170 }
12171
12172 /* Generate the DIE for a base class.  */
12173
12174 static void
12175 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12176 {
12177   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12178
12179   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12180   add_data_member_location_attribute (die, binfo);
12181
12182   if (BINFO_VIRTUAL_P (binfo))
12183     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12184
12185   if (access == access_public_node)
12186     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12187   else if (access == access_protected_node)
12188     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12189 }
12190
12191 /* Generate a DIE for a class member.  */
12192
12193 static void
12194 gen_member_die (tree type, dw_die_ref context_die)
12195 {
12196   tree member;
12197   tree binfo = TYPE_BINFO (type);
12198   dw_die_ref child;
12199
12200   /* If this is not an incomplete type, output descriptions of each of its
12201      members. Note that as we output the DIEs necessary to represent the
12202      members of this record or union type, we will also be trying to output
12203      DIEs to represent the *types* of those members. However the `type'
12204      function (above) will specifically avoid generating type DIEs for member
12205      types *within* the list of member DIEs for this (containing) type except
12206      for those types (of members) which are explicitly marked as also being
12207      members of this (containing) type themselves.  The g++ front- end can
12208      force any given type to be treated as a member of some other (containing)
12209      type by setting the TYPE_CONTEXT of the given (member) type to point to
12210      the TREE node representing the appropriate (containing) type.  */
12211
12212   /* First output info about the base classes.  */
12213   if (binfo)
12214     {
12215       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12216       int i;
12217       tree base;
12218
12219       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12220         gen_inheritance_die (base,
12221                              (accesses ? VEC_index (tree, accesses, i)
12222                               : access_public_node), context_die);
12223     }
12224
12225   /* Now output info about the data members and type members.  */
12226   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12227     {
12228       /* If we thought we were generating minimal debug info for TYPE
12229          and then changed our minds, some of the member declarations
12230          may have already been defined.  Don't define them again, but
12231          do put them in the right order.  */
12232
12233       child = lookup_decl_die (member);
12234       if (child)
12235         splice_child_die (context_die, child);
12236       else
12237         gen_decl_die (member, context_die);
12238     }
12239
12240   /* Now output info about the function members (if any).  */
12241   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12242     {
12243       /* Don't include clones in the member list.  */
12244       if (DECL_ABSTRACT_ORIGIN (member))
12245         continue;
12246
12247       child = lookup_decl_die (member);
12248       if (child)
12249         splice_child_die (context_die, child);
12250       else
12251         gen_decl_die (member, context_die);
12252     }
12253 }
12254
12255 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
12256    is set, we pretend that the type was never defined, so we only get the
12257    member DIEs needed by later specification DIEs.  */
12258
12259 static void
12260 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12261 {
12262   dw_die_ref type_die = lookup_type_die (type);
12263   dw_die_ref scope_die = 0;
12264   int nested = 0;
12265   int complete = (TYPE_SIZE (type)
12266                   && (! TYPE_STUB_DECL (type)
12267                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12268   int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12269
12270   if (type_die && ! complete)
12271     return;
12272
12273   if (TYPE_CONTEXT (type) != NULL_TREE
12274       && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12275           || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12276     nested = 1;
12277
12278   scope_die = scope_die_for (type, context_die);
12279
12280   if (! type_die || (nested && scope_die == comp_unit_die))
12281     /* First occurrence of type or toplevel definition of nested class.  */
12282     {
12283       dw_die_ref old_die = type_die;
12284
12285       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12286                           ? DW_TAG_structure_type : DW_TAG_union_type,
12287                           scope_die, type);
12288       equate_type_number_to_die (type, type_die);
12289       if (old_die)
12290         add_AT_specification (type_die, old_die);
12291       else
12292         add_name_attribute (type_die, type_tag (type));
12293     }
12294   else
12295     remove_AT (type_die, DW_AT_declaration);
12296
12297   /* If this type has been completed, then give it a byte_size attribute and
12298      then give a list of members.  */
12299   if (complete && !ns_decl)
12300     {
12301       /* Prevent infinite recursion in cases where the type of some member of
12302          this type is expressed in terms of this type itself.  */
12303       TREE_ASM_WRITTEN (type) = 1;
12304       add_byte_size_attribute (type_die, type);
12305       if (TYPE_STUB_DECL (type) != NULL_TREE)
12306         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12307
12308       /* If the first reference to this type was as the return type of an
12309          inline function, then it may not have a parent.  Fix this now.  */
12310       if (type_die->die_parent == NULL)
12311         add_child_die (scope_die, type_die);
12312
12313       push_decl_scope (type);
12314       gen_member_die (type, type_die);
12315       pop_decl_scope ();
12316
12317       /* GNU extension: Record what type our vtable lives in.  */
12318       if (TYPE_VFIELD (type))
12319         {
12320           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12321
12322           gen_type_die (vtype, context_die);
12323           add_AT_die_ref (type_die, DW_AT_containing_type,
12324                           lookup_type_die (vtype));
12325         }
12326     }
12327   else
12328     {
12329       add_AT_flag (type_die, DW_AT_declaration, 1);
12330
12331       /* We don't need to do this for function-local types.  */
12332       if (TYPE_STUB_DECL (type)
12333           && ! decl_function_context (TYPE_STUB_DECL (type)))
12334         VEC_safe_push (tree, gc, incomplete_types, type);
12335     }
12336 }
12337
12338 /* Generate a DIE for a subroutine _type_.  */
12339
12340 static void
12341 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12342 {
12343   tree return_type = TREE_TYPE (type);
12344   dw_die_ref subr_die
12345     = new_die (DW_TAG_subroutine_type,
12346                scope_die_for (type, context_die), type);
12347
12348   equate_type_number_to_die (type, subr_die);
12349   add_prototyped_attribute (subr_die, type);
12350   add_type_attribute (subr_die, return_type, 0, 0, context_die);
12351   gen_formal_types_die (type, subr_die);
12352 }
12353
12354 /* Generate a DIE for a type definition.  */
12355
12356 static void
12357 gen_typedef_die (tree decl, dw_die_ref context_die)
12358 {
12359   dw_die_ref type_die;
12360   tree origin;
12361
12362   if (TREE_ASM_WRITTEN (decl))
12363     return;
12364
12365   TREE_ASM_WRITTEN (decl) = 1;
12366   type_die = new_die (DW_TAG_typedef, context_die, decl);
12367   origin = decl_ultimate_origin (decl);
12368   if (origin != NULL)
12369     add_abstract_origin_attribute (type_die, origin);
12370   else
12371     {
12372       tree type;
12373
12374       add_name_and_src_coords_attributes (type_die, decl);
12375       if (DECL_ORIGINAL_TYPE (decl))
12376         {
12377           type = DECL_ORIGINAL_TYPE (decl);
12378
12379           gcc_assert (type != TREE_TYPE (decl));
12380           equate_type_number_to_die (TREE_TYPE (decl), type_die);
12381         }
12382       else
12383         type = TREE_TYPE (decl);
12384
12385       add_type_attribute (type_die, type, TREE_READONLY (decl),
12386                           TREE_THIS_VOLATILE (decl), context_die);
12387     }
12388
12389   if (DECL_ABSTRACT (decl))
12390     equate_decl_number_to_die (decl, type_die);
12391 }
12392
12393 /* Generate a type description DIE.  */
12394
12395 static void
12396 gen_type_die (tree type, dw_die_ref context_die)
12397 {
12398   int need_pop;
12399
12400   if (type == NULL_TREE || type == error_mark_node)
12401     return;
12402
12403   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12404       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12405     {
12406       if (TREE_ASM_WRITTEN (type))
12407         return;
12408
12409       /* Prevent broken recursion; we can't hand off to the same type.  */
12410       gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12411
12412       TREE_ASM_WRITTEN (type) = 1;
12413       gen_decl_die (TYPE_NAME (type), context_die);
12414       return;
12415     }
12416
12417   /* We are going to output a DIE to represent the unqualified version
12418      of this type (i.e. without any const or volatile qualifiers) so
12419      get the main variant (i.e. the unqualified version) of this type
12420      now.  (Vectors are special because the debugging info is in the
12421      cloned type itself).  */
12422   if (TREE_CODE (type) != VECTOR_TYPE)
12423     type = type_main_variant (type);
12424
12425   if (TREE_ASM_WRITTEN (type))
12426     return;
12427
12428   switch (TREE_CODE (type))
12429     {
12430     case ERROR_MARK:
12431       break;
12432
12433     case POINTER_TYPE:
12434     case REFERENCE_TYPE:
12435       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
12436          ensures that the gen_type_die recursion will terminate even if the
12437          type is recursive.  Recursive types are possible in Ada.  */
12438       /* ??? We could perhaps do this for all types before the switch
12439          statement.  */
12440       TREE_ASM_WRITTEN (type) = 1;
12441
12442       /* For these types, all that is required is that we output a DIE (or a
12443          set of DIEs) to represent the "basis" type.  */
12444       gen_type_die (TREE_TYPE (type), context_die);
12445       break;
12446
12447     case OFFSET_TYPE:
12448       /* This code is used for C++ pointer-to-data-member types.
12449          Output a description of the relevant class type.  */
12450       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12451
12452       /* Output a description of the type of the object pointed to.  */
12453       gen_type_die (TREE_TYPE (type), context_die);
12454
12455       /* Now output a DIE to represent this pointer-to-data-member type
12456          itself.  */
12457       gen_ptr_to_mbr_type_die (type, context_die);
12458       break;
12459
12460     case FUNCTION_TYPE:
12461       /* Force out return type (in case it wasn't forced out already).  */
12462       gen_type_die (TREE_TYPE (type), context_die);
12463       gen_subroutine_type_die (type, context_die);
12464       break;
12465
12466     case METHOD_TYPE:
12467       /* Force out return type (in case it wasn't forced out already).  */
12468       gen_type_die (TREE_TYPE (type), context_die);
12469       gen_subroutine_type_die (type, context_die);
12470       break;
12471
12472     case ARRAY_TYPE:
12473       gen_array_type_die (type, context_die);
12474       break;
12475
12476     case VECTOR_TYPE:
12477       gen_array_type_die (type, context_die);
12478       break;
12479
12480     case ENUMERAL_TYPE:
12481     case RECORD_TYPE:
12482     case UNION_TYPE:
12483     case QUAL_UNION_TYPE:
12484       /* If this is a nested type whose containing class hasn't been written
12485          out yet, writing it out will cover this one, too.  This does not apply
12486          to instantiations of member class templates; they need to be added to
12487          the containing class as they are generated.  FIXME: This hurts the
12488          idea of combining type decls from multiple TUs, since we can't predict
12489          what set of template instantiations we'll get.  */
12490       if (TYPE_CONTEXT (type)
12491           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12492           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12493         {
12494           gen_type_die (TYPE_CONTEXT (type), context_die);
12495
12496           if (TREE_ASM_WRITTEN (type))
12497             return;
12498
12499           /* If that failed, attach ourselves to the stub.  */
12500           push_decl_scope (TYPE_CONTEXT (type));
12501           context_die = lookup_type_die (TYPE_CONTEXT (type));
12502           need_pop = 1;
12503         }
12504       else
12505         {
12506           declare_in_namespace (type, context_die);
12507           need_pop = 0;
12508         }
12509
12510       if (TREE_CODE (type) == ENUMERAL_TYPE)
12511         gen_enumeration_type_die (type, context_die);
12512       else
12513         gen_struct_or_union_type_die (type, context_die);
12514
12515       if (need_pop)
12516         pop_decl_scope ();
12517
12518       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12519          it up if it is ever completed.  gen_*_type_die will set it for us
12520          when appropriate.  */
12521       return;
12522
12523     case VOID_TYPE:
12524     case INTEGER_TYPE:
12525     case REAL_TYPE:
12526     case COMPLEX_TYPE:
12527     case BOOLEAN_TYPE:
12528       /* No DIEs needed for fundamental types.  */
12529       break;
12530
12531     case LANG_TYPE:
12532       /* No Dwarf representation currently defined.  */
12533       break;
12534
12535     default:
12536       gcc_unreachable ();
12537     }
12538
12539   TREE_ASM_WRITTEN (type) = 1;
12540 }
12541
12542 /* Generate a DIE for a tagged type instantiation.  */
12543
12544 static void
12545 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12546 {
12547   if (type == NULL_TREE || type == error_mark_node)
12548     return;
12549
12550   /* We are going to output a DIE to represent the unqualified version of
12551      this type (i.e. without any const or volatile qualifiers) so make sure
12552      that we have the main variant (i.e. the unqualified version) of this
12553      type now.  */
12554   gcc_assert (type == type_main_variant (type));
12555
12556   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12557      an instance of an unresolved type.  */
12558
12559   switch (TREE_CODE (type))
12560     {
12561     case ERROR_MARK:
12562       break;
12563
12564     case ENUMERAL_TYPE:
12565       gen_inlined_enumeration_type_die (type, context_die);
12566       break;
12567
12568     case RECORD_TYPE:
12569       gen_inlined_structure_type_die (type, context_die);
12570       break;
12571
12572     case UNION_TYPE:
12573     case QUAL_UNION_TYPE:
12574       gen_inlined_union_type_die (type, context_die);
12575       break;
12576
12577     default:
12578       gcc_unreachable ();
12579     }
12580 }
12581
12582 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12583    things which are local to the given block.  */
12584
12585 static void
12586 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12587 {
12588   int must_output_die = 0;
12589   tree origin;
12590   tree decl;
12591   enum tree_code origin_code;
12592
12593   /* Ignore blocks that are NULL.  */
12594   if (stmt == NULL_TREE)
12595     return;
12596
12597   /* If the block is one fragment of a non-contiguous block, do not
12598      process the variables, since they will have been done by the
12599      origin block.  Do process subblocks.  */
12600   if (BLOCK_FRAGMENT_ORIGIN (stmt))
12601     {
12602       tree sub;
12603
12604       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12605         gen_block_die (sub, context_die, depth + 1);
12606
12607       return;
12608     }
12609
12610   /* Determine the "ultimate origin" of this block.  This block may be an
12611      inlined instance of an inlined instance of inline function, so we have
12612      to trace all of the way back through the origin chain to find out what
12613      sort of node actually served as the original seed for the creation of
12614      the current block.  */
12615   origin = block_ultimate_origin (stmt);
12616   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12617
12618   /* Determine if we need to output any Dwarf DIEs at all to represent this
12619      block.  */
12620   if (origin_code == FUNCTION_DECL)
12621     /* The outer scopes for inlinings *must* always be represented.  We
12622        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
12623     must_output_die = 1;
12624   else
12625     {
12626       /* In the case where the current block represents an inlining of the
12627          "body block" of an inline function, we must *NOT* output any DIE for
12628          this block because we have already output a DIE to represent the whole
12629          inlined function scope and the "body block" of any function doesn't
12630          really represent a different scope according to ANSI C rules.  So we
12631          check here to make sure that this block does not represent a "body
12632          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
12633       if (! is_body_block (origin ? origin : stmt))
12634         {
12635           /* Determine if this block directly contains any "significant"
12636              local declarations which we will need to output DIEs for.  */
12637           if (debug_info_level > DINFO_LEVEL_TERSE)
12638             /* We are not in terse mode so *any* local declaration counts
12639                as being a "significant" one.  */
12640             must_output_die = (BLOCK_VARS (stmt) != NULL
12641                                && (TREE_USED (stmt)
12642                                    || TREE_ASM_WRITTEN (stmt)
12643                                    || BLOCK_ABSTRACT (stmt)));
12644           else
12645             /* We are in terse mode, so only local (nested) function
12646                definitions count as "significant" local declarations.  */
12647             for (decl = BLOCK_VARS (stmt);
12648                  decl != NULL; decl = TREE_CHAIN (decl))
12649               if (TREE_CODE (decl) == FUNCTION_DECL
12650                   && DECL_INITIAL (decl))
12651                 {
12652                   must_output_die = 1;
12653                   break;
12654                 }
12655         }
12656     }
12657
12658   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12659      DIE for any block which contains no significant local declarations at
12660      all.  Rather, in such cases we just call `decls_for_scope' so that any
12661      needed Dwarf info for any sub-blocks will get properly generated. Note
12662      that in terse mode, our definition of what constitutes a "significant"
12663      local declaration gets restricted to include only inlined function
12664      instances and local (nested) function definitions.  */
12665   if (must_output_die)
12666     {
12667       if (origin_code == FUNCTION_DECL)
12668         gen_inlined_subroutine_die (stmt, context_die, depth);
12669       else
12670         gen_lexical_block_die (stmt, context_die, depth);
12671     }
12672   else
12673     decls_for_scope (stmt, context_die, depth);
12674 }
12675
12676 /* Generate all of the decls declared within a given scope and (recursively)
12677    all of its sub-blocks.  */
12678
12679 static void
12680 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12681 {
12682   tree decl;
12683   tree subblocks;
12684
12685   /* Ignore NULL blocks.  */
12686   if (stmt == NULL_TREE)
12687     return;
12688
12689   if (TREE_USED (stmt))
12690     {
12691       /* Output the DIEs to represent all of the data objects and typedefs
12692          declared directly within this block but not within any nested
12693          sub-blocks.  Also, nested function and tag DIEs have been
12694          generated with a parent of NULL; fix that up now.  */
12695       for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12696         {
12697           dw_die_ref die;
12698
12699           if (TREE_CODE (decl) == FUNCTION_DECL)
12700             die = lookup_decl_die (decl);
12701           else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12702             die = lookup_type_die (TREE_TYPE (decl));
12703           else
12704             die = NULL;
12705
12706           if (die != NULL && die->die_parent == NULL)
12707             add_child_die (context_die, die);
12708           /* Do not produce debug information for static variables since
12709              these might be optimized out.  We are called for these later
12710              in cgraph_varpool_analyze_pending_decls. */
12711           if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12712             ;
12713           else
12714             gen_decl_die (decl, context_die);
12715         }
12716     }
12717
12718   /* If we're at -g1, we're not interested in subblocks.  */
12719   if (debug_info_level <= DINFO_LEVEL_TERSE)
12720     return;
12721
12722   /* Output the DIEs to represent all sub-blocks (and the items declared
12723      therein) of this block.  */
12724   for (subblocks = BLOCK_SUBBLOCKS (stmt);
12725        subblocks != NULL;
12726        subblocks = BLOCK_CHAIN (subblocks))
12727     gen_block_die (subblocks, context_die, depth + 1);
12728 }
12729
12730 /* Is this a typedef we can avoid emitting?  */
12731
12732 static inline int
12733 is_redundant_typedef (tree decl)
12734 {
12735   if (TYPE_DECL_IS_STUB (decl))
12736     return 1;
12737
12738   if (DECL_ARTIFICIAL (decl)
12739       && DECL_CONTEXT (decl)
12740       && is_tagged_type (DECL_CONTEXT (decl))
12741       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12742       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12743     /* Also ignore the artificial member typedef for the class name.  */
12744     return 1;
12745
12746   return 0;
12747 }
12748
12749 /* Returns the DIE for decl.  A DIE will always be returned.  */
12750
12751 static dw_die_ref
12752 force_decl_die (tree decl)
12753 {
12754   dw_die_ref decl_die;
12755   unsigned saved_external_flag;
12756   tree save_fn = NULL_TREE;
12757   decl_die = lookup_decl_die (decl);
12758   if (!decl_die)
12759     {
12760       dw_die_ref context_die;
12761       tree decl_context = DECL_CONTEXT (decl);
12762       if (decl_context)
12763         {
12764           /* Find die that represents this context.  */
12765           if (TYPE_P (decl_context))
12766             context_die = force_type_die (decl_context);
12767           else
12768             context_die = force_decl_die (decl_context);
12769         }
12770       else
12771         context_die = comp_unit_die;
12772
12773       decl_die = lookup_decl_die (decl);
12774       if (decl_die)
12775         return decl_die;
12776
12777       switch (TREE_CODE (decl))
12778         {
12779         case FUNCTION_DECL:
12780           /* Clear current_function_decl, so that gen_subprogram_die thinks
12781              that this is a declaration. At this point, we just want to force
12782              declaration die.  */
12783           save_fn = current_function_decl;
12784           current_function_decl = NULL_TREE;
12785           gen_subprogram_die (decl, context_die);
12786           current_function_decl = save_fn;
12787           break;
12788
12789         case VAR_DECL:
12790           /* Set external flag to force declaration die. Restore it after
12791            gen_decl_die() call.  */
12792           saved_external_flag = DECL_EXTERNAL (decl);
12793           DECL_EXTERNAL (decl) = 1;
12794           gen_decl_die (decl, context_die);
12795           DECL_EXTERNAL (decl) = saved_external_flag;
12796           break;
12797
12798         case NAMESPACE_DECL:
12799           dwarf2out_decl (decl);
12800           break;
12801
12802         default:
12803           gcc_unreachable ();
12804         }
12805
12806       /* We should be able to find the DIE now.  */
12807       if (!decl_die)
12808         decl_die = lookup_decl_die (decl);
12809       gcc_assert (decl_die);
12810     }
12811
12812   return decl_die;
12813 }
12814
12815 /* Returns the DIE for TYPE.  A DIE is always returned.  */
12816
12817 static dw_die_ref
12818 force_type_die (tree type)
12819 {
12820   dw_die_ref type_die;
12821
12822   type_die = lookup_type_die (type);
12823   if (!type_die)
12824     {
12825       dw_die_ref context_die;
12826       if (TYPE_CONTEXT (type))
12827         {
12828           if (TYPE_P (TYPE_CONTEXT (type)))
12829             context_die = force_type_die (TYPE_CONTEXT (type));
12830           else
12831             context_die = force_decl_die (TYPE_CONTEXT (type));
12832         }
12833       else
12834         context_die = comp_unit_die;
12835
12836       type_die = lookup_type_die (type);
12837       if (type_die)
12838         return type_die;
12839       gen_type_die (type, context_die);
12840       type_die = lookup_type_die (type);
12841       gcc_assert (type_die);
12842     }
12843   return type_die;
12844 }
12845
12846 /* Force out any required namespaces to be able to output DECL,
12847    and return the new context_die for it, if it's changed.  */
12848
12849 static dw_die_ref
12850 setup_namespace_context (tree thing, dw_die_ref context_die)
12851 {
12852   tree context = (DECL_P (thing)
12853                   ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
12854   if (context && TREE_CODE (context) == NAMESPACE_DECL)
12855     /* Force out the namespace.  */
12856     context_die = force_decl_die (context);
12857
12858   return context_die;
12859 }
12860
12861 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
12862    type) within its namespace, if appropriate.
12863
12864    For compatibility with older debuggers, namespace DIEs only contain
12865    declarations; all definitions are emitted at CU scope.  */
12866
12867 static void
12868 declare_in_namespace (tree thing, dw_die_ref context_die)
12869 {
12870   dw_die_ref ns_context;
12871
12872   if (debug_info_level <= DINFO_LEVEL_TERSE)
12873     return;
12874
12875   /* If this decl is from an inlined function, then don't try to emit it in its
12876      namespace, as we will get confused.  It would have already been emitted
12877      when the abstract instance of the inline function was emitted anyways.  */
12878   if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
12879     return;
12880
12881   ns_context = setup_namespace_context (thing, context_die);
12882
12883   if (ns_context != context_die)
12884     {
12885       if (DECL_P (thing))
12886         gen_decl_die (thing, ns_context);
12887       else
12888         gen_type_die (thing, ns_context);
12889     }
12890 }
12891
12892 /* Generate a DIE for a namespace or namespace alias.  */
12893
12894 static void
12895 gen_namespace_die (tree decl)
12896 {
12897   dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
12898
12899   /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
12900      they are an alias of.  */
12901   if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
12902     {
12903       /* Output a real namespace.  */
12904       dw_die_ref namespace_die
12905         = new_die (DW_TAG_namespace, context_die, decl);
12906       add_name_and_src_coords_attributes (namespace_die, decl);
12907       equate_decl_number_to_die (decl, namespace_die);
12908     }
12909   else
12910     {
12911       /* Output a namespace alias.  */
12912
12913       /* Force out the namespace we are an alias of, if necessary.  */
12914       dw_die_ref origin_die
12915         = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
12916
12917       /* Now create the namespace alias DIE.  */
12918       dw_die_ref namespace_die
12919         = new_die (DW_TAG_imported_declaration, context_die, decl);
12920       add_name_and_src_coords_attributes (namespace_die, decl);
12921       add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
12922       equate_decl_number_to_die (decl, namespace_die);
12923     }
12924 }
12925
12926 /* Generate Dwarf debug information for a decl described by DECL.  */
12927
12928 static void
12929 gen_decl_die (tree decl, dw_die_ref context_die)
12930 {
12931   tree origin;
12932
12933   if (DECL_P (decl) && DECL_IGNORED_P (decl))
12934     return;
12935
12936   switch (TREE_CODE (decl))
12937     {
12938     case ERROR_MARK:
12939       break;
12940
12941     case CONST_DECL:
12942       /* The individual enumerators of an enum type get output when we output
12943          the Dwarf representation of the relevant enum type itself.  */
12944       break;
12945
12946     case FUNCTION_DECL:
12947       /* Don't output any DIEs to represent mere function declarations,
12948          unless they are class members or explicit block externs.  */
12949       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
12950           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
12951         break;
12952
12953 #if 0
12954       /* FIXME */
12955       /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
12956          on local redeclarations of global functions.  That seems broken.  */
12957       if (current_function_decl != decl)
12958         /* This is only a declaration.  */;
12959 #endif
12960
12961       /* If we're emitting a clone, emit info for the abstract instance.  */
12962       if (DECL_ORIGIN (decl) != decl)
12963         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
12964
12965       /* If we're emitting an out-of-line copy of an inline function,
12966          emit info for the abstract instance and set up to refer to it.  */
12967       else if (cgraph_function_possibly_inlined_p (decl)
12968                && ! DECL_ABSTRACT (decl)
12969                && ! class_or_namespace_scope_p (context_die)
12970                /* dwarf2out_abstract_function won't emit a die if this is just
12971                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
12972                   that case, because that works only if we have a die.  */
12973                && DECL_INITIAL (decl) != NULL_TREE)
12974         {
12975           dwarf2out_abstract_function (decl);
12976           set_decl_origin_self (decl);
12977         }
12978
12979       /* Otherwise we're emitting the primary DIE for this decl.  */
12980       else if (debug_info_level > DINFO_LEVEL_TERSE)
12981         {
12982           /* Before we describe the FUNCTION_DECL itself, make sure that we
12983              have described its return type.  */
12984           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
12985
12986           /* And its virtual context.  */
12987           if (DECL_VINDEX (decl) != NULL_TREE)
12988             gen_type_die (DECL_CONTEXT (decl), context_die);
12989
12990           /* And its containing type.  */
12991           origin = decl_class_context (decl);
12992           if (origin != NULL_TREE)
12993             gen_type_die_for_member (origin, decl, context_die);
12994
12995           /* And its containing namespace.  */
12996           declare_in_namespace (decl, context_die);
12997         }
12998
12999       /* Now output a DIE to represent the function itself.  */
13000       gen_subprogram_die (decl, context_die);
13001       break;
13002
13003     case TYPE_DECL:
13004       /* If we are in terse mode, don't generate any DIEs to represent any
13005          actual typedefs.  */
13006       if (debug_info_level <= DINFO_LEVEL_TERSE)
13007         break;
13008
13009       /* In the special case of a TYPE_DECL node representing the declaration
13010          of some type tag, if the given TYPE_DECL is marked as having been
13011          instantiated from some other (original) TYPE_DECL node (e.g. one which
13012          was generated within the original definition of an inline function) we
13013          have to generate a special (abbreviated) DW_TAG_structure_type,
13014          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
13015       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
13016         {
13017           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13018           break;
13019         }
13020
13021       if (is_redundant_typedef (decl))
13022         gen_type_die (TREE_TYPE (decl), context_die);
13023       else
13024         /* Output a DIE to represent the typedef itself.  */
13025         gen_typedef_die (decl, context_die);
13026       break;
13027
13028     case LABEL_DECL:
13029       if (debug_info_level >= DINFO_LEVEL_NORMAL)
13030         gen_label_die (decl, context_die);
13031       break;
13032
13033     case VAR_DECL:
13034     case RESULT_DECL:
13035       /* If we are in terse mode, don't generate any DIEs to represent any
13036          variable declarations or definitions.  */
13037       if (debug_info_level <= DINFO_LEVEL_TERSE)
13038         break;
13039
13040       /* Output any DIEs that are needed to specify the type of this data
13041          object.  */
13042       gen_type_die (TREE_TYPE (decl), context_die);
13043
13044       /* And its containing type.  */
13045       origin = decl_class_context (decl);
13046       if (origin != NULL_TREE)
13047         gen_type_die_for_member (origin, decl, context_die);
13048
13049       /* And its containing namespace.  */
13050       declare_in_namespace (decl, context_die);
13051
13052       /* Now output the DIE to represent the data object itself.  This gets
13053          complicated because of the possibility that the VAR_DECL really
13054          represents an inlined instance of a formal parameter for an inline
13055          function.  */
13056       origin = decl_ultimate_origin (decl);
13057       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13058         gen_formal_parameter_die (decl, context_die);
13059       else
13060         gen_variable_die (decl, context_die);
13061       break;
13062
13063     case FIELD_DECL:
13064       /* Ignore the nameless fields that are used to skip bits but handle C++
13065          anonymous unions and structs.  */
13066       if (DECL_NAME (decl) != NULL_TREE
13067           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13068           || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13069         {
13070           gen_type_die (member_declared_type (decl), context_die);
13071           gen_field_die (decl, context_die);
13072         }
13073       break;
13074
13075     case PARM_DECL:
13076       gen_type_die (TREE_TYPE (decl), context_die);
13077       gen_formal_parameter_die (decl, context_die);
13078       break;
13079
13080     case NAMESPACE_DECL:
13081       gen_namespace_die (decl);
13082       break;
13083
13084     default:
13085       /* Probably some frontend-internal decl.  Assume we don't care.  */
13086       gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13087       break;
13088     }
13089 }
13090 \f
13091 /* Output debug information for global decl DECL.  Called from toplev.c after
13092    compilation proper has finished.  */
13093
13094 static void
13095 dwarf2out_global_decl (tree decl)
13096 {
13097   /* Output DWARF2 information for file-scope tentative data object
13098      declarations, file-scope (extern) function declarations (which had no
13099      corresponding body) and file-scope tagged type declarations and
13100      definitions which have not yet been forced out.  */
13101   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13102     dwarf2out_decl (decl);
13103 }
13104
13105 /* Output debug information for type decl DECL.  Called from toplev.c
13106    and from language front ends (to record built-in types).  */
13107 static void
13108 dwarf2out_type_decl (tree decl, int local)
13109 {
13110   if (!local)
13111     dwarf2out_decl (decl);
13112 }
13113
13114 /* Output debug information for imported module or decl.  */
13115
13116 static void
13117 dwarf2out_imported_module_or_decl (tree decl, tree context)
13118 {
13119   dw_die_ref imported_die, at_import_die;
13120   dw_die_ref scope_die;
13121   unsigned file_index;
13122   expanded_location xloc;
13123
13124   if (debug_info_level <= DINFO_LEVEL_TERSE)
13125     return;
13126
13127   gcc_assert (decl);
13128
13129   /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13130      We need decl DIE for reference and scope die. First, get DIE for the decl
13131      itself.  */
13132
13133   /* Get the scope die for decl context. Use comp_unit_die for global module
13134      or decl. If die is not found for non globals, force new die.  */
13135   if (!context)
13136     scope_die = comp_unit_die;
13137   else if (TYPE_P (context))
13138     scope_die = force_type_die (context);
13139   else
13140     scope_die = force_decl_die (context);
13141
13142   /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE.  */
13143   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13144     at_import_die = force_type_die (TREE_TYPE (decl));
13145   else
13146     {
13147       at_import_die = lookup_decl_die (decl);
13148       if (!at_import_die)
13149         {
13150           /* If we're trying to avoid duplicate debug info, we may not have
13151              emitted the member decl for this field.  Emit it now.  */
13152           if (TREE_CODE (decl) == FIELD_DECL)
13153             {
13154               tree type = DECL_CONTEXT (decl);
13155               dw_die_ref type_context_die;
13156
13157               if (TYPE_CONTEXT (type))
13158                 if (TYPE_P (TYPE_CONTEXT (type)))
13159                   type_context_die = force_type_die (TYPE_CONTEXT (type));
13160               else
13161                 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13162               else
13163                 type_context_die = comp_unit_die;
13164               gen_type_die_for_member (type, decl, type_context_die);
13165             }
13166           at_import_die = force_decl_die (decl);
13167         }
13168     }
13169
13170   /* OK, now we have DIEs for decl as well as scope. Emit imported die.  */
13171   if (TREE_CODE (decl) == NAMESPACE_DECL)
13172     imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13173   else
13174     imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13175
13176   xloc = expand_location (input_location);
13177   file_index = lookup_filename (xloc.file);
13178   add_AT_unsigned (imported_die, DW_AT_decl_file, file_index);
13179   add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13180   add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13181 }
13182
13183 /* Write the debugging output for DECL.  */
13184
13185 void
13186 dwarf2out_decl (tree decl)
13187 {
13188   dw_die_ref context_die = comp_unit_die;
13189
13190   switch (TREE_CODE (decl))
13191     {
13192     case ERROR_MARK:
13193       return;
13194
13195     case FUNCTION_DECL:
13196       /* What we would really like to do here is to filter out all mere
13197          file-scope declarations of file-scope functions which are never
13198          referenced later within this translation unit (and keep all of ones
13199          that *are* referenced later on) but we aren't clairvoyant, so we have
13200          no idea which functions will be referenced in the future (i.e. later
13201          on within the current translation unit). So here we just ignore all
13202          file-scope function declarations which are not also definitions.  If
13203          and when the debugger needs to know something about these functions,
13204          it will have to hunt around and find the DWARF information associated
13205          with the definition of the function.
13206
13207          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13208          nodes represent definitions and which ones represent mere
13209          declarations.  We have to check DECL_INITIAL instead. That's because
13210          the C front-end supports some weird semantics for "extern inline"
13211          function definitions.  These can get inlined within the current
13212          translation unit (and thus, we need to generate Dwarf info for their
13213          abstract instances so that the Dwarf info for the concrete inlined
13214          instances can have something to refer to) but the compiler never
13215          generates any out-of-lines instances of such things (despite the fact
13216          that they *are* definitions).
13217
13218          The important point is that the C front-end marks these "extern
13219          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13220          them anyway. Note that the C++ front-end also plays some similar games
13221          for inline function definitions appearing within include files which
13222          also contain `#pragma interface' pragmas.  */
13223       if (DECL_INITIAL (decl) == NULL_TREE)
13224         return;
13225
13226       /* If we're a nested function, initially use a parent of NULL; if we're
13227          a plain function, this will be fixed up in decls_for_scope.  If
13228          we're a method, it will be ignored, since we already have a DIE.  */
13229       if (decl_function_context (decl)
13230           /* But if we're in terse mode, we don't care about scope.  */
13231           && debug_info_level > DINFO_LEVEL_TERSE)
13232         context_die = NULL;
13233       break;
13234
13235     case VAR_DECL:
13236       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13237          declaration and if the declaration was never even referenced from
13238          within this entire compilation unit.  We suppress these DIEs in
13239          order to save space in the .debug section (by eliminating entries
13240          which are probably useless).  Note that we must not suppress
13241          block-local extern declarations (whether used or not) because that
13242          would screw-up the debugger's name lookup mechanism and cause it to
13243          miss things which really ought to be in scope at a given point.  */
13244       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13245         return;
13246
13247       /* For local statics lookup proper context die.  */
13248       if (TREE_STATIC (decl) && decl_function_context (decl))
13249         context_die = lookup_decl_die (DECL_CONTEXT (decl));
13250
13251       /* If we are in terse mode, don't generate any DIEs to represent any
13252          variable declarations or definitions.  */
13253       if (debug_info_level <= DINFO_LEVEL_TERSE)
13254         return;
13255       break;
13256
13257     case NAMESPACE_DECL:
13258       if (debug_info_level <= DINFO_LEVEL_TERSE)
13259         return;
13260       if (lookup_decl_die (decl) != NULL)
13261         return;
13262       break;
13263
13264     case TYPE_DECL:
13265       /* Don't emit stubs for types unless they are needed by other DIEs.  */
13266       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13267         return;
13268
13269       /* Don't bother trying to generate any DIEs to represent any of the
13270          normal built-in types for the language we are compiling.  */
13271       if (DECL_IS_BUILTIN (decl))
13272         {
13273           /* OK, we need to generate one for `bool' so GDB knows what type
13274              comparisons have.  */
13275           if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
13276                == DW_LANG_C_plus_plus)
13277               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13278               && ! DECL_IGNORED_P (decl))
13279             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13280
13281           return;
13282         }
13283
13284       /* If we are in terse mode, don't generate any DIEs for types.  */
13285       if (debug_info_level <= DINFO_LEVEL_TERSE)
13286         return;
13287
13288       /* If we're a function-scope tag, initially use a parent of NULL;
13289          this will be fixed up in decls_for_scope.  */
13290       if (decl_function_context (decl))
13291         context_die = NULL;
13292
13293       break;
13294
13295     default:
13296       return;
13297     }
13298
13299   gen_decl_die (decl, context_die);
13300 }
13301
13302 /* Output a marker (i.e. a label) for the beginning of the generated code for
13303    a lexical block.  */
13304
13305 static void
13306 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13307                        unsigned int blocknum)
13308 {
13309   switch_to_section (current_function_section ());
13310   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13311 }
13312
13313 /* Output a marker (i.e. a label) for the end of the generated code for a
13314    lexical block.  */
13315
13316 static void
13317 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13318 {
13319   switch_to_section (current_function_section ());
13320   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13321 }
13322
13323 /* Returns nonzero if it is appropriate not to emit any debugging
13324    information for BLOCK, because it doesn't contain any instructions.
13325
13326    Don't allow this for blocks with nested functions or local classes
13327    as we would end up with orphans, and in the presence of scheduling
13328    we may end up calling them anyway.  */
13329
13330 static bool
13331 dwarf2out_ignore_block (tree block)
13332 {
13333   tree decl;
13334
13335   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13336     if (TREE_CODE (decl) == FUNCTION_DECL
13337         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13338       return 0;
13339
13340   return 1;
13341 }
13342
13343 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13344    dwarf2out.c) and return its "index".  The index of each (known) filename is
13345    just a unique number which is associated with only that one filename.  We
13346    need such numbers for the sake of generating labels (in the .debug_sfnames
13347    section) and references to those files numbers (in the .debug_srcinfo
13348    and.debug_macinfo sections).  If the filename given as an argument is not
13349    found in our current list, add it to the list and assign it the next
13350    available unique index number.  In order to speed up searches, we remember
13351    the index of the filename was looked up last.  This handles the majority of
13352    all searches.  */
13353
13354 static unsigned
13355 lookup_filename (const char *file_name)
13356 {
13357   size_t i, n;
13358   char *save_file_name;
13359
13360   /* Check to see if the file name that was searched on the previous
13361      call matches this file name.  If so, return the index.  */
13362   if (file_table_last_lookup_index != 0)
13363     {
13364       const char *last
13365         = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
13366       if (strcmp (file_name, last) == 0)
13367         return file_table_last_lookup_index;
13368     }
13369
13370   /* Didn't match the previous lookup, search the table.  */
13371   n = VARRAY_ACTIVE_SIZE (file_table);
13372   for (i = 1; i < n; i++)
13373     if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
13374       {
13375         file_table_last_lookup_index = i;
13376         return i;
13377       }
13378
13379   /* Add the new entry to the end of the filename table.  */
13380   file_table_last_lookup_index = n;
13381   save_file_name = (char *) ggc_strdup (file_name);
13382   VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
13383   VARRAY_PUSH_UINT (file_table_emitted, 0);
13384
13385   /* If the assembler is emitting the file table, and we aren't eliminating
13386      unused debug types, then we must emit .file here.  If we are eliminating
13387      unused debug types, then this will be done by the maybe_emit_file call in
13388      prune_unused_types_walk_attribs.  */
13389
13390   if (DWARF2_ASM_LINE_DEBUG_INFO && ! flag_eliminate_unused_debug_types)
13391     return maybe_emit_file (i);
13392
13393   return i;
13394 }
13395
13396 /* If the assembler will construct the file table, then translate the compiler
13397    internal file table number into the assembler file table number, and emit
13398    a .file directive if we haven't already emitted one yet.  The file table
13399    numbers are different because we prune debug info for unused variables and
13400    types, which may include filenames.  */
13401
13402 static int
13403 maybe_emit_file (int fileno)
13404 {
13405   if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
13406     {
13407       if (!VARRAY_UINT (file_table_emitted, fileno))
13408         {
13409           VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
13410           fprintf (asm_out_file, "\t.file %u ",
13411                    VARRAY_UINT (file_table_emitted, fileno));
13412           output_quoted_string (asm_out_file,
13413                                 VARRAY_CHAR_PTR (file_table, fileno));
13414           fputc ('\n', asm_out_file);
13415         }
13416       return VARRAY_UINT (file_table_emitted, fileno);
13417     }
13418   else
13419     return fileno;
13420 }
13421
13422 /* Initialize the compiler internal file table.  */
13423
13424 static void
13425 init_file_table (void)
13426 {
13427   /* Allocate the initial hunk of the file_table.  */
13428   VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
13429   VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
13430
13431   /* Skip the first entry - file numbers begin at 1.  */
13432   VARRAY_PUSH_CHAR_PTR (file_table, NULL);
13433   VARRAY_PUSH_UINT (file_table_emitted, 0);
13434   file_table_last_lookup_index = 0;
13435 }
13436
13437 /* Called by the final INSN scan whenever we see a var location.  We
13438    use it to drop labels in the right places, and throw the location in
13439    our lookup table.  */
13440
13441 static void
13442 dwarf2out_var_location (rtx loc_note)
13443 {
13444   char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13445   struct var_loc_node *newloc;
13446   rtx prev_insn;
13447   static rtx last_insn;
13448   static const char *last_label;
13449   tree decl;
13450
13451   if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13452     return;
13453   prev_insn = PREV_INSN (loc_note);
13454
13455   newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13456   /* If the insn we processed last time is the previous insn
13457      and it is also a var location note, use the label we emitted
13458      last time.  */
13459   if (last_insn != NULL_RTX
13460       && last_insn == prev_insn
13461       && NOTE_P (prev_insn)
13462       && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13463     {
13464       newloc->label = last_label;
13465     }
13466   else
13467     {
13468       ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13469       ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13470       loclabel_num++;
13471       newloc->label = ggc_strdup (loclabel);
13472     }
13473   newloc->var_loc_note = loc_note;
13474   newloc->next = NULL;
13475
13476   if (cfun && in_cold_section_p)
13477     newloc->section_label = cfun->cold_section_label;
13478   else
13479     newloc->section_label = text_section_label;
13480
13481   last_insn = loc_note;
13482   last_label = newloc->label;
13483   decl = NOTE_VAR_LOCATION_DECL (loc_note);
13484   if (DECL_DEBUG_EXPR_IS_FROM (decl) && DECL_DEBUG_EXPR (decl)
13485       && DECL_P (DECL_DEBUG_EXPR (decl)))
13486     decl = DECL_DEBUG_EXPR (decl);
13487   add_var_loc_to_decl (decl, newloc);
13488 }
13489
13490 /* We need to reset the locations at the beginning of each
13491    function. We can't do this in the end_function hook, because the
13492    declarations that use the locations won't have been output when
13493    that hook is called.  Also compute have_multiple_function_sections here.  */
13494
13495 static void
13496 dwarf2out_begin_function (tree fun)
13497 {
13498   htab_empty (decl_loc_table);
13499
13500   if (function_section (fun) != text_section)
13501     have_multiple_function_sections = true;
13502 }
13503
13504 /* Output a label to mark the beginning of a source code line entry
13505    and record information relating to this source line, in
13506    'line_info_table' for later output of the .debug_line section.  */
13507
13508 static void
13509 dwarf2out_source_line (unsigned int line, const char *filename)
13510 {
13511   if (debug_info_level >= DINFO_LEVEL_NORMAL
13512       && line != 0)
13513     {
13514       switch_to_section (current_function_section ());
13515
13516       /* If requested, emit something human-readable.  */
13517       if (flag_debug_asm)
13518         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13519                  filename, line);
13520
13521       if (DWARF2_ASM_LINE_DEBUG_INFO)
13522         {
13523           unsigned file_num = lookup_filename (filename);
13524
13525           file_num = maybe_emit_file (file_num);
13526
13527           /* Emit the .loc directive understood by GNU as.  */
13528           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13529
13530           /* Indicate that line number info exists.  */
13531           line_info_table_in_use++;
13532         }
13533       else if (function_section (current_function_decl) != text_section)
13534         {
13535           dw_separate_line_info_ref line_info;
13536           targetm.asm_out.internal_label (asm_out_file, SEPARATE_LINE_CODE_LABEL,
13537                                      separate_line_info_table_in_use);
13538
13539           /* Expand the line info table if necessary.  */
13540           if (separate_line_info_table_in_use
13541               == separate_line_info_table_allocated)
13542             {
13543               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13544               separate_line_info_table
13545                 = ggc_realloc (separate_line_info_table,
13546                                separate_line_info_table_allocated
13547                                * sizeof (dw_separate_line_info_entry));
13548               memset (separate_line_info_table
13549                        + separate_line_info_table_in_use,
13550                       0,
13551                       (LINE_INFO_TABLE_INCREMENT
13552                        * sizeof (dw_separate_line_info_entry)));
13553             }
13554
13555           /* Add the new entry at the end of the line_info_table.  */
13556           line_info
13557             = &separate_line_info_table[separate_line_info_table_in_use++];
13558           line_info->dw_file_num = lookup_filename (filename);
13559           line_info->dw_line_num = line;
13560           line_info->function = current_function_funcdef_no;
13561         }
13562       else
13563         {
13564           dw_line_info_ref line_info;
13565
13566           targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13567                                      line_info_table_in_use);
13568
13569           /* Expand the line info table if necessary.  */
13570           if (line_info_table_in_use == line_info_table_allocated)
13571             {
13572               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13573               line_info_table
13574                 = ggc_realloc (line_info_table,
13575                                (line_info_table_allocated
13576                                 * sizeof (dw_line_info_entry)));
13577               memset (line_info_table + line_info_table_in_use, 0,
13578                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13579             }
13580
13581           /* Add the new entry at the end of the line_info_table.  */
13582           line_info = &line_info_table[line_info_table_in_use++];
13583           line_info->dw_file_num = lookup_filename (filename);
13584           line_info->dw_line_num = line;
13585         }
13586     }
13587 }
13588
13589 /* Record the beginning of a new source file.  */
13590
13591 static void
13592 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13593 {
13594   if (flag_eliminate_dwarf2_dups)
13595     {
13596       /* Record the beginning of the file for break_out_includes.  */
13597       dw_die_ref bincl_die;
13598
13599       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13600       add_AT_string (bincl_die, DW_AT_name, filename);
13601     }
13602
13603   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13604     {
13605       int fileno;
13606
13607       switch_to_section (debug_macinfo_section);
13608       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13609       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13610                                    lineno);
13611
13612       fileno = maybe_emit_file (lookup_filename (filename));
13613       dw2_asm_output_data_uleb128 (fileno, "Filename we just started");
13614     }
13615 }
13616
13617 /* Record the end of a source file.  */
13618
13619 static void
13620 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13621 {
13622   if (flag_eliminate_dwarf2_dups)
13623     /* Record the end of the file for break_out_includes.  */
13624     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13625
13626   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13627     {
13628       switch_to_section (debug_macinfo_section);
13629       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13630     }
13631 }
13632
13633 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
13634    the tail part of the directive line, i.e. the part which is past the
13635    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13636
13637 static void
13638 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13639                   const char *buffer ATTRIBUTE_UNUSED)
13640 {
13641   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13642     {
13643       switch_to_section (debug_macinfo_section);
13644       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13645       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13646       dw2_asm_output_nstring (buffer, -1, "The macro");
13647     }
13648 }
13649
13650 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
13651    the tail part of the directive line, i.e. the part which is past the
13652    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13653
13654 static void
13655 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13656                  const char *buffer ATTRIBUTE_UNUSED)
13657 {
13658   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13659     {
13660       switch_to_section (debug_macinfo_section);
13661       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13662       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13663       dw2_asm_output_nstring (buffer, -1, "The macro");
13664     }
13665 }
13666
13667 /* Set up for Dwarf output at the start of compilation.  */
13668
13669 static void
13670 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13671 {
13672   init_file_table ();
13673
13674   /* Allocate the decl_die_table.  */
13675   decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13676                                     decl_die_table_eq, NULL);
13677
13678   /* Allocate the decl_loc_table.  */
13679   decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13680                                     decl_loc_table_eq, NULL);
13681
13682   /* Allocate the initial hunk of the decl_scope_table.  */
13683   decl_scope_table = VEC_alloc (tree, gc, 256);
13684
13685   /* Allocate the initial hunk of the abbrev_die_table.  */
13686   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13687                                         * sizeof (dw_die_ref));
13688   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13689   /* Zero-th entry is allocated, but unused.  */
13690   abbrev_die_table_in_use = 1;
13691
13692   /* Allocate the initial hunk of the line_info_table.  */
13693   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13694                                        * sizeof (dw_line_info_entry));
13695   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13696
13697   /* Zero-th entry is allocated, but unused.  */
13698   line_info_table_in_use = 1;
13699
13700   /* Generate the initial DIE for the .debug section.  Note that the (string)
13701      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13702      will (typically) be a relative pathname and that this pathname should be
13703      taken as being relative to the directory from which the compiler was
13704      invoked when the given (base) source file was compiled.  We will fill
13705      in this value in dwarf2out_finish.  */
13706   comp_unit_die = gen_compile_unit_die (NULL);
13707
13708   incomplete_types = VEC_alloc (tree, gc, 64);
13709
13710   used_rtx_array = VEC_alloc (rtx, gc, 32);
13711
13712   debug_info_section = get_section (DEBUG_INFO_SECTION,
13713                                     SECTION_DEBUG, NULL);
13714   debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
13715                                       SECTION_DEBUG, NULL);
13716   debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
13717                                        SECTION_DEBUG, NULL);
13718   debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
13719                                        SECTION_DEBUG, NULL);
13720   debug_line_section = get_section (DEBUG_LINE_SECTION,
13721                                     SECTION_DEBUG, NULL);
13722   debug_loc_section = get_section (DEBUG_LOC_SECTION,
13723                                    SECTION_DEBUG, NULL);
13724   debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
13725                                         SECTION_DEBUG, NULL);
13726   debug_str_section = get_section (DEBUG_STR_SECTION,
13727                                    DEBUG_STR_SECTION_FLAGS, NULL);
13728   debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
13729                                       SECTION_DEBUG, NULL);
13730
13731   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13732   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13733                                DEBUG_ABBREV_SECTION_LABEL, 0);
13734   ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13735   ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13736                                COLD_TEXT_SECTION_LABEL, 0);
13737   ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13738
13739   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13740                                DEBUG_INFO_SECTION_LABEL, 0);
13741   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
13742                                DEBUG_LINE_SECTION_LABEL, 0);
13743   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
13744                                DEBUG_RANGES_SECTION_LABEL, 0);
13745   switch_to_section (debug_abbrev_section);
13746   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
13747   switch_to_section (debug_info_section);
13748   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
13749   switch_to_section (debug_line_section);
13750   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
13751
13752   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13753     {
13754       switch_to_section (debug_macinfo_section);
13755       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
13756                                    DEBUG_MACINFO_SECTION_LABEL, 0);
13757       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
13758     }
13759
13760   switch_to_section (text_section);
13761   ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
13762   if (flag_reorder_blocks_and_partition)
13763     {
13764       switch_to_section (unlikely_text_section ());
13765       ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
13766     }
13767 }
13768
13769 /* A helper function for dwarf2out_finish called through
13770    ht_forall.  Emit one queued .debug_str string.  */
13771
13772 static int
13773 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
13774 {
13775   struct indirect_string_node *node = (struct indirect_string_node *) *h;
13776
13777   if (node->form == DW_FORM_strp)
13778     {
13779       switch_to_section (debug_str_section);
13780       ASM_OUTPUT_LABEL (asm_out_file, node->label);
13781       assemble_string (node->str, strlen (node->str) + 1);
13782     }
13783
13784   return 1;
13785 }
13786
13787
13788
13789 /* Clear the marks for a die and its children.
13790    Be cool if the mark isn't set.  */
13791
13792 static void
13793 prune_unmark_dies (dw_die_ref die)
13794 {
13795   dw_die_ref c;
13796   die->die_mark = 0;
13797   for (c = die->die_child; c; c = c->die_sib)
13798     prune_unmark_dies (c);
13799 }
13800
13801
13802 /* Given DIE that we're marking as used, find any other dies
13803    it references as attributes and mark them as used.  */
13804
13805 static void
13806 prune_unused_types_walk_attribs (dw_die_ref die)
13807 {
13808   dw_attr_ref a;
13809
13810   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
13811     {
13812       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
13813         {
13814           /* A reference to another DIE.
13815              Make sure that it will get emitted.  */
13816           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
13817         }
13818       else if (a->dw_attr == DW_AT_decl_file || a->dw_attr == DW_AT_call_file)
13819         {
13820           /* A reference to a file.  Make sure the file name is emitted.  */
13821           a->dw_attr_val.v.val_unsigned =
13822             maybe_emit_file (a->dw_attr_val.v.val_unsigned);
13823         }
13824     }
13825 }
13826
13827
13828 /* Mark DIE as being used.  If DOKIDS is true, then walk down
13829    to DIE's children.  */
13830
13831 static void
13832 prune_unused_types_mark (dw_die_ref die, int dokids)
13833 {
13834   dw_die_ref c;
13835
13836   if (die->die_mark == 0)
13837     {
13838       /* We haven't done this node yet.  Mark it as used.  */
13839       die->die_mark = 1;
13840
13841       /* We also have to mark its parents as used.
13842          (But we don't want to mark our parents' kids due to this.)  */
13843       if (die->die_parent)
13844         prune_unused_types_mark (die->die_parent, 0);
13845
13846       /* Mark any referenced nodes.  */
13847       prune_unused_types_walk_attribs (die);
13848
13849       /* If this node is a specification,
13850          also mark the definition, if it exists.  */
13851       if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
13852         prune_unused_types_mark (die->die_definition, 1);
13853     }
13854
13855   if (dokids && die->die_mark != 2)
13856     {
13857       /* We need to walk the children, but haven't done so yet.
13858          Remember that we've walked the kids.  */
13859       die->die_mark = 2;
13860
13861       /* Walk them.  */
13862       for (c = die->die_child; c; c = c->die_sib)
13863         {
13864           /* If this is an array type, we need to make sure our
13865              kids get marked, even if they're types.  */
13866           if (die->die_tag == DW_TAG_array_type)
13867             prune_unused_types_mark (c, 1);
13868           else
13869             prune_unused_types_walk (c);
13870         }
13871     }
13872 }
13873
13874
13875 /* Walk the tree DIE and mark types that we actually use.  */
13876
13877 static void
13878 prune_unused_types_walk (dw_die_ref die)
13879 {
13880   dw_die_ref c;
13881
13882   /* Don't do anything if this node is already marked.  */
13883   if (die->die_mark)
13884     return;
13885
13886   switch (die->die_tag) {
13887   case DW_TAG_const_type:
13888   case DW_TAG_packed_type:
13889   case DW_TAG_pointer_type:
13890   case DW_TAG_reference_type:
13891   case DW_TAG_volatile_type:
13892   case DW_TAG_typedef:
13893   case DW_TAG_array_type:
13894   case DW_TAG_structure_type:
13895   case DW_TAG_union_type:
13896   case DW_TAG_class_type:
13897   case DW_TAG_friend:
13898   case DW_TAG_variant_part:
13899   case DW_TAG_enumeration_type:
13900   case DW_TAG_subroutine_type:
13901   case DW_TAG_string_type:
13902   case DW_TAG_set_type:
13903   case DW_TAG_subrange_type:
13904   case DW_TAG_ptr_to_member_type:
13905   case DW_TAG_file_type:
13906     /* It's a type node --- don't mark it.  */
13907     return;
13908
13909   default:
13910     /* Mark everything else.  */
13911     break;
13912   }
13913
13914   die->die_mark = 1;
13915
13916   /* Now, mark any dies referenced from here.  */
13917   prune_unused_types_walk_attribs (die);
13918
13919   /* Mark children.  */
13920   for (c = die->die_child; c; c = c->die_sib)
13921     prune_unused_types_walk (c);
13922 }
13923
13924
13925 /* Remove from the tree DIE any dies that aren't marked.  */
13926
13927 static void
13928 prune_unused_types_prune (dw_die_ref die)
13929 {
13930   dw_die_ref c, p, n;
13931
13932   gcc_assert (die->die_mark);
13933
13934   p = NULL;
13935   for (c = die->die_child; c; c = n)
13936     {
13937       n = c->die_sib;
13938       if (c->die_mark)
13939         {
13940           prune_unused_types_prune (c);
13941           p = c;
13942         }
13943       else
13944         {
13945           if (p)
13946             p->die_sib = n;
13947           else
13948             die->die_child = n;
13949           free_die (c);
13950         }
13951     }
13952 }
13953
13954
13955 /* Remove dies representing declarations that we never use.  */
13956
13957 static void
13958 prune_unused_types (void)
13959 {
13960   unsigned int i;
13961   limbo_die_node *node;
13962
13963   /* Clear all the marks.  */
13964   prune_unmark_dies (comp_unit_die);
13965   for (node = limbo_die_list; node; node = node->next)
13966     prune_unmark_dies (node->die);
13967
13968   /* Set the mark on nodes that are actually used.  */
13969   prune_unused_types_walk (comp_unit_die);
13970   for (node = limbo_die_list; node; node = node->next)
13971     prune_unused_types_walk (node->die);
13972
13973   /* Also set the mark on nodes referenced from the
13974      pubname_table or arange_table.  */
13975   for (i = 0; i < pubname_table_in_use; i++)
13976     prune_unused_types_mark (pubname_table[i].die, 1);
13977   for (i = 0; i < arange_table_in_use; i++)
13978     prune_unused_types_mark (arange_table[i], 1);
13979
13980   /* Get rid of nodes that aren't marked.  */
13981   prune_unused_types_prune (comp_unit_die);
13982   for (node = limbo_die_list; node; node = node->next)
13983     prune_unused_types_prune (node->die);
13984
13985   /* Leave the marks clear.  */
13986   prune_unmark_dies (comp_unit_die);
13987   for (node = limbo_die_list; node; node = node->next)
13988     prune_unmark_dies (node->die);
13989 }
13990
13991 /* Output stuff that dwarf requires at the end of every file,
13992    and generate the DWARF-2 debugging info.  */
13993
13994 static void
13995 dwarf2out_finish (const char *filename)
13996 {
13997   limbo_die_node *node, *next_node;
13998   dw_die_ref die = 0;
13999
14000   /* Add the name for the main input file now.  We delayed this from
14001      dwarf2out_init to avoid complications with PCH.  */
14002   add_name_attribute (comp_unit_die, filename);
14003   if (filename[0] != DIR_SEPARATOR)
14004     add_comp_dir_attribute (comp_unit_die);
14005   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14006     {
14007       size_t i;
14008       for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
14009         if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR
14010             /* Don't add cwd for <built-in>.  */
14011             && VARRAY_CHAR_PTR (file_table, i)[0] != '<')
14012           {
14013             add_comp_dir_attribute (comp_unit_die);
14014             break;
14015           }
14016     }
14017
14018   /* Traverse the limbo die list, and add parent/child links.  The only
14019      dies without parents that should be here are concrete instances of
14020      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
14021      For concrete instances, we can get the parent die from the abstract
14022      instance.  */
14023   for (node = limbo_die_list; node; node = next_node)
14024     {
14025       next_node = node->next;
14026       die = node->die;
14027
14028       if (die->die_parent == NULL)
14029         {
14030           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14031
14032           if (origin)
14033             add_child_die (origin->die_parent, die);
14034           else if (die == comp_unit_die)
14035             ;
14036           else if (errorcount > 0 || sorrycount > 0)
14037             /* It's OK to be confused by errors in the input.  */
14038             add_child_die (comp_unit_die, die);
14039           else
14040             {
14041               /* In certain situations, the lexical block containing a
14042                  nested function can be optimized away, which results
14043                  in the nested function die being orphaned.  Likewise
14044                  with the return type of that nested function.  Force
14045                  this to be a child of the containing function.
14046
14047                  It may happen that even the containing function got fully
14048                  inlined and optimized out.  In that case we are lost and
14049                  assign the empty child.  This should not be big issue as
14050                  the function is likely unreachable too.  */
14051               tree context = NULL_TREE;
14052
14053               gcc_assert (node->created_for);
14054
14055               if (DECL_P (node->created_for))
14056                 context = DECL_CONTEXT (node->created_for);
14057               else if (TYPE_P (node->created_for))
14058                 context = TYPE_CONTEXT (node->created_for);
14059
14060               gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
14061
14062               origin = lookup_decl_die (context);
14063               if (origin)
14064                 add_child_die (origin, die);
14065               else
14066                 add_child_die (comp_unit_die, die);
14067             }
14068         }
14069     }
14070
14071   limbo_die_list = NULL;
14072
14073   /* Walk through the list of incomplete types again, trying once more to
14074      emit full debugging info for them.  */
14075   retry_incomplete_types ();
14076
14077   /* We need to reverse all the dies before break_out_includes, or
14078      we'll see the end of an include file before the beginning.  */
14079   reverse_all_dies (comp_unit_die);
14080
14081   if (flag_eliminate_unused_debug_types)
14082     prune_unused_types ();
14083
14084   /* Generate separate CUs for each of the include files we've seen.
14085      They will go into limbo_die_list.  */
14086   if (flag_eliminate_dwarf2_dups)
14087     break_out_includes (comp_unit_die);
14088
14089   /* Traverse the DIE's and add add sibling attributes to those DIE's
14090      that have children.  */
14091   add_sibling_attributes (comp_unit_die);
14092   for (node = limbo_die_list; node; node = node->next)
14093     add_sibling_attributes (node->die);
14094
14095   /* Output a terminator label for the .text section.  */
14096   switch_to_section (text_section);
14097   targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14098   if (flag_reorder_blocks_and_partition)
14099     {
14100       switch_to_section (unlikely_text_section ());
14101       targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14102     }
14103
14104   /* Output the source line correspondence table.  We must do this
14105      even if there is no line information.  Otherwise, on an empty
14106      translation unit, we will generate a present, but empty,
14107      .debug_info section.  IRIX 6.5 `nm' will then complain when
14108      examining the file.  */
14109   if (! DWARF2_ASM_LINE_DEBUG_INFO)
14110     {
14111       switch_to_section (debug_line_section);
14112       output_line_info ();
14113     }
14114
14115   /* We can only use the low/high_pc attributes if all of the code was
14116      in .text.  */
14117   if (!have_multiple_function_sections)
14118     {
14119       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14120       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14121     }
14122
14123   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14124      "base address".  Use zero so that these addresses become absolute.  */
14125   else if (have_location_lists || ranges_table_in_use)
14126     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14127
14128   /* Output location list section if necessary.  */
14129   if (have_location_lists)
14130     {
14131       /* Output the location lists info.  */
14132       switch_to_section (debug_loc_section);
14133       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14134                                    DEBUG_LOC_SECTION_LABEL, 0);
14135       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14136       output_location_lists (die);
14137     }
14138
14139   if (debug_info_level >= DINFO_LEVEL_NORMAL)
14140     add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
14141                        debug_line_section_label);
14142
14143   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14144     add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14145
14146   /* Output all of the compilation units.  We put the main one last so that
14147      the offsets are available to output_pubnames.  */
14148   for (node = limbo_die_list; node; node = node->next)
14149     output_comp_unit (node->die, 0);
14150
14151   output_comp_unit (comp_unit_die, 0);
14152
14153   /* Output the abbreviation table.  */
14154   switch_to_section (debug_abbrev_section);
14155   output_abbrev_section ();
14156
14157   /* Output public names table if necessary.  */
14158   if (pubname_table_in_use)
14159     {
14160       switch_to_section (debug_pubnames_section);
14161       output_pubnames ();
14162     }
14163
14164   /* Output the address range information.  We only put functions in the arange
14165      table, so don't write it out if we don't have any.  */
14166   if (fde_table_in_use)
14167     {
14168       switch_to_section (debug_aranges_section);
14169       output_aranges ();
14170     }
14171
14172   /* Output ranges section if necessary.  */
14173   if (ranges_table_in_use)
14174     {
14175       switch_to_section (debug_ranges_section);
14176       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14177       output_ranges ();
14178     }
14179
14180   /* Have to end the macro section.  */
14181   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14182     {
14183       switch_to_section (debug_macinfo_section);
14184       dw2_asm_output_data (1, 0, "End compilation unit");
14185     }
14186
14187   /* If we emitted any DW_FORM_strp form attribute, output the string
14188      table too.  */
14189   if (debug_str_hash)
14190     htab_traverse (debug_str_hash, output_indirect_string, NULL);
14191 }
14192 #else
14193
14194 /* This should never be used, but its address is needed for comparisons.  */
14195 const struct gcc_debug_hooks dwarf2_debug_hooks;
14196
14197 #endif /* DWARF2_DEBUGGING_INFO */
14198
14199 #include "gt-dwarf2out.h"