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 *);
 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);
 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
3394    a dw_cfa_location.  */
3395
3396 static struct dw_loc_descr_struct *
3397 build_cfa_loc (dw_cfa_location *cfa)
3398 {
3399   struct dw_loc_descr_struct *head, *tmp;
3400
3401   if (cfa->indirect)
3402     {
3403       if (cfa->base_offset)
3404         {
3405           if (cfa->reg <= 31)
3406             head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3407           else
3408             head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3409         }
3410       else if (cfa->reg <= 31)
3411         head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3412       else
3413         head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3414
3415       head->dw_loc_oprnd1.val_class = dw_val_class_const;
3416       tmp = new_loc_descr (DW_OP_deref, 0, 0);
3417       add_loc_descr (&head, tmp);
3418       if (cfa->offset != 0)
3419         {
3420           tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0);
3421           add_loc_descr (&head, tmp);
3422         }
3423     }
3424   else
3425     {
3426       if (cfa->offset == 0)
3427         if (cfa->reg <= 31)
3428           head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3429         else
3430           head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3431       else if (cfa->reg <= 31)
3432         head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->offset, 0);
3433       else
3434         head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->offset);
3435     }
3436
3437   return head;
3438 }
3439
3440 /* This function fills in aa dw_cfa_location structure from a dwarf location
3441    descriptor sequence.  */
3442
3443 static void
3444 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3445 {
3446   struct dw_loc_descr_struct *ptr;
3447   cfa->offset = 0;
3448   cfa->base_offset = 0;
3449   cfa->indirect = 0;
3450   cfa->reg = -1;
3451
3452   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3453     {
3454       enum dwarf_location_atom op = ptr->dw_loc_opc;
3455
3456       switch (op)
3457         {
3458         case DW_OP_reg0:
3459         case DW_OP_reg1:
3460         case DW_OP_reg2:
3461         case DW_OP_reg3:
3462         case DW_OP_reg4:
3463         case DW_OP_reg5:
3464         case DW_OP_reg6:
3465         case DW_OP_reg7:
3466         case DW_OP_reg8:
3467         case DW_OP_reg9:
3468         case DW_OP_reg10:
3469         case DW_OP_reg11:
3470         case DW_OP_reg12:
3471         case DW_OP_reg13:
3472         case DW_OP_reg14:
3473         case DW_OP_reg15:
3474         case DW_OP_reg16:
3475         case DW_OP_reg17:
3476         case DW_OP_reg18:
3477         case DW_OP_reg19:
3478         case DW_OP_reg20:
3479         case DW_OP_reg21:
3480         case DW_OP_reg22:
3481         case DW_OP_reg23:
3482         case DW_OP_reg24:
3483         case DW_OP_reg25:
3484         case DW_OP_reg26:
3485         case DW_OP_reg27:
3486         case DW_OP_reg28:
3487         case DW_OP_reg29:
3488         case DW_OP_reg30:
3489         case DW_OP_reg31:
3490           cfa->reg = op - DW_OP_reg0;
3491           break;
3492         case DW_OP_regx:
3493           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3494           break;
3495         case DW_OP_breg0:
3496         case DW_OP_breg1:
3497         case DW_OP_breg2:
3498         case DW_OP_breg3:
3499         case DW_OP_breg4:
3500         case DW_OP_breg5:
3501         case DW_OP_breg6:
3502         case DW_OP_breg7:
3503         case DW_OP_breg8:
3504         case DW_OP_breg9:
3505         case DW_OP_breg10:
3506         case DW_OP_breg11:
3507         case DW_OP_breg12:
3508         case DW_OP_breg13:
3509         case DW_OP_breg14:
3510         case DW_OP_breg15:
3511         case DW_OP_breg16:
3512         case DW_OP_breg17:
3513         case DW_OP_breg18:
3514         case DW_OP_breg19:
3515         case DW_OP_breg20:
3516         case DW_OP_breg21:
3517         case DW_OP_breg22:
3518         case DW_OP_breg23:
3519         case DW_OP_breg24:
3520         case DW_OP_breg25:
3521         case DW_OP_breg26:
3522         case DW_OP_breg27:
3523         case DW_OP_breg28:
3524         case DW_OP_breg29:
3525         case DW_OP_breg30:
3526         case DW_OP_breg31:
3527           cfa->reg = op - DW_OP_breg0;
3528           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3529           break;
3530         case DW_OP_bregx:
3531           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3532           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3533           break;
3534         case DW_OP_deref:
3535           cfa->indirect = 1;
3536           break;
3537         case DW_OP_plus_uconst:
3538           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3539           break;
3540         default:
3541           internal_error ("DW_LOC_OP %s not implemented",
3542                           dwarf_stack_op_name (ptr->dw_loc_opc));
3543         }
3544     }
3545 }
3546 #endif /* .debug_frame support */
3547 \f
3548 /* And now, the support for symbolic debugging information.  */
3549 #ifdef DWARF2_DEBUGGING_INFO
3550
3551 /* .debug_str support.  */
3552 static int output_indirect_string (void **, void *);
3553
3554 static void dwarf2out_init (const char *);
3555 static void dwarf2out_finish (const char *);
3556 static void dwarf2out_define (unsigned int, const char *);
3557 static void dwarf2out_undef (unsigned int, const char *);
3558 static void dwarf2out_start_source_file (unsigned, const char *);
3559 static void dwarf2out_end_source_file (unsigned);
3560 static void dwarf2out_begin_block (unsigned, unsigned);
3561 static void dwarf2out_end_block (unsigned, unsigned);
3562 static bool dwarf2out_ignore_block (tree);
3563 static void dwarf2out_global_decl (tree);
3564 static void dwarf2out_type_decl (tree, int);
3565 static void dwarf2out_imported_module_or_decl (tree, tree);
3566 static void dwarf2out_abstract_function (tree);
3567 static void dwarf2out_var_location (rtx);
3568 static void dwarf2out_begin_function (tree);
3569 static void dwarf2out_switch_text_section (void);
3570
3571 /* The debug hooks structure.  */
3572
3573 const struct gcc_debug_hooks dwarf2_debug_hooks =
3574 {
3575   dwarf2out_init,
3576   dwarf2out_finish,
3577   dwarf2out_define,
3578   dwarf2out_undef,
3579   dwarf2out_start_source_file,
3580   dwarf2out_end_source_file,
3581   dwarf2out_begin_block,
3582   dwarf2out_end_block,
3583   dwarf2out_ignore_block,
3584   dwarf2out_source_line,
3585   dwarf2out_begin_prologue,
3586   debug_nothing_int_charstar,   /* end_prologue */
3587   dwarf2out_end_epilogue,
3588   dwarf2out_begin_function,
3589   debug_nothing_int,            /* end_function */
3590   dwarf2out_decl,               /* function_decl */
3591   dwarf2out_global_decl,
3592   dwarf2out_type_decl,          /* type_decl */
3593   dwarf2out_imported_module_or_decl,
3594   debug_nothing_tree,           /* deferred_inline_function */
3595   /* The DWARF 2 backend tries to reduce debugging bloat by not
3596      emitting the abstract description of inline functions until
3597      something tries to reference them.  */
3598   dwarf2out_abstract_function,  /* outlining_inline_function */
3599   debug_nothing_rtx,            /* label */
3600   debug_nothing_int,            /* handle_pch */
3601   dwarf2out_var_location,
3602   dwarf2out_switch_text_section,
3603   1                             /* start_end_main_source_file */
3604 };
3605 #endif
3606 \f
3607 /* NOTE: In the comments in this file, many references are made to
3608    "Debugging Information Entries".  This term is abbreviated as `DIE'
3609    throughout the remainder of this file.  */
3610
3611 /* An internal representation of the DWARF output is built, and then
3612    walked to generate the DWARF debugging info.  The walk of the internal
3613    representation is done after the entire program has been compiled.
3614    The types below are used to describe the internal representation.  */
3615
3616 /* Various DIE's use offsets relative to the beginning of the
3617    .debug_info section to refer to each other.  */
3618
3619 typedef long int dw_offset;
3620
3621 /* Define typedefs here to avoid circular dependencies.  */
3622
3623 typedef struct dw_attr_struct *dw_attr_ref;
3624 typedef struct dw_line_info_struct *dw_line_info_ref;
3625 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3626 typedef struct pubname_struct *pubname_ref;
3627 typedef struct dw_ranges_struct *dw_ranges_ref;
3628
3629 /* Each entry in the line_info_table maintains the file and
3630    line number associated with the label generated for that
3631    entry.  The label gives the PC value associated with
3632    the line number entry.  */
3633
3634 typedef struct dw_line_info_struct GTY(())
3635 {
3636   unsigned long dw_file_num;
3637   unsigned long dw_line_num;
3638 }
3639 dw_line_info_entry;
3640
3641 /* Line information for functions in separate sections; each one gets its
3642    own sequence.  */
3643 typedef struct dw_separate_line_info_struct GTY(())
3644 {
3645   unsigned long dw_file_num;
3646   unsigned long dw_line_num;
3647   unsigned long function;
3648 }
3649 dw_separate_line_info_entry;
3650
3651 /* Each DIE attribute has a field specifying the attribute kind,
3652    a link to the next attribute in the chain, and an attribute value.
3653    Attributes are typically linked below the DIE they modify.  */
3654
3655 typedef struct dw_attr_struct GTY(())
3656 {
3657   enum dwarf_attribute dw_attr;
3658   dw_attr_ref dw_attr_next;
3659   dw_val_node dw_attr_val;
3660 }
3661 dw_attr_node;
3662
3663 /* The Debugging Information Entry (DIE) structure */
3664
3665 typedef struct die_struct GTY(())
3666 {
3667   enum dwarf_tag die_tag;
3668   char *die_symbol;
3669   dw_attr_ref die_attr;
3670   dw_die_ref die_parent;
3671   dw_die_ref die_child;
3672   dw_die_ref die_sib;
3673   dw_die_ref die_definition; /* ref from a specification to its definition */
3674   dw_offset die_offset;
3675   unsigned long die_abbrev;
3676   int die_mark;
3677   unsigned int decl_id;
3678 }
3679 die_node;
3680
3681 /* The pubname structure */
3682
3683 typedef struct pubname_struct GTY(())
3684 {
3685   dw_die_ref die;
3686   char *name;
3687 }
3688 pubname_entry;
3689
3690 struct dw_ranges_struct GTY(())
3691 {
3692   int block_num;
3693 };
3694
3695 /* The limbo die list structure.  */
3696 typedef struct limbo_die_struct GTY(())
3697 {
3698   dw_die_ref die;
3699   tree created_for;
3700   struct limbo_die_struct *next;
3701 }
3702 limbo_die_node;
3703
3704 /* How to start an assembler comment.  */
3705 #ifndef ASM_COMMENT_START
3706 #define ASM_COMMENT_START ";#"
3707 #endif
3708
3709 /* Define a macro which returns nonzero for a TYPE_DECL which was
3710    implicitly generated for a tagged type.
3711
3712    Note that unlike the gcc front end (which generates a NULL named
3713    TYPE_DECL node for each complete tagged type, each array type, and
3714    each function type node created) the g++ front end generates a
3715    _named_ TYPE_DECL node for each tagged type node created.
3716    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3717    generate a DW_TAG_typedef DIE for them.  */
3718
3719 #define TYPE_DECL_IS_STUB(decl)                         \
3720   (DECL_NAME (decl) == NULL_TREE                        \
3721    || (DECL_ARTIFICIAL (decl)                           \
3722        && is_tagged_type (TREE_TYPE (decl))             \
3723        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
3724            /* This is necessary for stub decls that     \
3725               appear in nested inline functions.  */    \
3726            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3727                && (decl_ultimate_origin (decl)          \
3728                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3729
3730 /* Information concerning the compilation unit's programming
3731    language, and compiler version.  */
3732
3733 /* Fixed size portion of the DWARF compilation unit header.  */
3734 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3735   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3736
3737 /* Fixed size portion of public names info.  */
3738 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3739
3740 /* Fixed size portion of the address range info.  */
3741 #define DWARF_ARANGES_HEADER_SIZE                                       \
3742   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
3743                 DWARF2_ADDR_SIZE * 2)                                   \
3744    - DWARF_INITIAL_LENGTH_SIZE)
3745
3746 /* Size of padding portion in the address range info.  It must be
3747    aligned to twice the pointer size.  */
3748 #define DWARF_ARANGES_PAD_SIZE \
3749   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3750                 DWARF2_ADDR_SIZE * 2) \
3751    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3752
3753 /* Use assembler line directives if available.  */
3754 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3755 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3756 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3757 #else
3758 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3759 #endif
3760 #endif
3761
3762 /* Minimum line offset in a special line info. opcode.
3763    This value was chosen to give a reasonable range of values.  */
3764 #define DWARF_LINE_BASE  -10
3765
3766 /* First special line opcode - leave room for the standard opcodes.  */
3767 #define DWARF_LINE_OPCODE_BASE  10
3768
3769 /* Range of line offsets in a special line info. opcode.  */
3770 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
3771
3772 /* Flag that indicates the initial value of the is_stmt_start flag.
3773    In the present implementation, we do not mark any lines as
3774    the beginning of a source statement, because that information
3775    is not made available by the GCC front-end.  */
3776 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3777
3778 #ifdef DWARF2_DEBUGGING_INFO
3779 /* This location is used by calc_die_sizes() to keep track
3780    the offset of each DIE within the .debug_info section.  */
3781 static unsigned long next_die_offset;
3782 #endif
3783
3784 /* Record the root of the DIE's built for the current compilation unit.  */
3785 static GTY(()) dw_die_ref comp_unit_die;
3786
3787 /* A list of DIEs with a NULL parent waiting to be relocated.  */
3788 static GTY(()) limbo_die_node *limbo_die_list;
3789
3790 /* Filenames referenced by this compilation unit.  */
3791 static GTY(()) varray_type file_table;
3792 static GTY(()) varray_type file_table_emitted;
3793 static GTY(()) size_t file_table_last_lookup_index;
3794
3795 /* A hash table of references to DIE's that describe declarations.
3796    The key is a DECL_UID() which is a unique number identifying each decl.  */
3797 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3798
3799 /* Node of the variable location list.  */
3800 struct var_loc_node GTY ((chain_next ("%h.next")))
3801 {
3802   rtx GTY (()) var_loc_note;
3803   const char * GTY (()) label;
3804   const char * GTY (()) section_label;
3805   struct var_loc_node * GTY (()) next;
3806 };
3807
3808 /* Variable location list.  */
3809 struct var_loc_list_def GTY (())
3810 {
3811   struct var_loc_node * GTY (()) first;
3812
3813   /* Do not mark the last element of the chained list because
3814      it is marked through the chain.  */
3815   struct var_loc_node * GTY ((skip ("%h"))) last;
3816
3817   /* DECL_UID of the variable decl.  */
3818   unsigned int decl_id;
3819 };
3820 typedef struct var_loc_list_def var_loc_list;
3821
3822
3823 /* Table of decl location linked lists.  */
3824 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3825
3826 /* A pointer to the base of a list of references to DIE's that
3827    are uniquely identified by their tag, presence/absence of
3828    children DIE's, and list of attribute/value pairs.  */
3829 static GTY((length ("abbrev_die_table_allocated")))
3830   dw_die_ref *abbrev_die_table;
3831
3832 /* Number of elements currently allocated for abbrev_die_table.  */
3833 static GTY(()) unsigned abbrev_die_table_allocated;
3834
3835 /* Number of elements in type_die_table currently in use.  */
3836 static GTY(()) unsigned abbrev_die_table_in_use;
3837
3838 /* Size (in elements) of increments by which we may expand the
3839    abbrev_die_table.  */
3840 #define ABBREV_DIE_TABLE_INCREMENT 256
3841
3842 /* A pointer to the base of a table that contains line information
3843    for each source code line in .text in the compilation unit.  */
3844 static GTY((length ("line_info_table_allocated")))
3845      dw_line_info_ref line_info_table;
3846
3847 /* Number of elements currently allocated for line_info_table.  */
3848 static GTY(()) unsigned line_info_table_allocated;
3849
3850 /* Number of elements in line_info_table currently in use.  */
3851 static GTY(()) unsigned line_info_table_in_use;
3852
3853 /* True if the compilation unit places functions in more than one section.  */
3854 static GTY(()) bool have_multiple_function_sections = false;
3855
3856 /* A pointer to the base of a table that contains line information
3857    for each source code line outside of .text in the compilation unit.  */
3858 static GTY ((length ("separate_line_info_table_allocated")))
3859      dw_separate_line_info_ref separate_line_info_table;
3860
3861 /* Number of elements currently allocated for separate_line_info_table.  */
3862 static GTY(()) unsigned separate_line_info_table_allocated;
3863
3864 /* Number of elements in separate_line_info_table currently in use.  */
3865 static GTY(()) unsigned separate_line_info_table_in_use;
3866
3867 /* Size (in elements) of increments by which we may expand the
3868    line_info_table.  */
3869 #define LINE_INFO_TABLE_INCREMENT 1024
3870
3871 /* A pointer to the base of a table that contains a list of publicly
3872    accessible names.  */
3873 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3874
3875 /* Number of elements currently allocated for pubname_table.  */
3876 static GTY(()) unsigned pubname_table_allocated;
3877
3878 /* Number of elements in pubname_table currently in use.  */
3879 static GTY(()) unsigned pubname_table_in_use;
3880
3881 /* Size (in elements) of increments by which we may expand the
3882    pubname_table.  */
3883 #define PUBNAME_TABLE_INCREMENT 64
3884
3885 /* Array of dies for which we should generate .debug_arange info.  */
3886 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3887
3888 /* Number of elements currently allocated for arange_table.  */
3889 static GTY(()) unsigned arange_table_allocated;
3890
3891 /* Number of elements in arange_table currently in use.  */
3892 static GTY(()) unsigned arange_table_in_use;
3893
3894 /* Size (in elements) of increments by which we may expand the
3895    arange_table.  */
3896 #define ARANGE_TABLE_INCREMENT 64
3897
3898 /* Array of dies for which we should generate .debug_ranges info.  */
3899 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3900
3901 /* Number of elements currently allocated for ranges_table.  */
3902 static GTY(()) unsigned ranges_table_allocated;
3903
3904 /* Number of elements in ranges_table currently in use.  */
3905 static GTY(()) unsigned ranges_table_in_use;
3906
3907 /* Size (in elements) of increments by which we may expand the
3908    ranges_table.  */
3909 #define RANGES_TABLE_INCREMENT 64
3910
3911 /* Whether we have location lists that need outputting */
3912 static GTY(()) bool have_location_lists;
3913
3914 /* Unique label counter.  */
3915 static GTY(()) unsigned int loclabel_num;
3916
3917 #ifdef DWARF2_DEBUGGING_INFO
3918 /* Record whether the function being analyzed contains inlined functions.  */
3919 static int current_function_has_inlines;
3920 #endif
3921 #if 0 && defined (MIPS_DEBUGGING_INFO)
3922 static int comp_unit_has_inlines;
3923 #endif
3924
3925 /* Number of file tables emitted in maybe_emit_file().  */
3926 static GTY(()) int emitcount = 0;
3927
3928 /* Number of internal labels generated by gen_internal_sym().  */
3929 static GTY(()) int label_num;
3930
3931 #ifdef DWARF2_DEBUGGING_INFO
3932
3933 /* Offset from the "steady-state frame pointer" to the CFA,
3934    within the current function.  */
3935 static HOST_WIDE_INT frame_pointer_cfa_offset;
3936
3937 /* Forward declarations for functions defined in this file.  */
3938
3939 static int is_pseudo_reg (rtx);
3940 static tree type_main_variant (tree);
3941 static int is_tagged_type (tree);
3942 static const char *dwarf_tag_name (unsigned);
3943 static const char *dwarf_attr_name (unsigned);
3944 static const char *dwarf_form_name (unsigned);
3945 static tree decl_ultimate_origin (tree);
3946 static tree block_ultimate_origin (tree);
3947 static tree decl_class_context (tree);
3948 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3949 static inline enum dw_val_class AT_class (dw_attr_ref);
3950 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3951 static inline unsigned AT_flag (dw_attr_ref);
3952 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3953 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3954 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3955 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3956 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
3957                               unsigned long);
3958 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3959                                unsigned int, unsigned char *);
3960 static hashval_t debug_str_do_hash (const void *);
3961 static int debug_str_eq (const void *, const void *);
3962 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3963 static inline const char *AT_string (dw_attr_ref);
3964 static int AT_string_form (dw_attr_ref);
3965 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3966 static void add_AT_specification (dw_die_ref, dw_die_ref);
3967 static inline dw_die_ref AT_ref (dw_attr_ref);
3968 static inline int AT_ref_external (dw_attr_ref);
3969 static inline void set_AT_ref_external (dw_attr_ref, int);
3970 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3971 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3972 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3973 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3974                              dw_loc_list_ref);
3975 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3976 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3977 static inline rtx AT_addr (dw_attr_ref);
3978 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3979 static void add_AT_lbl_offset (dw_die_ref, enum dwarf_attribute, const char *);
3980 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3981                            unsigned HOST_WIDE_INT);
3982 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3983                                unsigned long);
3984 static inline const char *AT_lbl (dw_attr_ref);
3985 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3986 static const char *get_AT_low_pc (dw_die_ref);
3987 static const char *get_AT_hi_pc (dw_die_ref);
3988 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3989 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3990 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3991 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3992 static bool is_c_family (void);
3993 static bool is_cxx (void);
3994 static bool is_java (void);
3995 static bool is_fortran (void);
3996 static bool is_ada (void);
3997 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3998 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3999 static inline void free_die (dw_die_ref);
4000 static void remove_children (dw_die_ref);
4001 static void add_child_die (dw_die_ref, dw_die_ref);
4002 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4003 static dw_die_ref lookup_type_die (tree);
4004 static void equate_type_number_to_die (tree, dw_die_ref);
4005 static hashval_t decl_die_table_hash (const void *);
4006 static int decl_die_table_eq (const void *, const void *);
4007 static dw_die_ref lookup_decl_die (tree);
4008 static hashval_t decl_loc_table_hash (const void *);
4009 static int decl_loc_table_eq (const void *, const void *);
4010 static var_loc_list *lookup_decl_loc (tree);
4011 static void equate_decl_number_to_die (tree, dw_die_ref);
4012 static void add_var_loc_to_decl (tree, struct var_loc_node *);
4013 static void print_spaces (FILE *);
4014 static void print_die (dw_die_ref, FILE *);
4015 static void print_dwarf_line_table (FILE *);
4016 static void reverse_die_lists (dw_die_ref);
4017 static void reverse_all_dies (dw_die_ref);
4018 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4019 static dw_die_ref pop_compile_unit (dw_die_ref);
4020 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4021 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4022 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4023 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4024 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
4025 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4026 static int same_die_p (dw_die_ref, dw_die_ref, int *);
4027 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4028 static void compute_section_prefix (dw_die_ref);
4029 static int is_type_die (dw_die_ref);
4030 static int is_comdat_die (dw_die_ref);
4031 static int is_symbol_die (dw_die_ref);
4032 static void assign_symbol_names (dw_die_ref);
4033 static void break_out_includes (dw_die_ref);
4034 static hashval_t htab_cu_hash (const void *);
4035 static int htab_cu_eq (const void *, const void *);
4036 static void htab_cu_del (void *);
4037 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4038 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4039 static void add_sibling_attributes (dw_die_ref);
4040 static void build_abbrev_table (dw_die_ref);
4041 static void output_location_lists (dw_die_ref);
4042 static int constant_size (long unsigned);
4043 static unsigned long size_of_die (dw_die_ref);
4044 static void calc_die_sizes (dw_die_ref);
4045 static void mark_dies (dw_die_ref);
4046 static void unmark_dies (dw_die_ref);
4047 static void unmark_all_dies (dw_die_ref);
4048 static unsigned long size_of_pubnames (void);
4049 static unsigned long size_of_aranges (void);
4050 static enum dwarf_form value_format (dw_attr_ref);
4051 static void output_value_format (dw_attr_ref);
4052 static void output_abbrev_section (void);
4053 static void output_die_symbol (dw_die_ref);
4054 static void output_die (dw_die_ref);
4055 static void output_compilation_unit_header (void);
4056 static void output_comp_unit (dw_die_ref, int);
4057 static const char *dwarf2_name (tree, int);
4058 static void add_pubname (tree, dw_die_ref);
4059 static void output_pubnames (void);
4060 static void add_arange (tree, dw_die_ref);
4061 static void output_aranges (void);
4062 static unsigned int add_ranges (tree);
4063 static void output_ranges (void);
4064 static void output_line_info (void);
4065 static void output_file_names (void);
4066 static dw_die_ref base_type_die (tree);
4067 static tree root_type (tree);
4068 static int is_base_type (tree);
4069 static bool is_subrange_type (tree);
4070 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4071 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4072 static int type_is_enum (tree);
4073 static unsigned int dbx_reg_number (rtx);
4074 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4075 static dw_loc_descr_ref reg_loc_descriptor (rtx);
4076 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4077 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4078 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4079 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4080 static int is_based_loc (rtx);
4081 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4082 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4083 static dw_loc_descr_ref loc_descriptor (rtx);
4084 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4085 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4086 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4087 static tree field_type (tree);
4088 static unsigned int simple_type_align_in_bits (tree);
4089 static unsigned int simple_decl_align_in_bits (tree);
4090 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4091 static HOST_WIDE_INT field_byte_offset (tree);
4092 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4093                                          dw_loc_descr_ref);
4094 static void add_data_member_location_attribute (dw_die_ref, tree);
4095 static void add_const_value_attribute (dw_die_ref, rtx);
4096 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4097 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4098 static void insert_float (rtx, unsigned char *);
4099 static rtx rtl_for_decl_location (tree);
4100 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4101                                                    enum dwarf_attribute);
4102 static void tree_add_const_value_attribute (dw_die_ref, tree);
4103 static void add_name_attribute (dw_die_ref, const char *);
4104 static void add_comp_dir_attribute (dw_die_ref);
4105 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4106 static void add_subscript_info (dw_die_ref, tree);
4107 static void add_byte_size_attribute (dw_die_ref, tree);
4108 static void add_bit_offset_attribute (dw_die_ref, tree);
4109 static void add_bit_size_attribute (dw_die_ref, tree);
4110 static void add_prototyped_attribute (dw_die_ref, tree);
4111 static void add_abstract_origin_attribute (dw_die_ref, tree);
4112 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4113 static void add_src_coords_attributes (dw_die_ref, tree);
4114 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4115 static void push_decl_scope (tree);
4116 static void pop_decl_scope (void);
4117 static dw_die_ref scope_die_for (tree, dw_die_ref);
4118 static inline int local_scope_p (dw_die_ref);
4119 static inline int class_or_namespace_scope_p (dw_die_ref);
4120 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4121 static void add_calling_convention_attribute (dw_die_ref, tree);
4122 static const char *type_tag (tree);
4123 static tree member_declared_type (tree);
4124 #if 0
4125 static const char *decl_start_label (tree);
4126 #endif
4127 static void gen_array_type_die (tree, dw_die_ref);
4128 #if 0
4129 static void gen_entry_point_die (tree, dw_die_ref);
4130 #endif
4131 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4132 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4133 static void gen_inlined_union_type_die (tree, dw_die_ref);
4134 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4135 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4136 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4137 static void gen_formal_types_die (tree, dw_die_ref);
4138 static void gen_subprogram_die (tree, dw_die_ref);
4139 static void gen_variable_die (tree, dw_die_ref);
4140 static void gen_label_die (tree, dw_die_ref);
4141 static void gen_lexical_block_die (tree, dw_die_ref, int);
4142 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4143 static void gen_field_die (tree, dw_die_ref);
4144 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4145 static dw_die_ref gen_compile_unit_die (const char *);
4146 static void gen_inheritance_die (tree, tree, dw_die_ref);
4147 static void gen_member_die (tree, dw_die_ref);
4148 static void gen_struct_or_union_type_die (tree, dw_die_ref);
4149 static void gen_subroutine_type_die (tree, dw_die_ref);
4150 static void gen_typedef_die (tree, dw_die_ref);
4151 static void gen_type_die (tree, dw_die_ref);
4152 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4153 static void gen_block_die (tree, dw_die_ref, int);
4154 static void decls_for_scope (tree, dw_die_ref, int);
4155 static int is_redundant_typedef (tree);
4156 static void gen_namespace_die (tree);
4157 static void gen_decl_die (tree, dw_die_ref);
4158 static dw_die_ref force_decl_die (tree);
4159 static dw_die_ref force_type_die (tree);
4160 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4161 static void declare_in_namespace (tree, dw_die_ref);
4162 static unsigned lookup_filename (const char *);
4163 static void init_file_table (void);
4164 static void retry_incomplete_types (void);
4165 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4166 static void splice_child_die (dw_die_ref, dw_die_ref);
4167 static int file_info_cmp (const void *, const void *);
4168 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4169                                      const char *, const char *, unsigned);
4170 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4171                                        const char *, const char *,
4172                                        const char *);
4173 static void output_loc_list (dw_loc_list_ref);
4174 static char *gen_internal_sym (const char *);
4175
4176 static void prune_unmark_dies (dw_die_ref);
4177 static void prune_unused_types_mark (dw_die_ref, int);
4178 static void prune_unused_types_walk (dw_die_ref);
4179 static void prune_unused_types_walk_attribs (dw_die_ref);
4180 static void prune_unused_types_prune (dw_die_ref);
4181 static void prune_unused_types (void);
4182 static int maybe_emit_file (int);
4183
4184 /* Section names used to hold DWARF debugging information.  */
4185 #ifndef DEBUG_INFO_SECTION
4186 #define DEBUG_INFO_SECTION      ".debug_info"
4187 #endif
4188 #ifndef DEBUG_ABBREV_SECTION
4189 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
4190 #endif
4191 #ifndef DEBUG_ARANGES_SECTION
4192 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
4193 #endif
4194 #ifndef DEBUG_MACINFO_SECTION
4195 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
4196 #endif
4197 #ifndef DEBUG_LINE_SECTION
4198 #define DEBUG_LINE_SECTION      ".debug_line"
4199 #endif
4200 #ifndef DEBUG_LOC_SECTION
4201 #define DEBUG_LOC_SECTION       ".debug_loc"
4202 #endif
4203 #ifndef DEBUG_PUBNAMES_SECTION
4204 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
4205 #endif
4206 #ifndef DEBUG_STR_SECTION
4207 #define DEBUG_STR_SECTION       ".debug_str"
4208 #endif
4209 #ifndef DEBUG_RANGES_SECTION
4210 #define DEBUG_RANGES_SECTION    ".debug_ranges"
4211 #endif
4212
4213 /* Standard ELF section names for compiled code and data.  */
4214 #ifndef TEXT_SECTION_NAME
4215 #define TEXT_SECTION_NAME       ".text"
4216 #endif
4217
4218 /* Section flags for .debug_str section.  */
4219 #define DEBUG_STR_SECTION_FLAGS \
4220   (HAVE_GAS_SHF_MERGE && flag_merge_constants                   \
4221    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
4222    : SECTION_DEBUG)
4223
4224 /* Labels we insert at beginning sections we can reference instead of
4225    the section names themselves.  */
4226
4227 #ifndef TEXT_SECTION_LABEL
4228 #define TEXT_SECTION_LABEL              "Ltext"
4229 #endif
4230 #ifndef COLD_TEXT_SECTION_LABEL
4231 #define COLD_TEXT_SECTION_LABEL         "Ltext_cold"
4232 #endif
4233 #ifndef DEBUG_LINE_SECTION_LABEL
4234 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
4235 #endif
4236 #ifndef DEBUG_INFO_SECTION_LABEL
4237 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
4238 #endif
4239 #ifndef DEBUG_ABBREV_SECTION_LABEL
4240 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
4241 #endif
4242 #ifndef DEBUG_LOC_SECTION_LABEL
4243 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
4244 #endif
4245 #ifndef DEBUG_RANGES_SECTION_LABEL
4246 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
4247 #endif
4248 #ifndef DEBUG_MACINFO_SECTION_LABEL
4249 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
4250 #endif
4251
4252 /* Definitions of defaults for formats and names of various special
4253    (artificial) labels which may be generated within this file (when the -g
4254    options is used and DWARF2_DEBUGGING_INFO is in effect.
4255    If necessary, these may be overridden from within the tm.h file, but
4256    typically, overriding these defaults is unnecessary.  */
4257
4258 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4259 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4260 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4261 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4262 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4263 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4264 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4265 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4266 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4267 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4268
4269 #ifndef TEXT_END_LABEL
4270 #define TEXT_END_LABEL          "Letext"
4271 #endif
4272 #ifndef COLD_END_LABEL
4273 #define COLD_END_LABEL          "Letext_cold"
4274 #endif
4275 #ifndef BLOCK_BEGIN_LABEL
4276 #define BLOCK_BEGIN_LABEL       "LBB"
4277 #endif
4278 #ifndef BLOCK_END_LABEL
4279 #define BLOCK_END_LABEL         "LBE"
4280 #endif
4281 #ifndef LINE_CODE_LABEL
4282 #define LINE_CODE_LABEL         "LM"
4283 #endif
4284 #ifndef SEPARATE_LINE_CODE_LABEL
4285 #define SEPARATE_LINE_CODE_LABEL        "LSM"
4286 #endif
4287 \f
4288 /* We allow a language front-end to designate a function that is to be
4289    called to "demangle" any name before it is put into a DIE.  */
4290
4291 static const char *(*demangle_name_func) (const char *);
4292
4293 void
4294 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4295 {
4296   demangle_name_func = func;
4297 }
4298
4299 /* Test if rtl node points to a pseudo register.  */
4300
4301 static inline int
4302 is_pseudo_reg (rtx rtl)
4303 {
4304   return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4305           || (GET_CODE (rtl) == SUBREG
4306               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4307 }
4308
4309 /* Return a reference to a type, with its const and volatile qualifiers
4310    removed.  */
4311
4312 static inline tree
4313 type_main_variant (tree type)
4314 {
4315   type = TYPE_MAIN_VARIANT (type);
4316
4317   /* ??? There really should be only one main variant among any group of
4318      variants of a given type (and all of the MAIN_VARIANT values for all
4319      members of the group should point to that one type) but sometimes the C
4320      front-end messes this up for array types, so we work around that bug
4321      here.  */
4322   if (TREE_CODE (type) == ARRAY_TYPE)
4323     while (type != TYPE_MAIN_VARIANT (type))
4324       type = TYPE_MAIN_VARIANT (type);
4325
4326   return type;
4327 }
4328
4329 /* Return nonzero if the given type node represents a tagged type.  */
4330
4331 static inline int
4332 is_tagged_type (tree type)
4333 {
4334   enum tree_code code = TREE_CODE (type);
4335
4336   return (code == RECORD_TYPE || code == UNION_TYPE
4337           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4338 }
4339
4340 /* Convert a DIE tag into its string name.  */
4341
4342 static const char *
4343 dwarf_tag_name (unsigned int tag)
4344 {
4345   switch (tag)
4346     {
4347     case DW_TAG_padding:
4348       return "DW_TAG_padding";
4349     case DW_TAG_array_type:
4350       return "DW_TAG_array_type";
4351     case DW_TAG_class_type:
4352       return "DW_TAG_class_type";
4353     case DW_TAG_entry_point:
4354       return "DW_TAG_entry_point";
4355     case DW_TAG_enumeration_type:
4356       return "DW_TAG_enumeration_type";
4357     case DW_TAG_formal_parameter:
4358       return "DW_TAG_formal_parameter";
4359     case DW_TAG_imported_declaration:
4360       return "DW_TAG_imported_declaration";
4361     case DW_TAG_label:
4362       return "DW_TAG_label";
4363     case DW_TAG_lexical_block:
4364       return "DW_TAG_lexical_block";
4365     case DW_TAG_member:
4366       return "DW_TAG_member";
4367     case DW_TAG_pointer_type:
4368       return "DW_TAG_pointer_type";
4369     case DW_TAG_reference_type:
4370       return "DW_TAG_reference_type";
4371     case DW_TAG_compile_unit:
4372       return "DW_TAG_compile_unit";
4373     case DW_TAG_string_type:
4374       return "DW_TAG_string_type";
4375     case DW_TAG_structure_type:
4376       return "DW_TAG_structure_type";
4377     case DW_TAG_subroutine_type:
4378       return "DW_TAG_subroutine_type";
4379     case DW_TAG_typedef:
4380       return "DW_TAG_typedef";
4381     case DW_TAG_union_type:
4382       return "DW_TAG_union_type";
4383     case DW_TAG_unspecified_parameters:
4384       return "DW_TAG_unspecified_parameters";
4385     case DW_TAG_variant:
4386       return "DW_TAG_variant";
4387     case DW_TAG_common_block:
4388       return "DW_TAG_common_block";
4389     case DW_TAG_common_inclusion:
4390       return "DW_TAG_common_inclusion";
4391     case DW_TAG_inheritance:
4392       return "DW_TAG_inheritance";
4393     case DW_TAG_inlined_subroutine:
4394       return "DW_TAG_inlined_subroutine";
4395     case DW_TAG_module:
4396       return "DW_TAG_module";
4397     case DW_TAG_ptr_to_member_type:
4398       return "DW_TAG_ptr_to_member_type";
4399     case DW_TAG_set_type:
4400       return "DW_TAG_set_type";
4401     case DW_TAG_subrange_type:
4402       return "DW_TAG_subrange_type";
4403     case DW_TAG_with_stmt:
4404       return "DW_TAG_with_stmt";
4405     case DW_TAG_access_declaration:
4406       return "DW_TAG_access_declaration";
4407     case DW_TAG_base_type:
4408       return "DW_TAG_base_type";
4409     case DW_TAG_catch_block:
4410       return "DW_TAG_catch_block";
4411     case DW_TAG_const_type:
4412       return "DW_TAG_const_type";
4413     case DW_TAG_constant:
4414       return "DW_TAG_constant";
4415     case DW_TAG_enumerator:
4416       return "DW_TAG_enumerator";
4417     case DW_TAG_file_type:
4418       return "DW_TAG_file_type";
4419     case DW_TAG_friend:
4420       return "DW_TAG_friend";
4421     case DW_TAG_namelist:
4422       return "DW_TAG_namelist";
4423     case DW_TAG_namelist_item:
4424       return "DW_TAG_namelist_item";
4425     case DW_TAG_namespace:
4426       return "DW_TAG_namespace";
4427     case DW_TAG_packed_type:
4428       return "DW_TAG_packed_type";
4429     case DW_TAG_subprogram:
4430       return "DW_TAG_subprogram";
4431     case DW_TAG_template_type_param:
4432       return "DW_TAG_template_type_param";
4433     case DW_TAG_template_value_param:
4434       return "DW_TAG_template_value_param";
4435     case DW_TAG_thrown_type:
4436       return "DW_TAG_thrown_type";
4437     case DW_TAG_try_block:
4438       return "DW_TAG_try_block";
4439     case DW_TAG_variant_part:
4440       return "DW_TAG_variant_part";
4441     case DW_TAG_variable:
4442       return "DW_TAG_variable";
4443     case DW_TAG_volatile_type:
4444       return "DW_TAG_volatile_type";
4445     case DW_TAG_imported_module:
4446       return "DW_TAG_imported_module";
4447     case DW_TAG_MIPS_loop:
4448       return "DW_TAG_MIPS_loop";
4449     case DW_TAG_format_label:
4450       return "DW_TAG_format_label";
4451     case DW_TAG_function_template:
4452       return "DW_TAG_function_template";
4453     case DW_TAG_class_template:
4454       return "DW_TAG_class_template";
4455     case DW_TAG_GNU_BINCL:
4456       return "DW_TAG_GNU_BINCL";
4457     case DW_TAG_GNU_EINCL:
4458       return "DW_TAG_GNU_EINCL";
4459     default:
4460       return "DW_TAG_<unknown>";
4461     }
4462 }
4463
4464 /* Convert a DWARF attribute code into its string name.  */
4465
4466 static const char *
4467 dwarf_attr_name (unsigned int attr)
4468 {
4469   switch (attr)
4470     {
4471     case DW_AT_sibling:
4472       return "DW_AT_sibling";
4473     case DW_AT_location:
4474       return "DW_AT_location";
4475     case DW_AT_name:
4476       return "DW_AT_name";
4477     case DW_AT_ordering:
4478       return "DW_AT_ordering";
4479     case DW_AT_subscr_data:
4480       return "DW_AT_subscr_data";
4481     case DW_AT_byte_size:
4482       return "DW_AT_byte_size";
4483     case DW_AT_bit_offset:
4484       return "DW_AT_bit_offset";
4485     case DW_AT_bit_size:
4486       return "DW_AT_bit_size";
4487     case DW_AT_element_list:
4488       return "DW_AT_element_list";
4489     case DW_AT_stmt_list:
4490       return "DW_AT_stmt_list";
4491     case DW_AT_low_pc:
4492       return "DW_AT_low_pc";
4493     case DW_AT_high_pc:
4494       return "DW_AT_high_pc";
4495     case DW_AT_language:
4496       return "DW_AT_language";
4497     case DW_AT_member:
4498       return "DW_AT_member";
4499     case DW_AT_discr:
4500       return "DW_AT_discr";
4501     case DW_AT_discr_value:
4502       return "DW_AT_discr_value";
4503     case DW_AT_visibility:
4504       return "DW_AT_visibility";
4505     case DW_AT_import:
4506       return "DW_AT_import";
4507     case DW_AT_string_length:
4508       return "DW_AT_string_length";
4509     case DW_AT_common_reference:
4510       return "DW_AT_common_reference";
4511     case DW_AT_comp_dir:
4512       return "DW_AT_comp_dir";
4513     case DW_AT_const_value:
4514       return "DW_AT_const_value";
4515     case DW_AT_containing_type:
4516       return "DW_AT_containing_type";
4517     case DW_AT_default_value:
4518       return "DW_AT_default_value";
4519     case DW_AT_inline:
4520       return "DW_AT_inline";
4521     case DW_AT_is_optional:
4522       return "DW_AT_is_optional";
4523     case DW_AT_lower_bound:
4524       return "DW_AT_lower_bound";
4525     case DW_AT_producer:
4526       return "DW_AT_producer";
4527     case DW_AT_prototyped:
4528       return "DW_AT_prototyped";
4529     case DW_AT_return_addr:
4530       return "DW_AT_return_addr";
4531     case DW_AT_start_scope:
4532       return "DW_AT_start_scope";
4533     case DW_AT_stride_size:
4534       return "DW_AT_stride_size";
4535     case DW_AT_upper_bound:
4536       return "DW_AT_upper_bound";
4537     case DW_AT_abstract_origin:
4538       return "DW_AT_abstract_origin";
4539     case DW_AT_accessibility:
4540       return "DW_AT_accessibility";
4541     case DW_AT_address_class:
4542       return "DW_AT_address_class";
4543     case DW_AT_artificial:
4544       return "DW_AT_artificial";
4545     case DW_AT_base_types:
4546       return "DW_AT_base_types";
4547     case DW_AT_calling_convention:
4548       return "DW_AT_calling_convention";
4549     case DW_AT_count:
4550       return "DW_AT_count";
4551     case DW_AT_data_member_location:
4552       return "DW_AT_data_member_location";
4553     case DW_AT_decl_column:
4554       return "DW_AT_decl_column";
4555     case DW_AT_decl_file:
4556       return "DW_AT_decl_file";
4557     case DW_AT_decl_line:
4558       return "DW_AT_decl_line";
4559     case DW_AT_declaration:
4560       return "DW_AT_declaration";
4561     case DW_AT_discr_list:
4562       return "DW_AT_discr_list";
4563     case DW_AT_encoding:
4564       return "DW_AT_encoding";
4565     case DW_AT_external:
4566       return "DW_AT_external";
4567     case DW_AT_frame_base:
4568       return "DW_AT_frame_base";
4569     case DW_AT_friend:
4570       return "DW_AT_friend";
4571     case DW_AT_identifier_case:
4572       return "DW_AT_identifier_case";
4573     case DW_AT_macro_info:
4574       return "DW_AT_macro_info";
4575     case DW_AT_namelist_items:
4576       return "DW_AT_namelist_items";
4577     case DW_AT_priority:
4578       return "DW_AT_priority";
4579     case DW_AT_segment:
4580       return "DW_AT_segment";
4581     case DW_AT_specification:
4582       return "DW_AT_specification";
4583     case DW_AT_static_link:
4584       return "DW_AT_static_link";
4585     case DW_AT_type:
4586       return "DW_AT_type";
4587     case DW_AT_use_location:
4588       return "DW_AT_use_location";
4589     case DW_AT_variable_parameter:
4590       return "DW_AT_variable_parameter";
4591     case DW_AT_virtuality:
4592       return "DW_AT_virtuality";
4593     case DW_AT_vtable_elem_location:
4594       return "DW_AT_vtable_elem_location";
4595
4596     case DW_AT_allocated:
4597       return "DW_AT_allocated";
4598     case DW_AT_associated:
4599       return "DW_AT_associated";
4600     case DW_AT_data_location:
4601       return "DW_AT_data_location";
4602     case DW_AT_stride:
4603       return "DW_AT_stride";
4604     case DW_AT_entry_pc:
4605       return "DW_AT_entry_pc";
4606     case DW_AT_use_UTF8:
4607       return "DW_AT_use_UTF8";
4608     case DW_AT_extension:
4609       return "DW_AT_extension";
4610     case DW_AT_ranges:
4611       return "DW_AT_ranges";
4612     case DW_AT_trampoline:
4613       return "DW_AT_trampoline";
4614     case DW_AT_call_column:
4615       return "DW_AT_call_column";
4616     case DW_AT_call_file:
4617       return "DW_AT_call_file";
4618     case DW_AT_call_line:
4619       return "DW_AT_call_line";
4620
4621     case DW_AT_MIPS_fde:
4622       return "DW_AT_MIPS_fde";
4623     case DW_AT_MIPS_loop_begin:
4624       return "DW_AT_MIPS_loop_begin";
4625     case DW_AT_MIPS_tail_loop_begin:
4626       return "DW_AT_MIPS_tail_loop_begin";
4627     case DW_AT_MIPS_epilog_begin:
4628       return "DW_AT_MIPS_epilog_begin";
4629     case DW_AT_MIPS_loop_unroll_factor:
4630       return "DW_AT_MIPS_loop_unroll_factor";
4631     case DW_AT_MIPS_software_pipeline_depth:
4632       return "DW_AT_MIPS_software_pipeline_depth";
4633     case DW_AT_MIPS_linkage_name:
4634       return "DW_AT_MIPS_linkage_name";
4635     case DW_AT_MIPS_stride:
4636       return "DW_AT_MIPS_stride";
4637     case DW_AT_MIPS_abstract_name:
4638       return "DW_AT_MIPS_abstract_name";
4639     case DW_AT_MIPS_clone_origin:
4640       return "DW_AT_MIPS_clone_origin";
4641     case DW_AT_MIPS_has_inlines:
4642       return "DW_AT_MIPS_has_inlines";
4643
4644     case DW_AT_sf_names:
4645       return "DW_AT_sf_names";
4646     case DW_AT_src_info:
4647       return "DW_AT_src_info";
4648     case DW_AT_mac_info:
4649       return "DW_AT_mac_info";
4650     case DW_AT_src_coords:
4651       return "DW_AT_src_coords";
4652     case DW_AT_body_begin:
4653       return "DW_AT_body_begin";
4654     case DW_AT_body_end:
4655       return "DW_AT_body_end";
4656     case DW_AT_GNU_vector:
4657       return "DW_AT_GNU_vector";
4658
4659     case DW_AT_VMS_rtnbeg_pd_address:
4660       return "DW_AT_VMS_rtnbeg_pd_address";
4661
4662     default:
4663       return "DW_AT_<unknown>";
4664     }
4665 }
4666
4667 /* Convert a DWARF value form code into its string name.  */
4668
4669 static const char *
4670 dwarf_form_name (unsigned int form)
4671 {
4672   switch (form)
4673     {
4674     case DW_FORM_addr:
4675       return "DW_FORM_addr";
4676     case DW_FORM_block2:
4677       return "DW_FORM_block2";
4678     case DW_FORM_block4:
4679       return "DW_FORM_block4";
4680     case DW_FORM_data2:
4681       return "DW_FORM_data2";
4682     case DW_FORM_data4:
4683       return "DW_FORM_data4";
4684     case DW_FORM_data8:
4685       return "DW_FORM_data8";
4686     case DW_FORM_string:
4687       return "DW_FORM_string";
4688     case DW_FORM_block:
4689       return "DW_FORM_block";
4690     case DW_FORM_block1:
4691       return "DW_FORM_block1";
4692     case DW_FORM_data1:
4693       return "DW_FORM_data1";
4694     case DW_FORM_flag:
4695       return "DW_FORM_flag";
4696     case DW_FORM_sdata:
4697       return "DW_FORM_sdata";
4698     case DW_FORM_strp:
4699       return "DW_FORM_strp";
4700     case DW_FORM_udata:
4701       return "DW_FORM_udata";
4702     case DW_FORM_ref_addr:
4703       return "DW_FORM_ref_addr";
4704     case DW_FORM_ref1:
4705       return "DW_FORM_ref1";
4706     case DW_FORM_ref2:
4707       return "DW_FORM_ref2";
4708     case DW_FORM_ref4:
4709       return "DW_FORM_ref4";
4710     case DW_FORM_ref8:
4711       return "DW_FORM_ref8";
4712     case DW_FORM_ref_udata:
4713       return "DW_FORM_ref_udata";
4714     case DW_FORM_indirect:
4715       return "DW_FORM_indirect";
4716     default:
4717       return "DW_FORM_<unknown>";
4718     }
4719 }
4720 \f
4721 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
4722    instance of an inlined instance of a decl which is local to an inline
4723    function, so we have to trace all of the way back through the origin chain
4724    to find out what sort of node actually served as the original seed for the
4725    given block.  */
4726
4727 static tree
4728 decl_ultimate_origin (tree decl)
4729 {
4730   if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4731     return NULL_TREE;
4732
4733   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4734      nodes in the function to point to themselves; ignore that if
4735      we're trying to output the abstract instance of this function.  */
4736   if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4737     return NULL_TREE;
4738
4739   /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4740      most distant ancestor, this should never happen.  */
4741   gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4742
4743   return DECL_ABSTRACT_ORIGIN (decl);
4744 }
4745
4746 /* Determine the "ultimate origin" of a block.  The block may be an inlined
4747    instance of an inlined instance of a block which is local to an inline
4748    function, so we have to trace all of the way back through the origin chain
4749    to find out what sort of node actually served as the original seed for the
4750    given block.  */
4751
4752 static tree
4753 block_ultimate_origin (tree block)
4754 {
4755   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4756
4757   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4758      nodes in the function to point to themselves; ignore that if
4759      we're trying to output the abstract instance of this function.  */
4760   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4761     return NULL_TREE;
4762
4763   if (immediate_origin == NULL_TREE)
4764     return NULL_TREE;
4765   else
4766     {
4767       tree ret_val;
4768       tree lookahead = immediate_origin;
4769
4770       do
4771         {
4772           ret_val = lookahead;
4773           lookahead = (TREE_CODE (ret_val) == BLOCK
4774                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4775         }
4776       while (lookahead != NULL && lookahead != ret_val);
4777
4778       /* The block's abstract origin chain may not be the *ultimate* origin of
4779          the block. It could lead to a DECL that has an abstract origin set.
4780          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4781          will give us if it has one).  Note that DECL's abstract origins are
4782          supposed to be the most distant ancestor (or so decl_ultimate_origin
4783          claims), so we don't need to loop following the DECL origins.  */
4784       if (DECL_P (ret_val))
4785         return DECL_ORIGIN (ret_val);
4786
4787       return ret_val;
4788     }
4789 }
4790
4791 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
4792    of a virtual function may refer to a base class, so we check the 'this'
4793    parameter.  */
4794
4795 static tree
4796 decl_class_context (tree decl)
4797 {
4798   tree context = NULL_TREE;
4799
4800   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4801     context = DECL_CONTEXT (decl);
4802   else
4803     context = TYPE_MAIN_VARIANT
4804       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4805
4806   if (context && !TYPE_P (context))
4807     context = NULL_TREE;
4808
4809   return context;
4810 }
4811 \f
4812 /* Add an attribute/value pair to a DIE.  We build the lists up in reverse
4813    addition order, and correct that in reverse_all_dies.  */
4814
4815 static inline void
4816 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4817 {
4818   if (die != NULL && attr != NULL)
4819     {
4820       attr->dw_attr_next = die->die_attr;
4821       die->die_attr = attr;
4822     }
4823 }
4824
4825 static inline enum dw_val_class
4826 AT_class (dw_attr_ref a)
4827 {
4828   return a->dw_attr_val.val_class;
4829 }
4830
4831 /* Add a flag value attribute to a DIE.  */
4832
4833 static inline void
4834 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4835 {
4836   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4837
4838   attr->dw_attr_next = NULL;
4839   attr->dw_attr = attr_kind;
4840   attr->dw_attr_val.val_class = dw_val_class_flag;
4841   attr->dw_attr_val.v.val_flag = flag;
4842   add_dwarf_attr (die, attr);
4843 }
4844
4845 static inline unsigned
4846 AT_flag (dw_attr_ref a)
4847 {
4848   gcc_assert (a && AT_class (a) == dw_val_class_flag);
4849   return a->dw_attr_val.v.val_flag;
4850 }
4851
4852 /* Add a signed integer attribute value to a DIE.  */
4853
4854 static inline void
4855 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4856 {
4857   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4858
4859   attr->dw_attr_next = NULL;
4860   attr->dw_attr = attr_kind;
4861   attr->dw_attr_val.val_class = dw_val_class_const;
4862   attr->dw_attr_val.v.val_int = int_val;
4863   add_dwarf_attr (die, attr);
4864 }
4865
4866 static inline HOST_WIDE_INT
4867 AT_int (dw_attr_ref a)
4868 {
4869   gcc_assert (a && AT_class (a) == dw_val_class_const);
4870   return a->dw_attr_val.v.val_int;
4871 }
4872
4873 /* Add an unsigned integer attribute value to a DIE.  */
4874
4875 static inline void
4876 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4877                  unsigned HOST_WIDE_INT unsigned_val)
4878 {
4879   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4880
4881   attr->dw_attr_next = NULL;
4882   attr->dw_attr = attr_kind;
4883   attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
4884   attr->dw_attr_val.v.val_unsigned = unsigned_val;
4885   add_dwarf_attr (die, attr);
4886 }
4887
4888 static inline unsigned HOST_WIDE_INT
4889 AT_unsigned (dw_attr_ref a)
4890 {
4891   gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4892   return a->dw_attr_val.v.val_unsigned;
4893 }
4894
4895 /* Add an unsigned double integer attribute value to a DIE.  */
4896
4897 static inline void
4898 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4899                   long unsigned int val_hi, long unsigned int val_low)
4900 {
4901   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4902
4903   attr->dw_attr_next = NULL;
4904   attr->dw_attr = attr_kind;
4905   attr->dw_attr_val.val_class = dw_val_class_long_long;
4906   attr->dw_attr_val.v.val_long_long.hi = val_hi;
4907   attr->dw_attr_val.v.val_long_long.low = val_low;
4908   add_dwarf_attr (die, attr);
4909 }
4910
4911 /* Add a floating point attribute value to a DIE and return it.  */
4912
4913 static inline void
4914 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4915             unsigned int length, unsigned int elt_size, unsigned char *array)
4916 {
4917   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4918
4919   attr->dw_attr_next = NULL;
4920   attr->dw_attr = attr_kind;
4921   attr->dw_attr_val.val_class = dw_val_class_vec;
4922   attr->dw_attr_val.v.val_vec.length = length;
4923   attr->dw_attr_val.v.val_vec.elt_size = elt_size;
4924   attr->dw_attr_val.v.val_vec.array = array;
4925   add_dwarf_attr (die, attr);
4926 }
4927
4928 /* Hash and equality functions for debug_str_hash.  */
4929
4930 static hashval_t
4931 debug_str_do_hash (const void *x)
4932 {
4933   return htab_hash_string (((const struct indirect_string_node *)x)->str);
4934 }
4935
4936 static int
4937 debug_str_eq (const void *x1, const void *x2)
4938 {
4939   return strcmp ((((const struct indirect_string_node *)x1)->str),
4940                  (const char *)x2) == 0;
4941 }
4942
4943 /* Add a string attribute value to a DIE.  */
4944
4945 static inline void
4946 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4947 {
4948   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4949   struct indirect_string_node *node;
4950   void **slot;
4951
4952   if (! debug_str_hash)
4953     debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
4954                                       debug_str_eq, NULL);
4955
4956   slot = htab_find_slot_with_hash (debug_str_hash, str,
4957                                    htab_hash_string (str), INSERT);
4958   if (*slot == NULL)
4959     *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
4960   node = (struct indirect_string_node *) *slot;
4961   node->str = ggc_strdup (str);
4962   node->refcount++;
4963
4964   attr->dw_attr_next = NULL;
4965   attr->dw_attr = attr_kind;
4966   attr->dw_attr_val.val_class = dw_val_class_str;
4967   attr->dw_attr_val.v.val_str = node;
4968   add_dwarf_attr (die, attr);
4969 }
4970
4971 static inline const char *
4972 AT_string (dw_attr_ref a)
4973 {
4974   gcc_assert (a && AT_class (a) == dw_val_class_str);
4975   return a->dw_attr_val.v.val_str->str;
4976 }
4977
4978 /* Find out whether a string should be output inline in DIE
4979    or out-of-line in .debug_str section.  */
4980
4981 static int
4982 AT_string_form (dw_attr_ref a)
4983 {
4984   struct indirect_string_node *node;
4985   unsigned int len;
4986   char label[32];
4987
4988   gcc_assert (a && AT_class (a) == dw_val_class_str);
4989
4990   node = a->dw_attr_val.v.val_str;
4991   if (node->form)
4992     return node->form;
4993
4994   len = strlen (node->str) + 1;
4995
4996   /* If the string is shorter or equal to the size of the reference, it is
4997      always better to put it inline.  */
4998   if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4999     return node->form = DW_FORM_string;
5000
5001   /* If we cannot expect the linker to merge strings in .debug_str
5002      section, only put it into .debug_str if it is worth even in this
5003      single module.  */
5004   if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5005       && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5006     return node->form = DW_FORM_string;
5007
5008   ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5009   ++dw2_string_counter;
5010   node->label = xstrdup (label);
5011
5012   return node->form = DW_FORM_strp;
5013 }
5014
5015 /* Add a DIE reference attribute value to a DIE.  */
5016
5017 static inline void
5018 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5019 {
5020   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5021
5022   attr->dw_attr_next = NULL;
5023   attr->dw_attr = attr_kind;
5024   attr->dw_attr_val.val_class = dw_val_class_die_ref;
5025   attr->dw_attr_val.v.val_die_ref.die = targ_die;
5026   attr->dw_attr_val.v.val_die_ref.external = 0;
5027   add_dwarf_attr (die, attr);
5028 }
5029
5030 /* Add an AT_specification attribute to a DIE, and also make the back
5031    pointer from the specification to the definition.  */
5032
5033 static inline void
5034 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5035 {
5036   add_AT_die_ref (die, DW_AT_specification, targ_die);
5037   gcc_assert (!targ_die->die_definition);
5038   targ_die->die_definition = die;
5039 }
5040
5041 static inline dw_die_ref
5042 AT_ref (dw_attr_ref a)
5043 {
5044   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5045   return a->dw_attr_val.v.val_die_ref.die;
5046 }
5047
5048 static inline int
5049 AT_ref_external (dw_attr_ref a)
5050 {
5051   if (a && AT_class (a) == dw_val_class_die_ref)
5052     return a->dw_attr_val.v.val_die_ref.external;
5053
5054   return 0;
5055 }
5056
5057 static inline void
5058 set_AT_ref_external (dw_attr_ref a, int i)
5059 {
5060   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5061   a->dw_attr_val.v.val_die_ref.external = i;
5062 }
5063
5064 /* Add an FDE reference attribute value to a DIE.  */
5065
5066 static inline void
5067 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5068 {
5069   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5070
5071   attr->dw_attr_next = NULL;
5072   attr->dw_attr = attr_kind;
5073   attr->dw_attr_val.val_class = dw_val_class_fde_ref;
5074   attr->dw_attr_val.v.val_fde_index = targ_fde;
5075   add_dwarf_attr (die, attr);
5076 }
5077
5078 /* Add a location description attribute value to a DIE.  */
5079
5080 static inline void
5081 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5082 {
5083   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5084
5085   attr->dw_attr_next = NULL;
5086   attr->dw_attr = attr_kind;
5087   attr->dw_attr_val.val_class = dw_val_class_loc;
5088   attr->dw_attr_val.v.val_loc = loc;
5089   add_dwarf_attr (die, attr);
5090 }
5091
5092 static inline dw_loc_descr_ref
5093 AT_loc (dw_attr_ref a)
5094 {
5095   gcc_assert (a && AT_class (a) == dw_val_class_loc);
5096   return a->dw_attr_val.v.val_loc;
5097 }
5098
5099 static inline void
5100 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5101 {
5102   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5103
5104   attr->dw_attr_next = NULL;
5105   attr->dw_attr = attr_kind;
5106   attr->dw_attr_val.val_class = dw_val_class_loc_list;
5107   attr->dw_attr_val.v.val_loc_list = loc_list;
5108   add_dwarf_attr (die, attr);
5109   have_location_lists = true;
5110 }
5111
5112 static inline dw_loc_list_ref
5113 AT_loc_list (dw_attr_ref a)
5114 {
5115   gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5116   return a->dw_attr_val.v.val_loc_list;
5117 }
5118
5119 /* Add an address constant attribute value to a DIE.  */
5120
5121 static inline void
5122 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5123 {
5124   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5125
5126   attr->dw_attr_next = NULL;
5127   attr->dw_attr = attr_kind;
5128   attr->dw_attr_val.val_class = dw_val_class_addr;
5129   attr->dw_attr_val.v.val_addr = addr;
5130   add_dwarf_attr (die, attr);
5131 }
5132
5133 static inline rtx
5134 AT_addr (dw_attr_ref a)
5135 {
5136   gcc_assert (a && AT_class (a) == dw_val_class_addr);
5137   return a->dw_attr_val.v.val_addr;
5138 }
5139
5140 /* Add a label identifier attribute value to a DIE.  */
5141
5142 static inline void
5143 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5144 {
5145   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5146
5147   attr->dw_attr_next = NULL;
5148   attr->dw_attr = attr_kind;
5149   attr->dw_attr_val.val_class = dw_val_class_lbl_id;
5150   attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5151   add_dwarf_attr (die, attr);
5152 }
5153
5154 /* Add a section offset attribute value to a DIE.  */
5155
5156 static inline void
5157 add_AT_lbl_offset (dw_die_ref die, enum dwarf_attribute attr_kind, const char *label)
5158 {
5159   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5160
5161   attr->dw_attr_next = NULL;
5162   attr->dw_attr = attr_kind;
5163   attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
5164   attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
5165   add_dwarf_attr (die, attr);
5166 }
5167
5168 /* Add an offset attribute value to a DIE.  */
5169
5170 static inline void
5171 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5172                unsigned HOST_WIDE_INT offset)
5173 {
5174   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5175
5176   attr->dw_attr_next = NULL;
5177   attr->dw_attr = attr_kind;
5178   attr->dw_attr_val.val_class = dw_val_class_offset;
5179   attr->dw_attr_val.v.val_offset = offset;
5180   add_dwarf_attr (die, attr);
5181 }
5182
5183 /* Add an range_list attribute value to a DIE.  */
5184
5185 static void
5186 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5187                    long unsigned int offset)
5188 {
5189   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5190
5191   attr->dw_attr_next = NULL;
5192   attr->dw_attr = attr_kind;
5193   attr->dw_attr_val.val_class = dw_val_class_range_list;
5194   attr->dw_attr_val.v.val_offset = offset;
5195   add_dwarf_attr (die, attr);
5196 }
5197
5198 static inline const char *
5199 AT_lbl (dw_attr_ref a)
5200 {
5201   gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5202                     || AT_class (a) == dw_val_class_lbl_offset));
5203   return a->dw_attr_val.v.val_lbl_id;
5204 }
5205
5206 /* Get the attribute of type attr_kind.  */
5207
5208 static dw_attr_ref
5209 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5210 {
5211   dw_attr_ref a;
5212   dw_die_ref spec = NULL;
5213
5214   if (die != NULL)
5215     {
5216       for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5217         if (a->dw_attr == attr_kind)
5218           return a;
5219         else if (a->dw_attr == DW_AT_specification
5220                  || a->dw_attr == DW_AT_abstract_origin)
5221           spec = AT_ref (a);
5222
5223       if (spec)
5224         return get_AT (spec, attr_kind);
5225     }
5226
5227   return NULL;
5228 }
5229
5230 /* Return the "low pc" attribute value, typically associated with a subprogram
5231    DIE.  Return null if the "low pc" attribute is either not present, or if it
5232    cannot be represented as an assembler label identifier.  */
5233
5234 static inline const char *
5235 get_AT_low_pc (dw_die_ref die)
5236 {
5237   dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5238
5239   return a ? AT_lbl (a) : NULL;
5240 }
5241
5242 /* Return the "high pc" attribute value, typically associated with a subprogram
5243    DIE.  Return null if the "high pc" attribute is either not present, or if it
5244    cannot be represented as an assembler label identifier.  */
5245
5246 static inline const char *
5247 get_AT_hi_pc (dw_die_ref die)
5248 {
5249   dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5250
5251   return a ? AT_lbl (a) : NULL;
5252 }
5253
5254 /* Return the value of the string attribute designated by ATTR_KIND, or
5255    NULL if it is not present.  */
5256
5257 static inline const char *
5258 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5259 {
5260   dw_attr_ref a = get_AT (die, attr_kind);
5261
5262   return a ? AT_string (a) : NULL;
5263 }
5264
5265 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5266    if it is not present.  */
5267
5268 static inline int
5269 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5270 {
5271   dw_attr_ref a = get_AT (die, attr_kind);
5272
5273   return a ? AT_flag (a) : 0;
5274 }
5275
5276 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5277    if it is not present.  */
5278
5279 static inline unsigned
5280 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5281 {
5282   dw_attr_ref a = get_AT (die, attr_kind);
5283
5284   return a ? AT_unsigned (a) : 0;
5285 }
5286
5287 static inline dw_die_ref
5288 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5289 {
5290   dw_attr_ref a = get_AT (die, attr_kind);
5291
5292   return a ? AT_ref (a) : NULL;
5293 }
5294
5295 /* Return TRUE if the language is C or C++.  */
5296
5297 static inline bool
5298 is_c_family (void)
5299 {
5300   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5301
5302   return (lang == DW_LANG_C || lang == DW_LANG_C89
5303           || lang == DW_LANG_C_plus_plus);
5304 }
5305
5306 /* Return TRUE if the language is C++.  */
5307
5308 static inline bool
5309 is_cxx (void)
5310 {
5311   return (get_AT_unsigned (comp_unit_die, DW_AT_language)
5312           == DW_LANG_C_plus_plus);
5313 }
5314
5315 /* Return TRUE if the language is Fortran.  */
5316
5317 static inline bool
5318 is_fortran (void)
5319 {
5320   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5321
5322   return (lang == DW_LANG_Fortran77
5323           || lang == DW_LANG_Fortran90
5324           || lang == DW_LANG_Fortran95);
5325 }
5326
5327 /* Return TRUE if the language is Java.  */
5328
5329 static inline bool
5330 is_java (void)
5331 {
5332   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5333
5334   return lang == DW_LANG_Java;
5335 }
5336
5337 /* Return TRUE if the language is Ada.  */
5338
5339 static inline bool
5340 is_ada (void)
5341 {
5342   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5343
5344   return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5345 }
5346
5347 /* Free up the memory used by A.  */
5348
5349 static inline void free_AT (dw_attr_ref);
5350 static inline void
5351 free_AT (dw_attr_ref a)
5352 {
5353   if (AT_class (a) == dw_val_class_str)
5354     if (a->dw_attr_val.v.val_str->refcount)
5355       a->dw_attr_val.v.val_str->refcount--;
5356 }
5357
5358 /* Remove the specified attribute if present.  */
5359
5360 static void
5361 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5362 {
5363   dw_attr_ref *p;
5364   dw_attr_ref removed = NULL;
5365
5366   if (die != NULL)
5367     {
5368       for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
5369         if ((*p)->dw_attr == attr_kind)
5370           {
5371             removed = *p;
5372             *p = (*p)->dw_attr_next;
5373             break;
5374           }
5375
5376       if (removed != 0)
5377         free_AT (removed);
5378     }
5379 }
5380
5381 /* Remove child die whose die_tag is specified tag.  */
5382
5383 static void
5384 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5385 {
5386   dw_die_ref current, prev, next;
5387   current = die->die_child;
5388   prev = NULL;
5389   while (current != NULL)
5390     {
5391       if (current->die_tag == tag)
5392         {
5393           next = current->die_sib;
5394           if (prev == NULL)
5395             die->die_child = next;
5396           else
5397             prev->die_sib = next;
5398           free_die (current);
5399           current = next;
5400         }
5401       else
5402         {
5403           prev = current;
5404           current = current->die_sib;
5405         }
5406     }
5407 }
5408
5409 /* Free up the memory used by DIE.  */
5410
5411 static inline void
5412 free_die (dw_die_ref die)
5413 {
5414   remove_children (die);
5415 }
5416
5417 /* Discard the children of this DIE.  */
5418
5419 static void
5420 remove_children (dw_die_ref die)
5421 {
5422   dw_die_ref child_die = die->die_child;
5423
5424   die->die_child = NULL;
5425
5426   while (child_die != NULL)
5427     {
5428       dw_die_ref tmp_die = child_die;
5429       dw_attr_ref a;
5430
5431       child_die = child_die->die_sib;
5432
5433       for (a = tmp_die->die_attr; a != NULL;)
5434         {
5435           dw_attr_ref tmp_a = a;
5436
5437           a = a->dw_attr_next;
5438           free_AT (tmp_a);
5439         }
5440
5441       free_die (tmp_die);
5442     }
5443 }
5444
5445 /* Add a child DIE below its parent.  We build the lists up in reverse
5446    addition order, and correct that in reverse_all_dies.  */
5447
5448 static inline void
5449 add_child_die (dw_die_ref die, dw_die_ref child_die)
5450 {
5451   if (die != NULL && child_die != NULL)
5452     {
5453       gcc_assert (die != child_die);
5454
5455       child_die->die_parent = die;
5456       child_die->die_sib = die->die_child;
5457       die->die_child = child_die;
5458     }
5459 }
5460
5461 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5462    is the specification, to the front of PARENT's list of children.  */
5463
5464 static void
5465 splice_child_die (dw_die_ref parent, dw_die_ref child)
5466 {
5467   dw_die_ref *p;
5468
5469   /* We want the declaration DIE from inside the class, not the
5470      specification DIE at toplevel.  */
5471   if (child->die_parent != parent)
5472     {
5473       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5474
5475       if (tmp)
5476         child = tmp;
5477     }
5478
5479   gcc_assert (child->die_parent == parent
5480               || (child->die_parent
5481                   == get_AT_ref (parent, DW_AT_specification)));
5482
5483   for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
5484     if (*p == child)
5485       {
5486         *p = child->die_sib;
5487         break;
5488       }
5489
5490   child->die_parent = parent;
5491   child->die_sib = parent->die_child;
5492   parent->die_child = child;
5493 }
5494
5495 /* Return a pointer to a newly created DIE node.  */
5496
5497 static inline dw_die_ref
5498 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5499 {
5500   dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5501
5502   die->die_tag = tag_value;
5503
5504   if (parent_die != NULL)
5505     add_child_die (parent_die, die);
5506   else
5507     {
5508       limbo_die_node *limbo_node;
5509
5510       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5511       limbo_node->die = die;
5512       limbo_node->created_for = t;
5513       limbo_node->next = limbo_die_list;
5514       limbo_die_list = limbo_node;
5515     }
5516
5517   return die;
5518 }
5519
5520 /* Return the DIE associated with the given type specifier.  */
5521
5522 static inline dw_die_ref
5523 lookup_type_die (tree type)
5524 {
5525   return TYPE_SYMTAB_DIE (type);
5526 }
5527
5528 /* Equate a DIE to a given type specifier.  */
5529
5530 static inline void
5531 equate_type_number_to_die (tree type, dw_die_ref type_die)
5532 {
5533   TYPE_SYMTAB_DIE (type) = type_die;
5534 }
5535
5536 /* Returns a hash value for X (which really is a die_struct).  */
5537
5538 static hashval_t
5539 decl_die_table_hash (const void *x)
5540 {
5541   return (hashval_t) ((const dw_die_ref) x)->decl_id;
5542 }
5543
5544 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
5545
5546 static int
5547 decl_die_table_eq (const void *x, const void *y)
5548 {
5549   return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5550 }
5551
5552 /* Return the DIE associated with a given declaration.  */
5553
5554 static inline dw_die_ref
5555 lookup_decl_die (tree decl)
5556 {
5557   return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5558 }
5559
5560 /* Returns a hash value for X (which really is a var_loc_list).  */
5561
5562 static hashval_t
5563 decl_loc_table_hash (const void *x)
5564 {
5565   return (hashval_t) ((const var_loc_list *) x)->decl_id;
5566 }
5567
5568 /* Return nonzero if decl_id of var_loc_list X is the same as
5569    UID of decl *Y.  */
5570
5571 static int
5572 decl_loc_table_eq (const void *x, const void *y)
5573 {
5574   return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5575 }
5576
5577 /* Return the var_loc list associated with a given declaration.  */
5578
5579 static inline var_loc_list *
5580 lookup_decl_loc (tree decl)
5581 {
5582   return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5583 }
5584
5585 /* Equate a DIE to a particular declaration.  */
5586
5587 static void
5588 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5589 {
5590   unsigned int decl_id = DECL_UID (decl);
5591   void **slot;
5592
5593   slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5594   *slot = decl_die;
5595   decl_die->decl_id = decl_id;
5596 }
5597
5598 /* Add a variable location node to the linked list for DECL.  */
5599
5600 static void
5601 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5602 {
5603   unsigned int decl_id = DECL_UID (decl);
5604   var_loc_list *temp;
5605   void **slot;
5606
5607   slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5608   if (*slot == NULL)
5609     {
5610       temp = ggc_alloc_cleared (sizeof (var_loc_list));
5611       temp->decl_id = decl_id;
5612       *slot = temp;
5613     }
5614   else
5615     temp = *slot;
5616
5617   if (temp->last)
5618     {
5619       /* If the current location is the same as the end of the list,
5620          we have nothing to do.  */
5621       if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5622                         NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5623         {
5624           /* Add LOC to the end of list and update LAST.  */
5625           temp->last->next = loc;
5626           temp->last = loc;
5627         }
5628     }
5629   /* Do not add empty location to the beginning of the list.  */
5630   else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5631     {
5632       temp->first = loc;
5633       temp->last = loc;
5634     }
5635 }
5636 \f
5637 /* Keep track of the number of spaces used to indent the
5638    output of the debugging routines that print the structure of
5639    the DIE internal representation.  */
5640 static int print_indent;
5641
5642 /* Indent the line the number of spaces given by print_indent.  */
5643
5644 static inline void
5645 print_spaces (FILE *outfile)
5646 {
5647   fprintf (outfile, "%*s", print_indent, "");
5648 }
5649
5650 /* Print the information associated with a given DIE, and its children.
5651    This routine is a debugging aid only.  */
5652
5653 static void
5654 print_die (dw_die_ref die, FILE *outfile)
5655 {
5656   dw_attr_ref a;
5657   dw_die_ref c;
5658
5659   print_spaces (outfile);
5660   fprintf (outfile, "DIE %4lu: %s\n",
5661            die->die_offset, dwarf_tag_name (die->die_tag));
5662   print_spaces (outfile);
5663   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5664   fprintf (outfile, " offset: %lu\n", die->die_offset);
5665
5666   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5667     {
5668       print_spaces (outfile);
5669       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5670
5671       switch (AT_class (a))
5672         {
5673         case dw_val_class_addr:
5674           fprintf (outfile, "address");
5675           break;
5676         case dw_val_class_offset:
5677           fprintf (outfile, "offset");
5678           break;
5679         case dw_val_class_loc:
5680           fprintf (outfile, "location descriptor");
5681           break;
5682         case dw_val_class_loc_list:
5683           fprintf (outfile, "location list -> label:%s",
5684                    AT_loc_list (a)->ll_symbol);
5685           break;
5686         case dw_val_class_range_list:
5687           fprintf (outfile, "range list");
5688           break;
5689         case dw_val_class_const:
5690           fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5691           break;
5692         case dw_val_class_unsigned_const:
5693           fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5694           break;
5695         case dw_val_class_long_long:
5696           fprintf (outfile, "constant (%lu,%lu)",
5697                    a->dw_attr_val.v.val_long_long.hi,
5698                    a->dw_attr_val.v.val_long_long.low);
5699           break;
5700         case dw_val_class_vec:
5701           fprintf (outfile, "floating-point or vector constant");
5702           break;
5703         case dw_val_class_flag:
5704           fprintf (outfile, "%u", AT_flag (a));
5705           break;
5706         case dw_val_class_die_ref:
5707           if (AT_ref (a) != NULL)
5708             {
5709               if (AT_ref (a)->die_symbol)
5710                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5711               else
5712                 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5713             }
5714           else
5715             fprintf (outfile, "die -> <null>");
5716           break;
5717         case dw_val_class_lbl_id:
5718         case dw_val_class_lbl_offset:
5719           fprintf (outfile, "label: %s", AT_lbl (a));
5720           break;
5721         case dw_val_class_str:
5722           if (AT_string (a) != NULL)
5723             fprintf (outfile, "\"%s\"", AT_string (a));
5724           else
5725             fprintf (outfile, "<null>");
5726           break;
5727         default:
5728           break;
5729         }
5730
5731       fprintf (outfile, "\n");
5732     }
5733
5734   if (die->die_child != NULL)
5735     {
5736       print_indent += 4;
5737       for (c = die->die_child; c != NULL; c = c->die_sib)
5738         print_die (c, outfile);
5739
5740       print_indent -= 4;
5741     }
5742   if (print_indent == 0)
5743     fprintf (outfile, "\n");
5744 }
5745
5746 /* Print the contents of the source code line number correspondence table.
5747    This routine is a debugging aid only.  */
5748
5749 static void
5750 print_dwarf_line_table (FILE *outfile)
5751 {
5752   unsigned i;
5753   dw_line_info_ref line_info;
5754
5755   fprintf (outfile, "\n\nDWARF source line information\n");
5756   for (i = 1; i < line_info_table_in_use; i++)
5757     {
5758       line_info = &line_info_table[i];
5759       fprintf (outfile, "%5d: ", i);
5760       fprintf (outfile, "%-20s",
5761                VARRAY_CHAR_PTR (file_table, line_info->dw_file_num));
5762       fprintf (outfile, "%6ld", line_info->dw_line_num);
5763       fprintf (outfile, "\n");
5764     }
5765
5766   fprintf (outfile, "\n\n");
5767 }
5768
5769 /* Print the information collected for a given DIE.  */
5770
5771 void
5772 debug_dwarf_die (dw_die_ref die)
5773 {
5774   print_die (die, stderr);
5775 }
5776
5777 /* Print all DWARF information collected for the compilation unit.
5778    This routine is a debugging aid only.  */
5779
5780 void
5781 debug_dwarf (void)
5782 {
5783   print_indent = 0;
5784   print_die (comp_unit_die, stderr);
5785   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5786     print_dwarf_line_table (stderr);
5787 }
5788 \f
5789 /* We build up the lists of children and attributes by pushing new ones
5790    onto the beginning of the list.  Reverse the lists for DIE so that
5791    they are in order of addition.  */
5792
5793 static void
5794 reverse_die_lists (dw_die_ref die)
5795 {
5796   dw_die_ref c, cp, cn;
5797   dw_attr_ref a, ap, an;
5798
5799   for (a = die->die_attr, ap = 0; a; a = an)
5800     {
5801       an = a->dw_attr_next;
5802       a->dw_attr_next = ap;
5803       ap = a;
5804     }
5805
5806   die->die_attr = ap;
5807
5808   for (c = die->die_child, cp = 0; c; c = cn)
5809     {
5810       cn = c->die_sib;
5811       c->die_sib = cp;
5812       cp = c;
5813     }
5814
5815   die->die_child = cp;
5816 }
5817
5818 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5819    reverse all dies in add_sibling_attributes, which runs through all the dies,
5820    it would reverse all the dies.  Now, however, since we don't call
5821    reverse_die_lists in add_sibling_attributes, we need a routine to
5822    recursively reverse all the dies. This is that routine.  */
5823
5824 static void
5825 reverse_all_dies (dw_die_ref die)
5826 {
5827   dw_die_ref c;
5828
5829   reverse_die_lists (die);
5830
5831   for (c = die->die_child; c; c = c->die_sib)
5832     reverse_all_dies (c);
5833 }
5834
5835 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5836    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5837    DIE that marks the start of the DIEs for this include file.  */
5838
5839 static dw_die_ref
5840 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5841 {
5842   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5843   dw_die_ref new_unit = gen_compile_unit_die (filename);
5844
5845   new_unit->die_sib = old_unit;
5846   return new_unit;
5847 }
5848
5849 /* Close an include-file CU and reopen the enclosing one.  */
5850
5851 static dw_die_ref
5852 pop_compile_unit (dw_die_ref old_unit)
5853 {
5854   dw_die_ref new_unit = old_unit->die_sib;
5855
5856   old_unit->die_sib = NULL;
5857   return new_unit;
5858 }
5859
5860 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5861 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5862
5863 /* Calculate the checksum of a location expression.  */
5864
5865 static inline void
5866 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5867 {
5868   CHECKSUM (loc->dw_loc_opc);
5869   CHECKSUM (loc->dw_loc_oprnd1);
5870   CHECKSUM (loc->dw_loc_oprnd2);
5871 }
5872
5873 /* Calculate the checksum of an attribute.  */
5874
5875 static void
5876 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5877 {
5878   dw_loc_descr_ref loc;
5879   rtx r;
5880
5881   CHECKSUM (at->dw_attr);
5882
5883   /* We don't care about differences in file numbering.  */
5884   if (at->dw_attr == DW_AT_decl_file
5885       /* Or that this was compiled with a different compiler snapshot; if
5886          the output is the same, that's what matters.  */
5887       || at->dw_attr == DW_AT_producer)
5888     return;
5889
5890   switch (AT_class (at))
5891     {
5892     case dw_val_class_const:
5893       CHECKSUM (at->dw_attr_val.v.val_int);
5894       break;
5895     case dw_val_class_unsigned_const:
5896       CHECKSUM (at->dw_attr_val.v.val_unsigned);
5897       break;
5898     case dw_val_class_long_long:
5899       CHECKSUM (at->dw_attr_val.v.val_long_long);
5900       break;
5901     case dw_val_class_vec:
5902       CHECKSUM (at->dw_attr_val.v.val_vec);
5903       break;
5904     case dw_val_class_flag:
5905       CHECKSUM (at->dw_attr_val.v.val_flag);
5906       break;
5907     case dw_val_class_str:
5908       CHECKSUM_STRING (AT_string (at));
5909       break;
5910
5911     case dw_val_class_addr:
5912       r = AT_addr (at);
5913       gcc_assert (GET_CODE (r) == SYMBOL_REF);
5914       CHECKSUM_STRING (XSTR (r, 0));
5915       break;
5916
5917     case dw_val_class_offset:
5918       CHECKSUM (at->dw_attr_val.v.val_offset);
5919       break;
5920
5921     case dw_val_class_loc:
5922       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5923         loc_checksum (loc, ctx);
5924       break;
5925
5926     case dw_val_class_die_ref:
5927       die_checksum (AT_ref (at), ctx, mark);
5928       break;
5929
5930     case dw_val_class_fde_ref:
5931     case dw_val_class_lbl_id:
5932     case dw_val_class_lbl_offset:
5933       break;
5934
5935     default:
5936       break;
5937     }
5938 }
5939
5940 /* Calculate the checksum of a DIE.  */
5941
5942 static void
5943 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5944 {
5945   dw_die_ref c;
5946   dw_attr_ref a;
5947
5948   /* To avoid infinite recursion.  */
5949   if (die->die_mark)
5950     {
5951       CHECKSUM (die->die_mark);
5952       return;
5953     }
5954   die->die_mark = ++(*mark);
5955
5956   CHECKSUM (die->die_tag);
5957
5958   for (a = die->die_attr; a; a = a->dw_attr_next)
5959     attr_checksum (a, ctx, mark);
5960
5961   for (c = die->die_child; c; c = c->die_sib)
5962     die_checksum (c, ctx, mark);
5963 }
5964
5965 #undef CHECKSUM
5966 #undef CHECKSUM_STRING
5967
5968 /* Do the location expressions look same?  */
5969 static inline int
5970 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
5971 {
5972   return loc1->dw_loc_opc == loc2->dw_loc_opc
5973          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
5974          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
5975 }
5976
5977 /* Do the values look the same?  */
5978 static int
5979 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
5980 {
5981   dw_loc_descr_ref loc1, loc2;
5982   rtx r1, r2;
5983
5984   if (v1->val_class != v2->val_class)
5985     return 0;
5986
5987   switch (v1->val_class)
5988     {
5989     case dw_val_class_const:
5990       return v1->v.val_int == v2->v.val_int;
5991     case dw_val_class_unsigned_const:
5992       return v1->v.val_unsigned == v2->v.val_unsigned;
5993     case dw_val_class_long_long:
5994       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
5995              && v1->v.val_long_long.low == v2->v.val_long_long.low;
5996     case dw_val_class_vec:
5997       if (v1->v.val_vec.length != v2->v.val_vec.length
5998           || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
5999         return 0;
6000       if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6001                   v1->v.val_vec.length * v1->v.val_vec.elt_size))
6002         return 0;
6003       return 1;
6004     case dw_val_class_flag:
6005       return v1->v.val_flag == v2->v.val_flag;
6006     case dw_val_class_str:
6007       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6008
6009     case dw_val_class_addr:
6010       r1 = v1->v.val_addr;
6011       r2 = v2->v.val_addr;
6012       if (GET_CODE (r1) != GET_CODE (r2))
6013         return 0;
6014       gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6015       return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6016
6017     case dw_val_class_offset:
6018       return v1->v.val_offset == v2->v.val_offset;
6019
6020     case dw_val_class_loc:
6021       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6022            loc1 && loc2;
6023            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6024         if (!same_loc_p (loc1, loc2, mark))
6025           return 0;
6026       return !loc1 && !loc2;
6027
6028     case dw_val_class_die_ref:
6029       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6030
6031     case dw_val_class_fde_ref:
6032     case dw_val_class_lbl_id:
6033     case dw_val_class_lbl_offset:
6034       return 1;
6035
6036     default:
6037       return 1;
6038     }
6039 }
6040
6041 /* Do the attributes look the same?  */
6042
6043 static int
6044 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6045 {
6046   if (at1->dw_attr != at2->dw_attr)
6047     return 0;
6048
6049   /* We don't care about differences in file numbering.  */
6050   if (at1->dw_attr == DW_AT_decl_file
6051       /* Or that this was compiled with a different compiler snapshot; if
6052          the output is the same, that's what matters.  */
6053       || at1->dw_attr == DW_AT_producer)
6054     return 1;
6055
6056   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6057 }
6058
6059 /* Do the dies look the same?  */
6060
6061 static int
6062 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6063 {
6064   dw_die_ref c1, c2;
6065   dw_attr_ref a1, a2;
6066
6067   /* To avoid infinite recursion.  */
6068   if (die1->die_mark)
6069     return die1->die_mark == die2->die_mark;
6070   die1->die_mark = die2->die_mark = ++(*mark);
6071
6072   if (die1->die_tag != die2->die_tag)
6073     return 0;
6074
6075   for (a1 = die1->die_attr, a2 = die2->die_attr;
6076        a1 && a2;
6077        a1 = a1->dw_attr_next, a2 = a2->dw_attr_next)
6078     if (!same_attr_p (a1, a2, mark))
6079       return 0;
6080   if (a1 || a2)
6081     return 0;
6082
6083   for (c1 = die1->die_child, c2 = die2->die_child;
6084        c1 && c2;
6085        c1 = c1->die_sib, c2 = c2->die_sib)
6086     if (!same_die_p (c1, c2, mark))
6087       return 0;
6088   if (c1 || c2)
6089     return 0;
6090
6091   return 1;
6092 }
6093
6094 /* Do the dies look the same?  Wrapper around same_die_p.  */
6095
6096 static int
6097 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6098 {
6099   int mark = 0;
6100   int ret = same_die_p (die1, die2, &mark);
6101
6102   unmark_all_dies (die1);
6103   unmark_all_dies (die2);
6104
6105   return ret;
6106 }
6107
6108 /* The prefix to attach to symbols on DIEs in the current comdat debug
6109    info section.  */
6110 static char *comdat_symbol_id;
6111
6112 /* The index of the current symbol within the current comdat CU.  */
6113 static unsigned int comdat_symbol_number;
6114
6115 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6116    children, and set comdat_symbol_id accordingly.  */
6117
6118 static void
6119 compute_section_prefix (dw_die_ref unit_die)
6120 {
6121   const char *die_name = get_AT_string (unit_die, DW_AT_name);
6122   const char *base = die_name ? lbasename (die_name) : "anonymous";
6123   char *name = alloca (strlen (base) + 64);
6124   char *p;
6125   int i, mark;
6126   unsigned char checksum[16];
6127   struct md5_ctx ctx;
6128
6129   /* Compute the checksum of the DIE, then append part of it as hex digits to
6130      the name filename of the unit.  */
6131
6132   md5_init_ctx (&ctx);
6133   mark = 0;
6134   die_checksum (unit_die, &ctx, &mark);
6135   unmark_all_dies (unit_die);
6136   md5_finish_ctx (&ctx, checksum);
6137
6138   sprintf (name, "%s.", base);
6139   clean_symbol_name (name);
6140
6141   p = name + strlen (name);
6142   for (i = 0; i < 4; i++)
6143     {
6144       sprintf (p, "%.2x", checksum[i]);
6145       p += 2;
6146     }
6147
6148   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6149   comdat_symbol_number = 0;
6150 }
6151
6152 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
6153
6154 static int
6155 is_type_die (dw_die_ref die)
6156 {
6157   switch (die->die_tag)
6158     {
6159     case DW_TAG_array_type:
6160     case DW_TAG_class_type:
6161     case DW_TAG_enumeration_type:
6162     case DW_TAG_pointer_type:
6163     case DW_TAG_reference_type:
6164     case DW_TAG_string_type:
6165     case DW_TAG_structure_type:
6166     case DW_TAG_subroutine_type:
6167     case DW_TAG_union_type:
6168     case DW_TAG_ptr_to_member_type:
6169     case DW_TAG_set_type:
6170     case DW_TAG_subrange_type:
6171     case DW_TAG_base_type:
6172     case DW_TAG_const_type:
6173     case DW_TAG_file_type:
6174     case DW_TAG_packed_type:
6175     case DW_TAG_volatile_type:
6176     case DW_TAG_typedef:
6177       return 1;
6178     default:
6179       return 0;
6180     }
6181 }
6182
6183 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6184    Basically, we want to choose the bits that are likely to be shared between
6185    compilations (types) and leave out the bits that are specific to individual
6186    compilations (functions).  */
6187
6188 static int
6189 is_comdat_die (dw_die_ref c)
6190 {
6191   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6192      we do for stabs.  The advantage is a greater likelihood of sharing between
6193      objects that don't include headers in the same order (and therefore would
6194      put the base types in a different comdat).  jason 8/28/00 */
6195
6196   if (c->die_tag == DW_TAG_base_type)
6197     return 0;
6198
6199   if (c->die_tag == DW_TAG_pointer_type
6200       || c->die_tag == DW_TAG_reference_type
6201       || c->die_tag == DW_TAG_const_type
6202       || c->die_tag == DW_TAG_volatile_type)
6203     {
6204       dw_die_ref t = get_AT_ref (c, DW_AT_type);
6205
6206       return t ? is_comdat_die (t) : 0;
6207     }
6208
6209   return is_type_die (c);
6210 }
6211
6212 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6213    compilation unit.  */
6214
6215 static int
6216 is_symbol_die (dw_die_ref c)
6217 {
6218   return (is_type_die (c)
6219           || (get_AT (c, DW_AT_declaration)
6220               && !get_AT (c, DW_AT_specification)));
6221 }
6222
6223 static char *
6224 gen_internal_sym (const char *prefix)
6225 {
6226   char buf[256];
6227
6228   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6229   return xstrdup (buf);
6230 }
6231
6232 /* Assign symbols to all worthy DIEs under DIE.  */
6233
6234 static void
6235 assign_symbol_names (dw_die_ref die)
6236 {
6237   dw_die_ref c;
6238
6239   if (is_symbol_die (die))
6240     {
6241       if (comdat_symbol_id)
6242         {
6243           char *p = alloca (strlen (comdat_symbol_id) + 64);
6244
6245           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6246                    comdat_symbol_id, comdat_symbol_number++);
6247           die->die_symbol = xstrdup (p);
6248         }
6249       else
6250         die->die_symbol = gen_internal_sym ("LDIE");
6251     }
6252
6253   for (c = die->die_child; c != NULL; c = c->die_sib)
6254     assign_symbol_names (c);
6255 }
6256
6257 struct cu_hash_table_entry
6258 {
6259   dw_die_ref cu;
6260   unsigned min_comdat_num, max_comdat_num;
6261   struct cu_hash_table_entry *next;
6262 };
6263
6264 /* Routines to manipulate hash table of CUs.  */
6265 static hashval_t
6266 htab_cu_hash (const void *of)
6267 {
6268   const struct cu_hash_table_entry *entry = of;
6269
6270   return htab_hash_string (entry->cu->die_symbol);
6271 }
6272
6273 static int
6274 htab_cu_eq (const void *of1, const void *of2)
6275 {
6276   const struct cu_hash_table_entry *entry1 = of1;
6277   const struct die_struct *entry2 = of2;
6278
6279   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6280 }
6281
6282 static void
6283 htab_cu_del (void *what)
6284 {
6285   struct cu_hash_table_entry *next, *entry = what;
6286
6287   while (entry)
6288     {
6289       next = entry->next;
6290       free (entry);
6291       entry = next;
6292     }
6293 }
6294
6295 /* Check whether we have already seen this CU and set up SYM_NUM
6296    accordingly.  */
6297 static int
6298 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6299 {
6300   struct cu_hash_table_entry dummy;
6301   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6302
6303   dummy.max_comdat_num = 0;
6304
6305   slot = (struct cu_hash_table_entry **)
6306     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6307         INSERT);
6308   entry = *slot;
6309
6310   for (; entry; last = entry, entry = entry->next)
6311     {
6312       if (same_die_p_wrap (cu, entry->cu))
6313         break;
6314     }
6315
6316   if (entry)
6317     {
6318       *sym_num = entry->min_comdat_num;
6319       return 1;
6320     }
6321
6322   entry = XCNEW (struct cu_hash_table_entry);
6323   entry->cu = cu;
6324   entry->min_comdat_num = *sym_num = last->max_comdat_num;
6325   entry->next = *slot;
6326   *slot = entry;
6327
6328   return 0;
6329 }
6330
6331 /* Record SYM_NUM to record of CU in HTABLE.  */
6332 static void
6333 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6334 {
6335   struct cu_hash_table_entry **slot, *entry;
6336
6337   slot = (struct cu_hash_table_entry **)
6338     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6339         NO_INSERT);
6340   entry = *slot;
6341
6342   entry->max_comdat_num = sym_num;
6343 }
6344
6345 /* Traverse the DIE (which is always comp_unit_die), and set up
6346    additional compilation units for each of the include files we see
6347    bracketed by BINCL/EINCL.  */
6348
6349 static void
6350 break_out_includes (dw_die_ref die)
6351 {
6352   dw_die_ref *ptr;
6353   dw_die_ref unit = NULL;
6354   limbo_die_node *node, **pnode;
6355   htab_t cu_hash_table;
6356
6357   for (ptr = &(die->die_child); *ptr;)
6358     {
6359       dw_die_ref c = *ptr;
6360
6361       if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6362           || (unit && is_comdat_die (c)))
6363         {
6364           /* This DIE is for a secondary CU; remove it from the main one.  */
6365           *ptr = c->die_sib;
6366
6367           if (c->die_tag == DW_TAG_GNU_BINCL)
6368             {
6369               unit = push_new_compile_unit (unit, c);
6370               free_die (c);
6371             }
6372           else if (c->die_tag == DW_TAG_GNU_EINCL)
6373             {
6374               unit = pop_compile_unit (unit);
6375               free_die (c);
6376             }
6377           else
6378             add_child_die (unit, c);
6379         }
6380       else
6381         {
6382           /* Leave this DIE in the main CU.  */
6383           ptr = &(c->die_sib);
6384           continue;
6385         }
6386     }
6387
6388 #if 0
6389   /* We can only use this in debugging, since the frontend doesn't check
6390      to make sure that we leave every include file we enter.  */
6391   gcc_assert (!unit);
6392 #endif
6393
6394   assign_symbol_names (die);
6395   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6396   for (node = limbo_die_list, pnode = &limbo_die_list;
6397        node;
6398        node = node->next)
6399     {
6400       int is_dupl;
6401
6402       compute_section_prefix (node->die);
6403       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6404                         &comdat_symbol_number);
6405       assign_symbol_names (node->die);
6406       if (is_dupl)
6407         *pnode = node->next;
6408       else
6409         {
6410           pnode = &node->next;
6411           record_comdat_symbol_number (node->die, cu_hash_table,
6412                 comdat_symbol_number);
6413         }
6414     }
6415   htab_delete (cu_hash_table);
6416 }
6417
6418 /* Traverse the DIE and add a sibling attribute if it may have the
6419    effect of speeding up access to siblings.  To save some space,
6420    avoid generating sibling attributes for DIE's without children.  */
6421
6422 static void
6423 add_sibling_attributes (dw_die_ref die)
6424 {
6425   dw_die_ref c;
6426
6427   if (die->die_tag != DW_TAG_compile_unit
6428       && die->die_sib && die->die_child != NULL)
6429     /* Add the sibling link to the front of the attribute list.  */
6430     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6431
6432   for (c = die->die_child; c != NULL; c = c->die_sib)
6433     add_sibling_attributes (c);
6434 }
6435
6436 /* Output all location lists for the DIE and its children.  */
6437
6438 static void
6439 output_location_lists (dw_die_ref die)
6440 {
6441   dw_die_ref c;
6442   dw_attr_ref d_attr;
6443
6444   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6445     if (AT_class (d_attr) == dw_val_class_loc_list)
6446       output_loc_list (AT_loc_list (d_attr));
6447
6448   for (c = die->die_child; c != NULL; c = c->die_sib)
6449     output_location_lists (c);
6450
6451 }
6452
6453 /* The format of each DIE (and its attribute value pairs) is encoded in an
6454    abbreviation table.  This routine builds the abbreviation table and assigns
6455    a unique abbreviation id for each abbreviation entry.  The children of each
6456    die are visited recursively.  */
6457
6458 static void
6459 build_abbrev_table (dw_die_ref die)
6460 {
6461   unsigned long abbrev_id;
6462   unsigned int n_alloc;
6463   dw_die_ref c;
6464   dw_attr_ref d_attr, a_attr;
6465
6466   /* Scan the DIE references, and mark as external any that refer to
6467      DIEs from other CUs (i.e. those which are not marked).  */
6468   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6469     if (AT_class (d_attr) == dw_val_class_die_ref
6470         && AT_ref (d_attr)->die_mark == 0)
6471       {
6472         gcc_assert (AT_ref (d_attr)->die_symbol);
6473
6474         set_AT_ref_external (d_attr, 1);
6475       }
6476
6477   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6478     {
6479       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6480
6481       if (abbrev->die_tag == die->die_tag)
6482         {
6483           if ((abbrev->die_child != NULL) == (die->die_child != NULL))
6484             {
6485               a_attr = abbrev->die_attr;
6486               d_attr = die->die_attr;
6487
6488               while (a_attr != NULL && d_attr != NULL)
6489                 {
6490                   if ((a_attr->dw_attr != d_attr->dw_attr)
6491                       || (value_format (a_attr) != value_format (d_attr)))
6492                     break;
6493
6494                   a_attr = a_attr->dw_attr_next;
6495                   d_attr = d_attr->dw_attr_next;
6496                 }
6497
6498               if (a_attr == NULL && d_attr == NULL)
6499                 break;
6500             }
6501         }
6502     }
6503
6504   if (abbrev_id >= abbrev_die_table_in_use)
6505     {
6506       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6507         {
6508           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6509           abbrev_die_table = ggc_realloc (abbrev_die_table,
6510                                           sizeof (dw_die_ref) * n_alloc);
6511
6512           memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6513                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6514           abbrev_die_table_allocated = n_alloc;
6515         }
6516
6517       ++abbrev_die_table_in_use;
6518       abbrev_die_table[abbrev_id] = die;
6519     }
6520
6521   die->die_abbrev = abbrev_id;
6522   for (c = die->die_child; c != NULL; c = c->die_sib)
6523     build_abbrev_table (c);
6524 }
6525 \f
6526 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6527
6528 static int
6529 constant_size (long unsigned int value)
6530 {
6531   int log;
6532
6533   if (value == 0)
6534     log = 0;
6535   else
6536     log = floor_log2 (value);
6537
6538   log = log / 8;
6539   log = 1 << (floor_log2 (log) + 1);
6540
6541   return log;
6542 }
6543
6544 /* Return the size of a DIE as it is represented in the
6545    .debug_info section.  */
6546
6547 static unsigned long
6548 size_of_die (dw_die_ref die)
6549 {
6550   unsigned long size = 0;
6551   dw_attr_ref a;
6552
6553   size += size_of_uleb128 (die->die_abbrev);
6554   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6555     {
6556       switch (AT_class (a))
6557         {
6558         case dw_val_class_addr:
6559           size += DWARF2_ADDR_SIZE;
6560           break;
6561         case dw_val_class_offset:
6562           size += DWARF_OFFSET_SIZE;
6563           break;
6564         case dw_val_class_loc:
6565           {
6566             unsigned long lsize = size_of_locs (AT_loc (a));
6567
6568             /* Block length.  */
6569             size += constant_size (lsize);
6570             size += lsize;
6571           }
6572           break;
6573         case dw_val_class_loc_list:
6574           size += DWARF_OFFSET_SIZE;
6575           break;
6576         case dw_val_class_range_list:
6577           size += DWARF_OFFSET_SIZE;
6578           break;
6579         case dw_val_class_const:
6580           size += size_of_sleb128 (AT_int (a));
6581           break;
6582         case dw_val_class_unsigned_const:
6583           size += constant_size (AT_unsigned (a));
6584           break;
6585         case dw_val_class_long_long:
6586           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6587           break;
6588         case dw_val_class_vec:
6589           size += 1 + (a->dw_attr_val.v.val_vec.length
6590                        * a->dw_attr_val.v.val_vec.elt_size); /* block */
6591           break;
6592         case dw_val_class_flag:
6593           size += 1;
6594           break;
6595         case dw_val_class_die_ref:
6596           if (AT_ref_external (a))
6597             size += DWARF2_ADDR_SIZE;
6598           else
6599             size += DWARF_OFFSET_SIZE;
6600           break;
6601         case dw_val_class_fde_ref:
6602           size += DWARF_OFFSET_SIZE;
6603           break;
6604         case dw_val_class_lbl_id:
6605           size += DWARF2_ADDR_SIZE;
6606           break;
6607         case dw_val_class_lbl_offset:
6608           size += DWARF_OFFSET_SIZE;
6609           break;
6610         case dw_val_class_str:
6611           if (AT_string_form (a) == DW_FORM_strp)
6612             size += DWARF_OFFSET_SIZE;
6613           else
6614             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6615           break;
6616         default:
6617           gcc_unreachable ();
6618         }
6619     }
6620
6621   return size;
6622 }
6623
6624 /* Size the debugging information associated with a given DIE.  Visits the
6625    DIE's children recursively.  Updates the global variable next_die_offset, on
6626    each time through.  Uses the current value of next_die_offset to update the
6627    die_offset field in each DIE.  */
6628
6629 static void
6630 calc_die_sizes (dw_die_ref die)
6631 {
6632   dw_die_ref c;
6633
6634   die->die_offset = next_die_offset;
6635   next_die_offset += size_of_die (die);
6636
6637   for (c = die->die_child; c != NULL; c = c->die_sib)
6638     calc_die_sizes (c);
6639
6640   if (die->die_child != NULL)
6641     /* Count the null byte used to terminate sibling lists.  */
6642     next_die_offset += 1;
6643 }
6644
6645 /* Set the marks for a die and its children.  We do this so
6646    that we know whether or not a reference needs to use FORM_ref_addr; only
6647    DIEs in the same CU will be marked.  We used to clear out the offset
6648    and use that as the flag, but ran into ordering problems.  */
6649
6650 static void
6651 mark_dies (dw_die_ref die)
6652 {
6653   dw_die_ref c;
6654
6655   gcc_assert (!die->die_mark);
6656
6657   die->die_mark = 1;
6658   for (c = die->die_child; c; c = c->die_sib)
6659     mark_dies (c);
6660 }
6661
6662 /* Clear the marks for a die and its children.  */
6663
6664 static void
6665 unmark_dies (dw_die_ref die)
6666 {
6667   dw_die_ref c;
6668
6669   gcc_assert (die->die_mark);
6670
6671   die->die_mark = 0;
6672   for (c = die->die_child; c; c = c->die_sib)
6673     unmark_dies (c);
6674 }
6675
6676 /* Clear the marks for a die, its children and referred dies.  */
6677
6678 static void
6679 unmark_all_dies (dw_die_ref die)
6680 {
6681   dw_die_ref c;
6682   dw_attr_ref a;
6683
6684   if (!die->die_mark)
6685     return;
6686   die->die_mark = 0;
6687
6688   for (c = die->die_child; c; c = c->die_sib)
6689     unmark_all_dies (c);
6690
6691   for (a = die->die_attr; a; a = a->dw_attr_next)
6692     if (AT_class (a) == dw_val_class_die_ref)
6693       unmark_all_dies (AT_ref (a));
6694 }
6695
6696 /* Return the size of the .debug_pubnames table  generated for the
6697    compilation unit.  */
6698
6699 static unsigned long
6700 size_of_pubnames (void)
6701 {
6702   unsigned long size;
6703   unsigned i;
6704
6705   size = DWARF_PUBNAMES_HEADER_SIZE;
6706   for (i = 0; i < pubname_table_in_use; i++)
6707     {
6708       pubname_ref p = &pubname_table[i];
6709       size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6710     }
6711
6712   size += DWARF_OFFSET_SIZE;
6713   return size;
6714 }
6715
6716 /* Return the size of the information in the .debug_aranges section.  */
6717
6718 static unsigned long
6719 size_of_aranges (void)
6720 {
6721   unsigned long size;
6722
6723   size = DWARF_ARANGES_HEADER_SIZE;
6724
6725   /* Count the address/length pair for this compilation unit.  */
6726   size += 2 * DWARF2_ADDR_SIZE;
6727   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6728
6729   /* Count the two zero words used to terminated the address range table.  */
6730   size += 2 * DWARF2_ADDR_SIZE;
6731   return size;
6732 }
6733 \f
6734 /* Select the encoding of an attribute value.  */
6735
6736 static enum dwarf_form
6737 value_format (dw_attr_ref a)
6738 {
6739   switch (a->dw_attr_val.val_class)
6740     {
6741     case dw_val_class_addr:
6742       return DW_FORM_addr;
6743     case dw_val_class_range_list:
6744     case dw_val_class_offset:
6745       switch (DWARF_OFFSET_SIZE)
6746         {
6747         case 4:
6748           return DW_FORM_data4;
6749         case 8:
6750           return DW_FORM_data8;
6751         default:
6752           gcc_unreachable ();
6753         }
6754     case dw_val_class_loc_list:
6755       /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6756          .debug_loc section */
6757       return DW_FORM_data4;
6758     case dw_val_class_loc:
6759       switch (constant_size (size_of_locs (AT_loc (a))))
6760         {
6761         case 1:
6762           return DW_FORM_block1;
6763         case 2:
6764           return DW_FORM_block2;
6765         default:
6766           gcc_unreachable ();
6767         }
6768     case dw_val_class_const:
6769       return DW_FORM_sdata;
6770     case dw_val_class_unsigned_const:
6771       switch (constant_size (AT_unsigned (a)))
6772         {
6773         case 1:
6774           return DW_FORM_data1;
6775         case 2:
6776           return DW_FORM_data2;
6777         case 4:
6778           return DW_FORM_data4;
6779         case 8:
6780           return DW_FORM_data8;
6781         default:
6782           gcc_unreachable ();
6783         }
6784     case dw_val_class_long_long:
6785       return DW_FORM_block1;
6786     case dw_val_class_vec:
6787       return DW_FORM_block1;
6788     case dw_val_class_flag:
6789       return DW_FORM_flag;
6790     case dw_val_class_die_ref:
6791       if (AT_ref_external (a))
6792         return DW_FORM_ref_addr;
6793       else
6794         return DW_FORM_ref;
6795     case dw_val_class_fde_ref:
6796       return DW_FORM_data;
6797     case dw_val_class_lbl_id:
6798       return DW_FORM_addr;
6799     case dw_val_class_lbl_offset:
6800       return DW_FORM_data;
6801     case dw_val_class_str:
6802       return AT_string_form (a);
6803
6804     default:
6805       gcc_unreachable ();
6806     }
6807 }
6808
6809 /* Output the encoding of an attribute value.  */
6810
6811 static void
6812 output_value_format (dw_attr_ref a)
6813 {
6814   enum dwarf_form form = value_format (a);
6815
6816   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6817 }
6818
6819 /* Output the .debug_abbrev section which defines the DIE abbreviation
6820    table.  */
6821
6822 static void
6823 output_abbrev_section (void)
6824 {
6825   unsigned long abbrev_id;
6826
6827   dw_attr_ref a_attr;
6828
6829   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6830     {
6831       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6832
6833       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6834       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6835                                    dwarf_tag_name (abbrev->die_tag));
6836
6837       if (abbrev->die_child != NULL)
6838         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6839       else
6840         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6841
6842       for (a_attr = abbrev->die_attr; a_attr != NULL;
6843            a_attr = a_attr->dw_attr_next)
6844         {
6845           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6846                                        dwarf_attr_name (a_attr->dw_attr));
6847           output_value_format (a_attr);
6848         }
6849
6850       dw2_asm_output_data (1, 0, NULL);
6851       dw2_asm_output_data (1, 0, NULL);
6852     }
6853
6854   /* Terminate the table.  */
6855   dw2_asm_output_data (1, 0, NULL);
6856 }
6857
6858 /* Output a symbol we can use to refer to this DIE from another CU.  */
6859
6860 static inline void
6861 output_die_symbol (dw_die_ref die)
6862 {
6863   char *sym = die->die_symbol;
6864
6865   if (sym == 0)
6866     return;
6867
6868   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6869     /* We make these global, not weak; if the target doesn't support
6870        .linkonce, it doesn't support combining the sections, so debugging
6871        will break.  */
6872     targetm.asm_out.globalize_label (asm_out_file, sym);
6873
6874   ASM_OUTPUT_LABEL (asm_out_file, sym);
6875 }
6876
6877 /* Return a new location list, given the begin and end range, and the
6878    expression. gensym tells us whether to generate a new internal symbol for
6879    this location list node, which is done for the head of the list only.  */
6880
6881 static inline dw_loc_list_ref
6882 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6883               const char *section, unsigned int gensym)
6884 {
6885   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6886
6887   retlist->begin = begin;
6888   retlist->end = end;
6889   retlist->expr = expr;
6890   retlist->section = section;
6891   if (gensym)
6892     retlist->ll_symbol = gen_internal_sym ("LLST");
6893
6894   return retlist;
6895 }
6896
6897 /* Add a location description expression to a location list.  */
6898
6899 static inline void
6900 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6901                            const char *begin, const char *end,
6902                            const char *section)
6903 {
6904   dw_loc_list_ref *d;
6905
6906   /* Find the end of the chain.  */
6907   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6908     ;
6909
6910   /* Add a new location list node to the list.  */
6911   *d = new_loc_list (descr, begin, end, section, 0);
6912 }
6913
6914 static void
6915 dwarf2out_switch_text_section (void)
6916 {
6917   dw_fde_ref fde;
6918
6919   gcc_assert (cfun);
6920
6921   fde = &fde_table[fde_table_in_use - 1];
6922   fde->dw_fde_switched_sections = true;
6923   fde->dw_fde_hot_section_label = cfun->hot_section_label;
6924   fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
6925   fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
6926   fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
6927   have_multiple_function_sections = true;
6928 }
6929
6930 /* Output the location list given to us.  */
6931
6932 static void
6933 output_loc_list (dw_loc_list_ref list_head)
6934 {
6935   dw_loc_list_ref curr = list_head;
6936
6937   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
6938
6939   /* Walk the location list, and output each range + expression.  */
6940   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
6941     {
6942       unsigned long size;
6943       if (!have_multiple_function_sections)
6944         {
6945           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
6946                                 "Location list begin address (%s)",
6947                                 list_head->ll_symbol);
6948           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
6949                                 "Location list end address (%s)",
6950                                 list_head->ll_symbol);
6951         }
6952       else
6953         {
6954           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
6955                                "Location list begin address (%s)",
6956                                list_head->ll_symbol);
6957           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
6958                                "Location list end address (%s)",
6959                                list_head->ll_symbol);
6960         }
6961       size = size_of_locs (curr->expr);
6962
6963       /* Output the block length for this list of location operations.  */
6964       gcc_assert (size <= 0xffff);
6965       dw2_asm_output_data (2, size, "%s", "Location expression size");
6966
6967       output_loc_sequence (curr->expr);
6968     }
6969
6970   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
6971                        "Location list terminator begin (%s)",
6972                        list_head->ll_symbol);
6973   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
6974                        "Location list terminator end (%s)",
6975                        list_head->ll_symbol);
6976 }
6977
6978 /* Output the DIE and its attributes.  Called recursively to generate
6979    the definitions of each child DIE.  */
6980
6981 static void
6982 output_die (dw_die_ref die)
6983 {
6984   dw_attr_ref a;
6985   dw_die_ref c;
6986   unsigned long size;
6987
6988   /* If someone in another CU might refer to us, set up a symbol for
6989      them to point to.  */
6990   if (die->die_symbol)
6991     output_die_symbol (die);
6992
6993   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
6994                                die->die_offset, dwarf_tag_name (die->die_tag));
6995
6996   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6997     {
6998       const char *name = dwarf_attr_name (a->dw_attr);
6999
7000       switch (AT_class (a))
7001         {
7002         case dw_val_class_addr:
7003           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7004           break;
7005
7006         case dw_val_class_offset:
7007           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7008                                "%s", name);
7009           break;
7010
7011         case dw_val_class_range_list:
7012           {
7013             char *p = strchr (ranges_section_label, '\0');
7014
7015             sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7016                      a->dw_attr_val.v.val_offset);
7017             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7018                                    "%s", name);
7019             *p = '\0';
7020           }
7021           break;
7022
7023         case dw_val_class_loc:
7024           size = size_of_locs (AT_loc (a));
7025
7026           /* Output the block length for this list of location operations.  */
7027           dw2_asm_output_data (constant_size (size), size, "%s", name);
7028
7029           output_loc_sequence (AT_loc (a));
7030           break;
7031
7032         case dw_val_class_const:
7033           /* ??? It would be slightly more efficient to use a scheme like is
7034              used for unsigned constants below, but gdb 4.x does not sign
7035              extend.  Gdb 5.x does sign extend.  */
7036           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7037           break;
7038
7039         case dw_val_class_unsigned_const:
7040           dw2_asm_output_data (constant_size (AT_unsigned (a)),
7041                                AT_unsigned (a), "%s", name);
7042           break;
7043
7044         case dw_val_class_long_long:
7045           {
7046             unsigned HOST_WIDE_INT first, second;
7047
7048             dw2_asm_output_data (1,
7049                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7050                                  "%s", name);
7051
7052             if (WORDS_BIG_ENDIAN)
7053               {
7054                 first = a->dw_attr_val.v.val_long_long.hi;
7055                 second = a->dw_attr_val.v.val_long_long.low;
7056               }
7057             else
7058               {
7059                 first = a->dw_attr_val.v.val_long_long.low;
7060                 second = a->dw_attr_val.v.val_long_long.hi;
7061               }
7062
7063             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7064                                  first, "long long constant");
7065             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7066                                  second, NULL);
7067           }
7068           break;
7069
7070         case dw_val_class_vec:
7071           {
7072             unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7073             unsigned int len = a->dw_attr_val.v.val_vec.length;
7074             unsigned int i;
7075             unsigned char *p;
7076
7077             dw2_asm_output_data (1, len * elt_size, "%s", name);
7078             if (elt_size > sizeof (HOST_WIDE_INT))
7079               {
7080                 elt_size /= 2;
7081                 len *= 2;
7082               }
7083             for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7084                  i < len;
7085                  i++, p += elt_size)
7086               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7087                                    "fp or vector constant word %u", i);
7088             break;
7089           }
7090
7091         case dw_val_class_flag:
7092           dw2_asm_output_data (1, AT_flag (a), "%s", name);
7093           break;
7094
7095         case dw_val_class_loc_list:
7096           {
7097             char *sym = AT_loc_list (a)->ll_symbol;
7098
7099             gcc_assert (sym);
7100             dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, "%s", name);
7101           }
7102           break;
7103
7104         case dw_val_class_die_ref:
7105           if (AT_ref_external (a))
7106             {
7107               char *sym = AT_ref (a)->die_symbol;
7108
7109               gcc_assert (sym);
7110               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
7111             }
7112           else
7113             {
7114               gcc_assert (AT_ref (a)->die_offset);
7115               dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7116                                    "%s", name);
7117             }
7118           break;
7119
7120         case dw_val_class_fde_ref:
7121           {
7122             char l1[20];
7123
7124             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7125                                          a->dw_attr_val.v.val_fde_index * 2);
7126             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name);
7127           }
7128           break;
7129
7130         case dw_val_class_lbl_id:
7131           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7132           break;
7133
7134         case dw_val_class_lbl_offset:
7135           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name);
7136           break;
7137
7138         case dw_val_class_str:
7139           if (AT_string_form (a) == DW_FORM_strp)
7140             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7141                                    a->dw_attr_val.v.val_str->label,
7142                                    "%s: \"%s\"", name, AT_string (a));
7143           else
7144             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7145           break;
7146
7147         default:
7148           gcc_unreachable ();
7149         }
7150     }
7151
7152   for (c = die->die_child; c != NULL; c = c->die_sib)
7153     output_die (c);
7154
7155   /* Add null byte to terminate sibling list.  */
7156   if (die->die_child != NULL)
7157     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7158                          die->die_offset);
7159 }
7160
7161 /* Output the compilation unit that appears at the beginning of the
7162    .debug_info section, and precedes the DIE descriptions.  */
7163
7164 static void
7165 output_compilation_unit_header (void)
7166 {
7167   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7168     dw2_asm_output_data (4, 0xffffffff,
7169       "Initial length escape value indicating 64-bit DWARF extension");
7170   dw2_asm_output_data (DWARF_OFFSET_SIZE,
7171                        next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7172                        "Length of Compilation Unit Info");
7173   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7174   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7175                          "Offset Into Abbrev. Section");
7176   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7177 }
7178
7179 /* Output the compilation unit DIE and its children.  */
7180
7181 static void
7182 output_comp_unit (dw_die_ref die, int output_if_empty)
7183 {
7184   const char *secname;
7185   char *oldsym, *tmp;
7186
7187   /* Unless we are outputting main CU, we may throw away empty ones.  */
7188   if (!output_if_empty && die->die_child == NULL)
7189     return;
7190
7191   /* Even if there are no children of this DIE, we must output the information
7192      about the compilation unit.  Otherwise, on an empty translation unit, we
7193      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
7194      will then complain when examining the file.  First mark all the DIEs in
7195      this CU so we know which get local refs.  */
7196   mark_dies (die);
7197
7198   build_abbrev_table (die);
7199
7200   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
7201   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7202   calc_die_sizes (die);
7203
7204   oldsym = die->die_symbol;
7205   if (oldsym)
7206     {
7207       tmp = alloca (strlen (oldsym) + 24);
7208
7209       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7210       secname = tmp;
7211       die->die_symbol = NULL;
7212       switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7213     }
7214   else
7215     switch_to_section (debug_info_section);
7216
7217   /* Output debugging information.  */
7218   output_compilation_unit_header ();
7219   output_die (die);
7220
7221   /* Leave the marks on the main CU, so we can check them in
7222      output_pubnames.  */
7223   if (oldsym)
7224     {
7225       unmark_dies (die);
7226       die->die_symbol = oldsym;
7227     }
7228 }
7229
7230 /* The DWARF2 pubname for a nested thingy looks like "A::f".  The
7231    output of lang_hooks.decl_printable_name for C++ looks like
7232    "A::f(int)".  Let's drop the argument list, and maybe the scope.  */
7233
7234 static const char *
7235 dwarf2_name (tree decl, int scope)
7236 {
7237   return lang_hooks.decl_printable_name (decl, scope ? 1 : 0);
7238 }
7239
7240 /* Add a new entry to .debug_pubnames if appropriate.  */
7241
7242 static void
7243 add_pubname (tree decl, dw_die_ref die)
7244 {
7245   pubname_ref p;
7246
7247   if (! TREE_PUBLIC (decl))
7248     return;
7249
7250   if (pubname_table_in_use == pubname_table_allocated)
7251     {
7252       pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
7253       pubname_table
7254         = ggc_realloc (pubname_table,
7255                        (pubname_table_allocated * sizeof (pubname_entry)));
7256       memset (pubname_table + pubname_table_in_use, 0,
7257               PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7258     }
7259
7260   p = &pubname_table[pubname_table_in_use++];
7261   p->die = die;
7262   p->name = xstrdup (dwarf2_name (decl, 1));
7263 }
7264
7265 /* Output the public names table used to speed up access to externally
7266    visible names.  For now, only generate entries for externally
7267    visible procedures.  */
7268
7269 static void
7270 output_pubnames (void)
7271 {
7272   unsigned i;
7273   unsigned long pubnames_length = size_of_pubnames ();
7274
7275   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7276     dw2_asm_output_data (4, 0xffffffff,
7277       "Initial length escape value indicating 64-bit DWARF extension");
7278   dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7279                        "Length of Public Names Info");
7280   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7281   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7282                          "Offset of Compilation Unit Info");
7283   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7284                        "Compilation Unit Length");
7285
7286   for (i = 0; i < pubname_table_in_use; i++)
7287     {
7288       pubname_ref pub = &pubname_table[i];
7289
7290       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
7291       gcc_assert (pub->die->die_mark);
7292
7293       dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7294                            "DIE offset");
7295
7296       dw2_asm_output_nstring (pub->name, -1, "external name");
7297     }
7298
7299   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7300 }
7301
7302 /* Add a new entry to .debug_aranges if appropriate.  */
7303
7304 static void
7305 add_arange (tree decl, dw_die_ref die)
7306 {
7307   if (! DECL_SECTION_NAME (decl))
7308     return;
7309
7310   if (arange_table_in_use == arange_table_allocated)
7311     {
7312       arange_table_allocated += ARANGE_TABLE_INCREMENT;
7313       arange_table = ggc_realloc (arange_table,
7314                                   (arange_table_allocated
7315                                    * sizeof (dw_die_ref)));
7316       memset (arange_table + arange_table_in_use, 0,
7317               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7318     }
7319
7320   arange_table[arange_table_in_use++] = die;
7321 }
7322
7323 /* Output the information that goes into the .debug_aranges table.
7324    Namely, define the beginning and ending address range of the
7325    text section generated for this compilation unit.  */
7326
7327 static void
7328 output_aranges (void)
7329 {
7330   unsigned i;
7331   unsigned long aranges_length = size_of_aranges ();
7332
7333   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7334     dw2_asm_output_data (4, 0xffffffff,
7335       "Initial length escape value indicating 64-bit DWARF extension");
7336   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7337                        "Length of Address Ranges Info");
7338   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7339   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7340                          "Offset of Compilation Unit Info");
7341   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7342   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7343
7344   /* We need to align to twice the pointer size here.  */
7345   if (DWARF_ARANGES_PAD_SIZE)
7346     {
7347       /* Pad using a 2 byte words so that padding is correct for any
7348          pointer size.  */
7349       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7350                            2 * DWARF2_ADDR_SIZE);
7351       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7352         dw2_asm_output_data (2, 0, NULL);
7353     }
7354
7355   dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7356   dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7357                         text_section_label, "Length");
7358   if (flag_reorder_blocks_and_partition)
7359     {
7360       dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7361                            "Address");
7362       dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7363                             cold_text_section_label, "Length");
7364     }
7365
7366   for (i = 0; i < arange_table_in_use; i++)
7367     {
7368       dw_die_ref die = arange_table[i];
7369
7370       /* We shouldn't see aranges for DIEs outside of the main CU.  */
7371       gcc_assert (die->die_mark);
7372
7373       if (die->die_tag == DW_TAG_subprogram)
7374         {
7375           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7376                                "Address");
7377           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7378                                 get_AT_low_pc (die), "Length");
7379         }
7380       else
7381         {
7382           /* A static variable; extract the symbol from DW_AT_location.
7383              Note that this code isn't currently hit, as we only emit
7384              aranges for functions (jason 9/23/99).  */
7385           dw_attr_ref a = get_AT (die, DW_AT_location);
7386           dw_loc_descr_ref loc;
7387
7388           gcc_assert (a && AT_class (a) == dw_val_class_loc);
7389
7390           loc = AT_loc (a);
7391           gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7392
7393           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7394                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
7395           dw2_asm_output_data (DWARF2_ADDR_SIZE,
7396                                get_AT_unsigned (die, DW_AT_byte_size),
7397                                "Length");
7398         }
7399     }
7400
7401   /* Output the terminator words.  */
7402   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7403   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7404 }
7405
7406 /* Add a new entry to .debug_ranges.  Return the offset at which it
7407    was placed.  */
7408
7409 static unsigned int
7410 add_ranges (tree block)
7411 {
7412   unsigned int in_use = ranges_table_in_use;
7413
7414   if (in_use == ranges_table_allocated)
7415     {
7416       ranges_table_allocated += RANGES_TABLE_INCREMENT;
7417       ranges_table
7418         = ggc_realloc (ranges_table, (ranges_table_allocated
7419                                       * sizeof (struct dw_ranges_struct)));
7420       memset (ranges_table + ranges_table_in_use, 0,
7421               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7422     }
7423
7424   ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7425   ranges_table_in_use = in_use + 1;
7426
7427   return in_use * 2 * DWARF2_ADDR_SIZE;
7428 }
7429
7430 static void
7431 output_ranges (void)
7432 {
7433   unsigned i;
7434   static const char *const start_fmt = "Offset 0x%x";
7435   const char *fmt = start_fmt;
7436
7437   for (i = 0; i < ranges_table_in_use; i++)
7438     {
7439       int block_num = ranges_table[i].block_num;
7440
7441       if (block_num)
7442         {
7443           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7444           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7445
7446           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7447           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7448
7449           /* If all code is in the text section, then the compilation
7450              unit base address defaults to DW_AT_low_pc, which is the
7451              base of the text section.  */
7452           if (!have_multiple_function_sections)
7453             {
7454               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7455                                     text_section_label,
7456                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7457               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7458                                     text_section_label, NULL);
7459             }
7460
7461           /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7462              compilation unit base address to zero, which allows us to
7463              use absolute addresses, and not worry about whether the
7464              target supports cross-section arithmetic.  */
7465           else
7466             {
7467               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7468                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7469               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7470             }
7471
7472           fmt = NULL;
7473         }
7474       else
7475         {
7476           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7477           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7478           fmt = start_fmt;
7479         }
7480     }
7481 }
7482
7483 /* Data structure containing information about input files.  */
7484 struct file_info
7485 {
7486   char *path;           /* Complete file name.  */
7487   char *fname;          /* File name part.  */
7488   int length;           /* Length of entire string.  */
7489   int file_idx;         /* Index in input file table.  */
7490   int dir_idx;          /* Index in directory table.  */
7491 };
7492
7493 /* Data structure containing information about directories with source
7494    files.  */
7495 struct dir_info
7496 {
7497   char *path;           /* Path including directory name.  */
7498   int length;           /* Path length.  */
7499   int prefix;           /* Index of directory entry which is a prefix.  */
7500   int count;            /* Number of files in this directory.  */
7501   int dir_idx;          /* Index of directory used as base.  */
7502   int used;             /* Used in the end?  */
7503 };
7504
7505 /* Callback function for file_info comparison.  We sort by looking at
7506    the directories in the path.  */
7507
7508 static int
7509 file_info_cmp (const void *p1, const void *p2)
7510 {
7511   const struct file_info *s1 = p1;
7512   const struct file_info *s2 = p2;
7513   unsigned char *cp1;
7514   unsigned char *cp2;
7515
7516   /* Take care of file names without directories.  We need to make sure that
7517      we return consistent values to qsort since some will get confused if
7518      we return the same value when identical operands are passed in opposite
7519      orders.  So if neither has a directory, return 0 and otherwise return
7520      1 or -1 depending on which one has the directory.  */
7521   if ((s1->path == s1->fname || s2->path == s2->fname))
7522     return (s2->path == s2->fname) - (s1->path == s1->fname);
7523
7524   cp1 = (unsigned char *) s1->path;
7525   cp2 = (unsigned char *) s2->path;
7526
7527   while (1)
7528     {
7529       ++cp1;
7530       ++cp2;
7531       /* Reached the end of the first path?  If so, handle like above.  */
7532       if ((cp1 == (unsigned char *) s1->fname)
7533           || (cp2 == (unsigned char *) s2->fname))
7534         return ((cp2 == (unsigned char *) s2->fname)
7535                 - (cp1 == (unsigned char *) s1->fname));
7536
7537       /* Character of current path component the same?  */
7538       else if (*cp1 != *cp2)
7539         return *cp1 - *cp2;
7540     }
7541 }
7542
7543 /* Output the directory table and the file name table.  We try to minimize
7544    the total amount of memory needed.  A heuristic is used to avoid large
7545    slowdowns with many input files.  */
7546
7547 static void
7548 output_file_names (void)
7549 {
7550   struct file_info *files;
7551   struct dir_info *dirs;
7552   int *saved;
7553   int *savehere;
7554   int *backmap;
7555   size_t ndirs;
7556   int idx_offset;
7557   size_t i;
7558   int idx;
7559
7560   /* Handle the case where file_table is empty.  */
7561   if (VARRAY_ACTIVE_SIZE (file_table) <= 1)
7562     {
7563       dw2_asm_output_data (1, 0, "End directory table");
7564       dw2_asm_output_data (1, 0, "End file name table");
7565       return;
7566     }
7567
7568   /* Allocate the various arrays we need.  */
7569   files = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct file_info));
7570   dirs = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct dir_info));
7571
7572   /* Sort the file names.  */
7573   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7574     {
7575       char *f;
7576
7577       /* Skip all leading "./".  */
7578       f = VARRAY_CHAR_PTR (file_table, i);
7579       while (f[0] == '.' && f[1] == '/')
7580         f += 2;
7581
7582       /* Create a new array entry.  */
7583       files[i].path = f;
7584       files[i].length = strlen (f);
7585       files[i].file_idx = i;
7586
7587       /* Search for the file name part.  */
7588       f = strrchr (f, '/');
7589       files[i].fname = f == NULL ? files[i].path : f + 1;
7590     }
7591
7592   qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1,
7593          sizeof (files[0]), file_info_cmp);
7594
7595   /* Find all the different directories used.  */
7596   dirs[0].path = files[1].path;
7597   dirs[0].length = files[1].fname - files[1].path;
7598   dirs[0].prefix = -1;
7599   dirs[0].count = 1;
7600   dirs[0].dir_idx = 0;
7601   dirs[0].used = 0;
7602   files[1].dir_idx = 0;
7603   ndirs = 1;
7604
7605   for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7606     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7607         && memcmp (dirs[ndirs - 1].path, files[i].path,
7608                    dirs[ndirs - 1].length) == 0)
7609       {
7610         /* Same directory as last entry.  */
7611         files[i].dir_idx = ndirs - 1;
7612         ++dirs[ndirs - 1].count;
7613       }
7614     else
7615       {
7616         size_t j;
7617
7618         /* This is a new directory.  */
7619         dirs[ndirs].path = files[i].path;
7620         dirs[ndirs].length = files[i].fname - files[i].path;
7621         dirs[ndirs].count = 1;
7622         dirs[ndirs].dir_idx = ndirs;
7623         dirs[ndirs].used = 0;
7624         files[i].dir_idx = ndirs;
7625
7626         /* Search for a prefix.  */
7627         dirs[ndirs].prefix = -1;
7628         for (j = 0; j < ndirs; j++)
7629           if (dirs[j].length < dirs[ndirs].length
7630               && dirs[j].length > 1
7631               && (dirs[ndirs].prefix == -1
7632                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7633               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7634             dirs[ndirs].prefix = j;
7635
7636         ++ndirs;
7637       }
7638
7639   /* Now to the actual work.  We have to find a subset of the directories which
7640      allow expressing the file name using references to the directory table
7641      with the least amount of characters.  We do not do an exhaustive search
7642      where we would have to check out every combination of every single
7643      possible prefix.  Instead we use a heuristic which provides nearly optimal
7644      results in most cases and never is much off.  */
7645   saved = alloca (ndirs * sizeof (int));
7646   savehere = alloca (ndirs * sizeof (int));
7647
7648   memset (saved, '\0', ndirs * sizeof (saved[0]));
7649   for (i = 0; i < ndirs; i++)
7650     {
7651       size_t j;
7652       int total;
7653
7654       /* We can always save some space for the current directory.  But this
7655          does not mean it will be enough to justify adding the directory.  */
7656       savehere[i] = dirs[i].length;
7657       total = (savehere[i] - saved[i]) * dirs[i].count;
7658
7659       for (j = i + 1; j < ndirs; j++)
7660         {
7661           savehere[j] = 0;
7662           if (saved[j] < dirs[i].length)
7663             {
7664               /* Determine whether the dirs[i] path is a prefix of the
7665                  dirs[j] path.  */
7666               int k;
7667
7668               k = dirs[j].prefix;
7669               while (k != -1 && k != (int) i)
7670                 k = dirs[k].prefix;
7671
7672               if (k == (int) i)
7673                 {
7674                   /* Yes it is.  We can possibly safe some memory but
7675                      writing the filenames in dirs[j] relative to
7676                      dirs[i].  */
7677                   savehere[j] = dirs[i].length;
7678                   total += (savehere[j] - saved[j]) * dirs[j].count;
7679                 }
7680             }
7681         }
7682
7683       /* Check whether we can safe enough to justify adding the dirs[i]
7684          directory.  */
7685       if (total > dirs[i].length + 1)
7686         {
7687           /* It's worthwhile adding.  */
7688           for (j = i; j < ndirs; j++)
7689             if (savehere[j] > 0)
7690               {
7691                 /* Remember how much we saved for this directory so far.  */
7692                 saved[j] = savehere[j];
7693
7694                 /* Remember the prefix directory.  */
7695                 dirs[j].dir_idx = i;
7696               }
7697         }
7698     }
7699
7700   /* We have to emit them in the order they appear in the file_table array
7701      since the index is used in the debug info generation.  To do this
7702      efficiently we generate a back-mapping of the indices first.  */
7703   backmap = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int));
7704   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7705     {
7706       backmap[files[i].file_idx] = i;
7707
7708       /* Mark this directory as used.  */
7709       dirs[dirs[files[i].dir_idx].dir_idx].used = 1;
7710     }
7711
7712   /* That was it.  We are ready to emit the information.  First emit the
7713      directory name table.  We have to make sure the first actually emitted
7714      directory name has index one; zero is reserved for the current working
7715      directory.  Make sure we do not confuse these indices with the one for the
7716      constructed table (even though most of the time they are identical).  */
7717   idx = 1;
7718   idx_offset = dirs[0].length > 0 ? 1 : 0;
7719   for (i = 1 - idx_offset; i < ndirs; i++)
7720     if (dirs[i].used != 0)
7721       {
7722         dirs[i].used = idx++;
7723         dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7724                                 "Directory Entry: 0x%x", dirs[i].used);
7725       }
7726
7727   dw2_asm_output_data (1, 0, "End directory table");
7728
7729   /* Correct the index for the current working directory entry if it
7730      exists.  */
7731   if (idx_offset == 0)
7732     dirs[0].used = 0;
7733
7734   /* Now write all the file names.  */
7735   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7736     {
7737       int file_idx = backmap[i];
7738       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7739
7740       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7741                               "File Entry: 0x%lx", (unsigned long) i);
7742
7743       /* Include directory index.  */
7744       dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL);
7745
7746       /* Modification time.  */
7747       dw2_asm_output_data_uleb128 (0, NULL);
7748
7749       /* File length in bytes.  */
7750       dw2_asm_output_data_uleb128 (0, NULL);
7751     }
7752
7753   dw2_asm_output_data (1, 0, "End file name table");
7754 }
7755
7756
7757 /* Output the source line number correspondence information.  This
7758    information goes into the .debug_line section.  */
7759
7760 static void
7761 output_line_info (void)
7762 {
7763   char l1[20], l2[20], p1[20], p2[20];
7764   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7765   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7766   unsigned opc;
7767   unsigned n_op_args;
7768   unsigned long lt_index;
7769   unsigned long current_line;
7770   long line_offset;
7771   long line_delta;
7772   unsigned long current_file;
7773   unsigned long function;
7774
7775   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7776   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7777   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7778   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7779
7780   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7781     dw2_asm_output_data (4, 0xffffffff,
7782       "Initial length escape value indicating 64-bit DWARF extension");
7783   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7784                         "Length of Source Line Info");
7785   ASM_OUTPUT_LABEL (asm_out_file, l1);
7786
7787   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7788   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7789   ASM_OUTPUT_LABEL (asm_out_file, p1);
7790
7791   /* Define the architecture-dependent minimum instruction length (in
7792    bytes).  In this implementation of DWARF, this field is used for
7793    information purposes only.  Since GCC generates assembly language,
7794    we have no a priori knowledge of how many instruction bytes are
7795    generated for each source line, and therefore can use only the
7796    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7797    commands.  Accordingly, we fix this as `1', which is "correct
7798    enough" for all architectures, and don't let the target override.  */
7799   dw2_asm_output_data (1, 1,
7800                        "Minimum Instruction Length");
7801
7802   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7803                        "Default is_stmt_start flag");
7804   dw2_asm_output_data (1, DWARF_LINE_BASE,
7805                        "Line Base Value (Special Opcodes)");
7806   dw2_asm_output_data (1, DWARF_LINE_RANGE,
7807                        "Line Range Value (Special Opcodes)");
7808   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7809                        "Special Opcode Base");
7810
7811   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7812     {
7813       switch (opc)
7814         {
7815         case DW_LNS_advance_pc:
7816         case DW_LNS_advance_line:
7817         case DW_LNS_set_file:
7818         case DW_LNS_set_column:
7819         case DW_LNS_fixed_advance_pc:
7820           n_op_args = 1;
7821           break;
7822         default:
7823           n_op_args = 0;
7824           break;
7825         }
7826
7827       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7828                            opc, n_op_args);
7829     }
7830
7831   /* Write out the information about the files we use.  */
7832   output_file_names ();
7833   ASM_OUTPUT_LABEL (asm_out_file, p2);
7834
7835   /* We used to set the address register to the first location in the text
7836      section here, but that didn't accomplish anything since we already
7837      have a line note for the opening brace of the first function.  */
7838
7839   /* Generate the line number to PC correspondence table, encoded as
7840      a series of state machine operations.  */
7841   current_file = 1;
7842   current_line = 1;
7843
7844   if (cfun && in_cold_section_p)
7845     strcpy (prev_line_label, cfun->cold_section_label);
7846   else
7847     strcpy (prev_line_label, text_section_label);
7848   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7849     {
7850       dw_line_info_ref line_info = &line_info_table[lt_index];
7851
7852 #if 0
7853       /* Disable this optimization for now; GDB wants to see two line notes
7854          at the beginning of a function so it can find the end of the
7855          prologue.  */
7856
7857       /* Don't emit anything for redundant notes.  Just updating the
7858          address doesn't accomplish anything, because we already assume
7859          that anything after the last address is this line.  */
7860       if (line_info->dw_line_num == current_line
7861           && line_info->dw_file_num == current_file)
7862         continue;
7863 #endif
7864
7865       /* Emit debug info for the address of the current line.
7866
7867          Unfortunately, we have little choice here currently, and must always
7868          use the most general form.  GCC does not know the address delta
7869          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
7870          attributes which will give an upper bound on the address range.  We
7871          could perhaps use length attributes to determine when it is safe to
7872          use DW_LNS_fixed_advance_pc.  */
7873
7874       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7875       if (0)
7876         {
7877           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
7878           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7879                                "DW_LNS_fixed_advance_pc");
7880           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7881         }
7882       else
7883         {
7884           /* This can handle any delta.  This takes
7885              4+DWARF2_ADDR_SIZE bytes.  */
7886           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7887           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7888           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7889           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7890         }
7891
7892       strcpy (prev_line_label, line_label);
7893
7894       /* Emit debug info for the source file of the current line, if
7895          different from the previous line.  */
7896       if (line_info->dw_file_num != current_file)
7897         {
7898           current_file = line_info->dw_file_num;
7899           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7900           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7901                                        VARRAY_CHAR_PTR (file_table,
7902                                                         current_file));
7903         }
7904
7905       /* Emit debug info for the current line number, choosing the encoding
7906          that uses the least amount of space.  */
7907       if (line_info->dw_line_num != current_line)
7908         {
7909           line_offset = line_info->dw_line_num - current_line;
7910           line_delta = line_offset - DWARF_LINE_BASE;
7911           current_line = line_info->dw_line_num;
7912           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7913             /* This can handle deltas from -10 to 234, using the current
7914                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
7915                takes 1 byte.  */
7916             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7917                                  "line %lu", current_line);
7918           else
7919             {
7920               /* This can handle any delta.  This takes at least 4 bytes,
7921                  depending on the value being encoded.  */
7922               dw2_asm_output_data (1, DW_LNS_advance_line,
7923                                    "advance to line %lu", current_line);
7924               dw2_asm_output_data_sleb128 (line_offset, NULL);
7925               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7926             }
7927         }
7928       else
7929         /* We still need to start a new row, so output a copy insn.  */
7930         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7931     }
7932
7933   /* Emit debug info for the address of the end of the function.  */
7934   if (0)
7935     {
7936       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7937                            "DW_LNS_fixed_advance_pc");
7938       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
7939     }
7940   else
7941     {
7942       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7943       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7944       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7945       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
7946     }
7947
7948   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7949   dw2_asm_output_data_uleb128 (1, NULL);
7950   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7951
7952   function = 0;
7953   current_file = 1;
7954   current_line = 1;
7955   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
7956     {
7957       dw_separate_line_info_ref line_info
7958         = &separate_line_info_table[lt_index];
7959
7960 #if 0
7961       /* Don't emit anything for redundant notes.  */
7962       if (line_info->dw_line_num == current_line
7963           && line_info->dw_file_num == current_file
7964           && line_info->function == function)
7965         goto cont;
7966 #endif
7967
7968       /* Emit debug info for the address of the current line.  If this is
7969          a new function, or the first line of a function, then we need
7970          to handle it differently.  */
7971       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
7972                                    lt_index);
7973       if (function != line_info->function)
7974         {
7975           function = line_info->function;
7976
7977           /* Set the address register to the first line in the function.  */
7978           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7979           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7980           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7981           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7982         }
7983       else
7984         {
7985           /* ??? See the DW_LNS_advance_pc comment above.  */
7986           if (0)
7987             {
7988               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7989                                    "DW_LNS_fixed_advance_pc");
7990               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7991             }
7992           else
7993             {
7994               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7995               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7996               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7997               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7998             }
7999         }
8000
8001       strcpy (prev_line_label, line_label);
8002
8003       /* Emit debug info for the source file of the current line, if
8004          different from the previous line.  */
8005       if (line_info->dw_file_num != current_file)
8006         {
8007           current_file = line_info->dw_file_num;
8008           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8009           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
8010                                        VARRAY_CHAR_PTR (file_table,
8011                                                         current_file));
8012         }
8013
8014       /* Emit debug info for the current line number, choosing the encoding
8015          that uses the least amount of space.  */
8016       if (line_info->dw_line_num != current_line)
8017         {
8018           line_offset = line_info->dw_line_num - current_line;
8019           line_delta = line_offset - DWARF_LINE_BASE;
8020           current_line = line_info->dw_line_num;
8021           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8022             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8023                                  "line %lu", current_line);
8024           else
8025             {
8026               dw2_asm_output_data (1, DW_LNS_advance_line,
8027                                    "advance to line %lu", current_line);
8028               dw2_asm_output_data_sleb128 (line_offset, NULL);
8029               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8030             }
8031         }
8032       else
8033         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8034
8035 #if 0
8036     cont:
8037 #endif
8038
8039       lt_index++;
8040
8041       /* If we're done with a function, end its sequence.  */
8042       if (lt_index == separate_line_info_table_in_use
8043           || separate_line_info_table[lt_index].function != function)
8044         {
8045           current_file = 1;
8046           current_line = 1;
8047
8048           /* Emit debug info for the address of the end of the function.  */
8049           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8050           if (0)
8051             {
8052               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8053                                    "DW_LNS_fixed_advance_pc");
8054               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8055             }
8056           else
8057             {
8058               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8059               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8060               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8061               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8062             }
8063
8064           /* Output the marker for the end of this sequence.  */
8065           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8066           dw2_asm_output_data_uleb128 (1, NULL);
8067           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8068         }
8069     }
8070
8071   /* Output the marker for the end of the line number info.  */
8072   ASM_OUTPUT_LABEL (asm_out_file, l2);
8073 }
8074 \f
8075 /* Given a pointer to a tree node for some base type, return a pointer to
8076    a DIE that describes the given type.
8077
8078    This routine must only be called for GCC type nodes that correspond to
8079    Dwarf base (fundamental) types.  */
8080
8081 static dw_die_ref
8082 base_type_die (tree type)
8083 {
8084   dw_die_ref base_type_result;
8085   enum dwarf_type encoding;
8086
8087   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8088     return 0;
8089
8090   switch (TREE_CODE (type))
8091     {
8092     case INTEGER_TYPE:
8093       if (TYPE_STRING_FLAG (type))
8094         {
8095           if (TYPE_UNSIGNED (type))
8096             encoding = DW_ATE_unsigned_char;
8097           else
8098             encoding = DW_ATE_signed_char;
8099         }
8100       else if (TYPE_UNSIGNED (type))
8101         encoding = DW_ATE_unsigned;
8102       else
8103         encoding = DW_ATE_signed;
8104       break;
8105
8106     case REAL_TYPE:
8107       if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8108         encoding = DW_ATE_decimal_float;
8109       else
8110         encoding = DW_ATE_float;
8111       break;
8112
8113       /* Dwarf2 doesn't know anything about complex ints, so use
8114          a user defined type for it.  */
8115     case COMPLEX_TYPE:
8116       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8117         encoding = DW_ATE_complex_float;
8118       else
8119         encoding = DW_ATE_lo_user;
8120       break;
8121
8122     case BOOLEAN_TYPE:
8123       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
8124       encoding = DW_ATE_boolean;
8125       break;
8126
8127     default:
8128       /* No other TREE_CODEs are Dwarf fundamental types.  */
8129       gcc_unreachable ();
8130     }
8131
8132   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8133
8134   /* This probably indicates a bug.  */
8135   if (! TYPE_NAME (type))
8136     add_name_attribute (base_type_result, "__unknown__");
8137
8138   add_AT_unsigned (base_type_result, DW_AT_byte_size,
8139                    int_size_in_bytes (type));
8140   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8141
8142   return base_type_result;
8143 }
8144
8145 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8146    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
8147    a given type is generally the same as the given type, except that if the
8148    given type is a pointer or reference type, then the root type of the given
8149    type is the root type of the "basis" type for the pointer or reference
8150    type.  (This definition of the "root" type is recursive.) Also, the root
8151    type of a `const' qualified type or a `volatile' qualified type is the
8152    root type of the given type without the qualifiers.  */
8153
8154 static tree
8155 root_type (tree type)
8156 {
8157   if (TREE_CODE (type) == ERROR_MARK)
8158     return error_mark_node;
8159
8160   switch (TREE_CODE (type))
8161     {
8162     case ERROR_MARK:
8163       return error_mark_node;
8164
8165     case POINTER_TYPE:
8166     case REFERENCE_TYPE:
8167       return type_main_variant (root_type (TREE_TYPE (type)));
8168
8169     default:
8170       return type_main_variant (type);
8171     }
8172 }
8173
8174 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8175    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
8176
8177 static inline int
8178 is_base_type (tree type)
8179 {
8180   switch (TREE_CODE (type))
8181     {
8182     case ERROR_MARK:
8183     case VOID_TYPE:
8184     case INTEGER_TYPE:
8185     case REAL_TYPE:
8186     case COMPLEX_TYPE:
8187     case BOOLEAN_TYPE:
8188       return 1;
8189
8190     case ARRAY_TYPE:
8191     case RECORD_TYPE:
8192     case UNION_TYPE:
8193     case QUAL_UNION_TYPE:
8194     case ENUMERAL_TYPE:
8195     case FUNCTION_TYPE:
8196     case METHOD_TYPE:
8197     case POINTER_TYPE:
8198     case REFERENCE_TYPE:
8199     case OFFSET_TYPE:
8200     case LANG_TYPE:
8201     case VECTOR_TYPE:
8202       return 0;
8203
8204     default:
8205       gcc_unreachable ();
8206     }
8207
8208   return 0;
8209 }
8210
8211 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8212    node, return the size in bits for the type if it is a constant, or else
8213    return the alignment for the type if the type's size is not constant, or
8214    else return BITS_PER_WORD if the type actually turns out to be an
8215    ERROR_MARK node.  */
8216
8217 static inline unsigned HOST_WIDE_INT
8218 simple_type_size_in_bits (tree type)
8219 {
8220   if (TREE_CODE (type) == ERROR_MARK)
8221     return BITS_PER_WORD;
8222   else if (TYPE_SIZE (type) == NULL_TREE)
8223     return 0;
8224   else if (host_integerp (TYPE_SIZE (type), 1))
8225     return tree_low_cst (TYPE_SIZE (type), 1);
8226   else
8227     return TYPE_ALIGN (type);
8228 }
8229
8230 /* Return true if the debug information for the given type should be
8231    emitted as a subrange type.  */
8232
8233 static inline bool
8234 is_subrange_type (tree type)
8235 {
8236   tree subtype = TREE_TYPE (type);
8237
8238   /* Subrange types are identified by the fact that they are integer
8239      types, and that they have a subtype which is either an integer type
8240      or an enumeral type.  */
8241
8242   if (TREE_CODE (type) != INTEGER_TYPE
8243       || subtype == NULL_TREE)
8244     return false;
8245
8246   if (TREE_CODE (subtype) != INTEGER_TYPE
8247       && TREE_CODE (subtype) != ENUMERAL_TYPE)
8248     return false;
8249
8250   if (TREE_CODE (type) == TREE_CODE (subtype)
8251       && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8252       && TYPE_MIN_VALUE (type) != NULL
8253       && TYPE_MIN_VALUE (subtype) != NULL
8254       && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8255       && TYPE_MAX_VALUE (type) != NULL
8256       && TYPE_MAX_VALUE (subtype) != NULL
8257       && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8258     {
8259       /* The type and its subtype have the same representation.  If in
8260          addition the two types also have the same name, then the given
8261          type is not a subrange type, but rather a plain base type.  */
8262       /* FIXME: brobecker/2004-03-22:
8263          Sizetype INTEGER_CSTs nodes are canonicalized.  It should
8264          therefore be sufficient to check the TYPE_SIZE node pointers
8265          rather than checking the actual size.  Unfortunately, we have
8266          found some cases, such as in the Ada "integer" type, where
8267          this is not the case.  Until this problem is solved, we need to
8268          keep checking the actual size.  */
8269       tree type_name = TYPE_NAME (type);
8270       tree subtype_name = TYPE_NAME (subtype);
8271
8272       if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8273         type_name = DECL_NAME (type_name);
8274
8275       if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8276         subtype_name = DECL_NAME (subtype_name);
8277
8278       if (type_name == subtype_name)
8279         return false;
8280     }
8281
8282   return true;
8283 }
8284
8285 /*  Given a pointer to a tree node for a subrange type, return a pointer
8286     to a DIE that describes the given type.  */
8287
8288 static dw_die_ref
8289 subrange_type_die (tree type, dw_die_ref context_die)
8290 {
8291   dw_die_ref subrange_die;
8292   const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8293
8294   if (context_die == NULL)
8295     context_die = comp_unit_die;
8296
8297   subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8298
8299   if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8300     {
8301       /* The size of the subrange type and its base type do not match,
8302          so we need to generate a size attribute for the subrange type.  */
8303       add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8304     }
8305
8306   if (TYPE_MIN_VALUE (type) != NULL)
8307     add_bound_info (subrange_die, DW_AT_lower_bound,
8308                     TYPE_MIN_VALUE (type));
8309   if (TYPE_MAX_VALUE (type) != NULL)
8310     add_bound_info (subrange_die, DW_AT_upper_bound,
8311                     TYPE_MAX_VALUE (type));
8312
8313   return subrange_die;
8314 }
8315
8316 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8317    entry that chains various modifiers in front of the given type.  */
8318
8319 static dw_die_ref
8320 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8321                    dw_die_ref context_die)
8322 {
8323   enum tree_code code = TREE_CODE (type);
8324   dw_die_ref mod_type_die;
8325   dw_die_ref sub_die = NULL;
8326   tree item_type = NULL;
8327   tree qualified_type;
8328   tree name;
8329
8330   if (code == ERROR_MARK)
8331     return NULL;
8332
8333   /* See if we already have the appropriately qualified variant of
8334      this type.  */
8335   qualified_type
8336     = get_qualified_type (type,
8337                           ((is_const_type ? TYPE_QUAL_CONST : 0)
8338                            | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8339
8340   /* If we do, then we can just use its DIE, if it exists.  */
8341   if (qualified_type)
8342     {
8343       mod_type_die = lookup_type_die (qualified_type);
8344       if (mod_type_die)
8345         return mod_type_die;
8346     }
8347
8348   name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8349
8350   /* Handle C typedef types.  */
8351   if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8352     {
8353       tree dtype = TREE_TYPE (name);
8354
8355       if (qualified_type == dtype)
8356         {
8357           /* For a named type, use the typedef.  */
8358           gen_type_die (qualified_type, context_die);
8359           return lookup_type_die (qualified_type);
8360         }
8361       else if (DECL_ORIGINAL_TYPE (name)
8362                && (is_const_type < TYPE_READONLY (dtype)
8363                    || is_volatile_type < TYPE_VOLATILE (dtype)))
8364         /* cv-unqualified version of named type.  Just use the unnamed
8365            type to which it refers.  */
8366         return modified_type_die (DECL_ORIGINAL_TYPE (name),
8367                                   is_const_type, is_volatile_type,
8368                                   context_die);
8369       /* Else cv-qualified version of named type; fall through.  */
8370     }
8371
8372   if (is_const_type)
8373     {
8374       mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8375       sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8376     }
8377   else if (is_volatile_type)
8378     {
8379       mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8380       sub_die = modified_type_die (type, 0, 0, context_die);
8381     }
8382   else if (code == POINTER_TYPE)
8383     {
8384       mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8385       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8386                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8387       item_type = TREE_TYPE (type);
8388     }
8389   else if (code == REFERENCE_TYPE)
8390     {
8391       mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8392       add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8393                        simple_type_size_in_bits (type) / BITS_PER_UNIT);
8394       item_type = TREE_TYPE (type);
8395     }
8396   else if (is_subrange_type (type))
8397     {
8398       mod_type_die = subrange_type_die (type, context_die);
8399       item_type = TREE_TYPE (type);
8400     }
8401   else if (is_base_type (type))
8402     mod_type_die = base_type_die (type);
8403   else
8404     {
8405       gen_type_die (type, context_die);
8406
8407       /* We have to get the type_main_variant here (and pass that to the
8408          `lookup_type_die' routine) because the ..._TYPE node we have
8409          might simply be a *copy* of some original type node (where the
8410          copy was created to help us keep track of typedef names) and
8411          that copy might have a different TYPE_UID from the original
8412          ..._TYPE node.  */
8413       if (TREE_CODE (type) != VECTOR_TYPE)
8414         return lookup_type_die (type_main_variant (type));
8415       else
8416         /* Vectors have the debugging information in the type,
8417            not the main variant.  */
8418         return lookup_type_die (type);
8419     }
8420
8421   /* Builtin types don't have a DECL_ORIGINAL_TYPE.  For those,
8422      don't output a DW_TAG_typedef, since there isn't one in the
8423      user's program; just attach a DW_AT_name to the type.  */
8424   if (name
8425       && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type))
8426     {
8427       if (TREE_CODE (name) == TYPE_DECL)
8428         /* Could just call add_name_and_src_coords_attributes here,
8429            but since this is a builtin type it doesn't have any
8430            useful source coordinates anyway.  */
8431         name = DECL_NAME (name);
8432       add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8433     }
8434
8435   if (qualified_type)
8436     equate_type_number_to_die (qualified_type, mod_type_die);
8437
8438   if (item_type)
8439     /* We must do this after the equate_type_number_to_die call, in case
8440        this is a recursive type.  This ensures that the modified_type_die
8441        recursion will terminate even if the type is recursive.  Recursive
8442        types are possible in Ada.  */
8443     sub_die = modified_type_die (item_type,
8444                                  TYPE_READONLY (item_type),
8445                                  TYPE_VOLATILE (item_type),
8446                                  context_die);
8447
8448   if (sub_die != NULL)
8449     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8450
8451   return mod_type_die;
8452 }
8453
8454 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8455    an enumerated type.  */
8456
8457 static inline int
8458 type_is_enum (tree type)
8459 {
8460   return TREE_CODE (type) == ENUMERAL_TYPE;
8461 }
8462
8463 /* Return the DBX register number described by a given RTL node.  */
8464
8465 static unsigned int
8466 dbx_reg_number (rtx rtl)
8467 {
8468   unsigned regno = REGNO (rtl);
8469
8470   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8471
8472 #ifdef LEAF_REG_REMAP
8473   regno = LEAF_REG_REMAP (regno);
8474 #endif
8475
8476   return DBX_REGISTER_NUMBER (regno);
8477 }
8478
8479 /* Optionally add a DW_OP_piece term to a location description expression.
8480    DW_OP_piece is only added if the location description expression already
8481    doesn't end with DW_OP_piece.  */
8482
8483 static void
8484 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8485 {
8486   dw_loc_descr_ref loc;
8487
8488   if (*list_head != NULL)
8489     {
8490       /* Find the end of the chain.  */
8491       for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8492         ;
8493
8494       if (loc->dw_loc_opc != DW_OP_piece)
8495         loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8496     }
8497 }
8498
8499 /* Return a location descriptor that designates a machine register or
8500    zero if there is none.  */
8501
8502 static dw_loc_descr_ref
8503 reg_loc_descriptor (rtx rtl)
8504 {
8505   rtx regs;
8506
8507   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8508     return 0;
8509
8510   regs = targetm.dwarf_register_span (rtl);
8511
8512   if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8513     return multiple_reg_loc_descriptor (rtl, regs);
8514   else
8515     return one_reg_loc_descriptor (dbx_reg_number (rtl));
8516 }
8517
8518 /* Return a location descriptor that designates a machine register for
8519    a given hard register number.  */
8520
8521 static dw_loc_descr_ref
8522 one_reg_loc_descriptor (unsigned int regno)
8523 {
8524   if (regno <= 31)
8525     return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8526   else
8527     return new_loc_descr (DW_OP_regx, regno, 0);
8528 }
8529
8530 /* Given an RTL of a register, return a location descriptor that
8531    designates a value that spans more than one register.  */
8532
8533 static dw_loc_descr_ref
8534 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8535 {
8536   int nregs, size, i;
8537   unsigned reg;
8538   dw_loc_descr_ref loc_result = NULL;
8539
8540   reg = REGNO (rtl);
8541 #ifdef LEAF_REG_REMAP
8542   reg = LEAF_REG_REMAP (reg);
8543 #endif
8544   gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8545   nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8546
8547   /* Simple, contiguous registers.  */
8548   if (regs == NULL_RTX)
8549     {
8550       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8551
8552       loc_result = NULL;
8553       while (nregs--)
8554         {
8555           dw_loc_descr_ref t;
8556
8557           t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8558           add_loc_descr (&loc_result, t);
8559           add_loc_descr_op_piece (&loc_result, size);
8560           ++reg;
8561         }
8562       return loc_result;
8563     }
8564
8565   /* Now onto stupid register sets in non contiguous locations.  */
8566
8567   gcc_assert (GET_CODE (regs) == PARALLEL);
8568
8569   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8570   loc_result = NULL;
8571
8572   for (i = 0; i < XVECLEN (regs, 0); ++i)
8573     {
8574       dw_loc_descr_ref t;
8575
8576       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8577       add_loc_descr (&loc_result, t);
8578       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8579       add_loc_descr_op_piece (&loc_result, size);
8580     }
8581   return loc_result;
8582 }
8583
8584 /* Return a location descriptor that designates a constant.  */
8585
8586 static dw_loc_descr_ref
8587 int_loc_descriptor (HOST_WIDE_INT i)
8588 {
8589   enum dwarf_location_atom op;
8590
8591   /* Pick the smallest representation of a constant, rather than just
8592      defaulting to the LEB encoding.  */
8593   if (i >= 0)
8594     {
8595       if (i <= 31)
8596         op = DW_OP_lit0 + i;
8597       else if (i <= 0xff)
8598         op = DW_OP_const1u;
8599       else if (i <= 0xffff)
8600         op = DW_OP_const2u;
8601       else if (HOST_BITS_PER_WIDE_INT == 32
8602                || i <= 0xffffffff)
8603         op = DW_OP_const4u;
8604       else
8605         op = DW_OP_constu;
8606     }
8607   else
8608     {
8609       if (i >= -0x80)
8610         op = DW_OP_const1s;
8611       else if (i >= -0x8000)
8612         op = DW_OP_const2s;
8613       else if (HOST_BITS_PER_WIDE_INT == 32
8614                || i >= -0x80000000)
8615         op = DW_OP_const4s;
8616       else
8617         op = DW_OP_consts;
8618     }
8619
8620   return new_loc_descr (op, i, 0);
8621 }
8622
8623 /* Return a location descriptor that designates a base+offset location.  */
8624
8625 static dw_loc_descr_ref
8626 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8627 {
8628   unsigned int regno;
8629
8630   /* We only use "frame base" when we're sure we're talking about the
8631      post-prologue local stack frame.  We do this by *not* running
8632      register elimination until this point, and recognizing the special
8633      argument pointer and soft frame pointer rtx's.  */
8634   if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8635     {
8636       rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8637
8638       if (elim != reg)
8639         {
8640           if (GET_CODE (elim) == PLUS)
8641             {
8642               offset += INTVAL (XEXP (elim, 1));
8643               elim = XEXP (elim, 0);
8644             }
8645           gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8646                       : stack_pointer_rtx));
8647           offset += frame_pointer_cfa_offset;
8648
8649           return new_loc_descr (DW_OP_fbreg, offset, 0);
8650         }
8651     }
8652
8653   regno = dbx_reg_number (reg);
8654   if (regno <= 31)
8655     return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8656   else
8657     return new_loc_descr (DW_OP_bregx, regno, offset);
8658 }
8659
8660 /* Return true if this RTL expression describes a base+offset calculation.  */
8661
8662 static inline int
8663 is_based_loc (rtx rtl)
8664 {
8665   return (GET_CODE (rtl) == PLUS
8666           && ((REG_P (XEXP (rtl, 0))
8667                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8668                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8669 }
8670
8671 /* The following routine converts the RTL for a variable or parameter
8672    (resident in memory) into an equivalent Dwarf representation of a
8673    mechanism for getting the address of that same variable onto the top of a
8674    hypothetical "address evaluation" stack.
8675
8676    When creating memory location descriptors, we are effectively transforming
8677    the RTL for a memory-resident object into its Dwarf postfix expression
8678    equivalent.  This routine recursively descends an RTL tree, turning
8679    it into Dwarf postfix code as it goes.
8680
8681    MODE is the mode of the memory reference, needed to handle some
8682    autoincrement addressing modes.
8683
8684    CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8685    location list for RTL.
8686
8687    Return 0 if we can't represent the location.  */
8688
8689 static dw_loc_descr_ref
8690 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8691 {
8692   dw_loc_descr_ref mem_loc_result = NULL;
8693   enum dwarf_location_atom op;
8694
8695   /* Note that for a dynamically sized array, the location we will generate a
8696      description of here will be the lowest numbered location which is
8697      actually within the array.  That's *not* necessarily the same as the
8698      zeroth element of the array.  */
8699
8700   rtl = targetm.delegitimize_address (rtl);
8701
8702   switch (GET_CODE (rtl))
8703     {
8704     case POST_INC:
8705     case POST_DEC:
8706     case POST_MODIFY:
8707       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8708          just fall into the SUBREG code.  */
8709
8710       /* ... fall through ...  */
8711
8712     case SUBREG:
8713       /* The case of a subreg may arise when we have a local (register)
8714          variable or a formal (register) parameter which doesn't quite fill
8715          up an entire register.  For now, just assume that it is
8716          legitimate to make the Dwarf info refer to the whole register which
8717          contains the given subreg.  */
8718       rtl = XEXP (rtl, 0);
8719
8720       /* ... fall through ...  */
8721
8722     case REG:
8723       /* Whenever a register number forms a part of the description of the
8724          method for calculating the (dynamic) address of a memory resident
8725          object, DWARF rules require the register number be referred to as
8726          a "base register".  This distinction is not based in any way upon
8727          what category of register the hardware believes the given register
8728          belongs to.  This is strictly DWARF terminology we're dealing with
8729          here. Note that in cases where the location of a memory-resident
8730          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8731          OP_CONST (0)) the actual DWARF location descriptor that we generate
8732          may just be OP_BASEREG (basereg).  This may look deceptively like
8733          the object in question was allocated to a register (rather than in
8734          memory) so DWARF consumers need to be aware of the subtle
8735          distinction between OP_REG and OP_BASEREG.  */
8736       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8737         mem_loc_result = based_loc_descr (rtl, 0);
8738       break;
8739
8740     case MEM:
8741       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8742       if (mem_loc_result != 0)
8743         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8744       break;
8745
8746     case LO_SUM:
8747          rtl = XEXP (rtl, 1);
8748
8749       /* ... fall through ...  */
8750
8751     case LABEL_REF:
8752       /* Some ports can transform a symbol ref into a label ref, because
8753          the symbol ref is too far away and has to be dumped into a constant
8754          pool.  */
8755     case CONST:
8756     case SYMBOL_REF:
8757       /* Alternatively, the symbol in the constant pool might be referenced
8758          by a different symbol.  */
8759       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8760         {
8761           bool marked;
8762           rtx tmp = get_pool_constant_mark (rtl, &marked);
8763
8764           if (GET_CODE (tmp) == SYMBOL_REF)
8765             {
8766               rtl = tmp;
8767               if (CONSTANT_POOL_ADDRESS_P (tmp))
8768                 get_pool_constant_mark (tmp, &marked);
8769               else
8770                 marked = true;
8771             }
8772
8773           /* If all references to this pool constant were optimized away,
8774              it was not output and thus we can't represent it.
8775              FIXME: might try to use DW_OP_const_value here, though
8776              DW_OP_piece complicates it.  */
8777           if (!marked)
8778             return 0;
8779         }
8780
8781       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8782       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8783       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8784       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8785       break;
8786
8787     case PRE_MODIFY:
8788       /* Extract the PLUS expression nested inside and fall into
8789          PLUS code below.  */
8790       rtl = XEXP (rtl, 1);
8791       goto plus;
8792
8793     case PRE_INC:
8794     case PRE_DEC:
8795       /* Turn these into a PLUS expression and fall into the PLUS code
8796          below.  */
8797       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8798                           GEN_INT (GET_CODE (rtl) == PRE_INC
8799                                    ? GET_MODE_UNIT_SIZE (mode)
8800                                    : -GET_MODE_UNIT_SIZE (mode)));
8801
8802       /* ... fall through ...  */
8803
8804     case PLUS:
8805     plus:
8806       if (is_based_loc (rtl))
8807         mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8808                                           INTVAL (XEXP (rtl, 1)));
8809       else
8810         {
8811           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8812           if (mem_loc_result == 0)
8813             break;
8814
8815           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8816               && INTVAL (XEXP (rtl, 1)) >= 0)
8817             add_loc_descr (&mem_loc_result,
8818                            new_loc_descr (DW_OP_plus_uconst,
8819                                           INTVAL (XEXP (rtl, 1)), 0));
8820           else
8821             {
8822               add_loc_descr (&mem_loc_result,
8823                              mem_loc_descriptor (XEXP (rtl, 1), mode));
8824               add_loc_descr (&mem_loc_result,
8825                              new_loc_descr (DW_OP_plus, 0, 0));
8826             }
8827         }
8828       break;
8829
8830     /* If a pseudo-reg is optimized away, it is possible for it to
8831        be replaced with a MEM containing a multiply or shift.  */
8832     case MULT:
8833       op = DW_OP_mul;
8834       goto do_binop;
8835
8836     case ASHIFT:
8837       op = DW_OP_shl;
8838       goto do_binop;
8839
8840     case ASHIFTRT:
8841       op = DW_OP_shra;
8842       goto do_binop;
8843
8844     case LSHIFTRT:
8845       op = DW_OP_shr;
8846       goto do_binop;
8847
8848     do_binop:
8849       {
8850         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8851         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8852
8853         if (op0 == 0 || op1 == 0)
8854           break;
8855
8856         mem_loc_result = op0;
8857         add_loc_descr (&mem_loc_result, op1);
8858         add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
8859         break;
8860       }
8861
8862     case CONST_INT:
8863       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8864       break;
8865
8866     default:
8867       gcc_unreachable ();
8868     }
8869
8870   return mem_loc_result;
8871 }
8872
8873 /* Return a descriptor that describes the concatenation of two locations.
8874    This is typically a complex variable.  */
8875
8876 static dw_loc_descr_ref
8877 concat_loc_descriptor (rtx x0, rtx x1)
8878 {
8879   dw_loc_descr_ref cc_loc_result = NULL;
8880   dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8881   dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8882
8883   if (x0_ref == 0 || x1_ref == 0)
8884     return 0;
8885
8886   cc_loc_result = x0_ref;
8887   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
8888
8889   add_loc_descr (&cc_loc_result, x1_ref);
8890   add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
8891
8892   return cc_loc_result;
8893 }
8894
8895 /* Output a proper Dwarf location descriptor for a variable or parameter
8896    which is either allocated in a register or in a memory location.  For a
8897    register, we just generate an OP_REG and the register number.  For a
8898    memory location we provide a Dwarf postfix expression describing how to
8899    generate the (dynamic) address of the object onto the address stack.
8900
8901    If we don't know how to describe it, return 0.  */
8902
8903 static dw_loc_descr_ref
8904 loc_descriptor (rtx rtl)
8905 {
8906   dw_loc_descr_ref loc_result = NULL;
8907
8908   switch (GET_CODE (rtl))
8909     {
8910     case SUBREG:
8911       /* The case of a subreg may arise when we have a local (register)
8912          variable or a formal (register) parameter which doesn't quite fill
8913          up an entire register.  For now, just assume that it is
8914          legitimate to make the Dwarf info refer to the whole register which
8915          contains the given subreg.  */
8916       rtl = SUBREG_REG (rtl);
8917
8918       /* ... fall through ...  */
8919
8920     case REG:
8921       loc_result = reg_loc_descriptor (rtl);
8922       break;
8923
8924     case MEM:
8925       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8926       break;
8927
8928     case CONCAT:
8929       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8930       break;
8931
8932     case VAR_LOCATION:
8933       /* Single part.  */
8934       if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
8935         {
8936           loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
8937           break;
8938         }
8939
8940       rtl = XEXP (rtl, 1);
8941       /* FALLTHRU */
8942
8943     case PARALLEL:
8944       {
8945         rtvec par_elems = XVEC (rtl, 0);
8946         int num_elem = GET_NUM_ELEM (par_elems);
8947         enum machine_mode mode;
8948         int i;
8949
8950         /* Create the first one, so we have something to add to.  */
8951         loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
8952         mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
8953         add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
8954         for (i = 1; i < num_elem; i++)
8955           {
8956             dw_loc_descr_ref temp;
8957
8958             temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
8959             add_loc_descr (&loc_result, temp);
8960             mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
8961             add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
8962           }
8963       }
8964       break;
8965
8966     default:
8967       gcc_unreachable ();
8968     }
8969
8970   return loc_result;
8971 }
8972
8973 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
8974    up particularly with variable length arrays.  WANT_ADDRESS is 2 if this is
8975    a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
8976    top-level invocation, and we require the address of LOC; is 0 if we require
8977    the value of LOC.  */
8978
8979 static dw_loc_descr_ref
8980 loc_descriptor_from_tree_1 (tree loc, int want_address)
8981 {
8982   dw_loc_descr_ref ret, ret1;
8983   int have_address = 0;
8984   enum dwarf_location_atom op;
8985
8986   /* ??? Most of the time we do not take proper care for sign/zero
8987      extending the values properly.  Hopefully this won't be a real
8988      problem...  */
8989
8990   switch (TREE_CODE (loc))
8991     {
8992     case ERROR_MARK:
8993       return 0;
8994
8995     case PLACEHOLDER_EXPR:
8996       /* This case involves extracting fields from an object to determine the
8997          position of other fields.  We don't try to encode this here.  The
8998          only user of this is Ada, which encodes the needed information using
8999          the names of types.  */
9000       return 0;
9001
9002     case CALL_EXPR:
9003       return 0;
9004
9005     case PREINCREMENT_EXPR:
9006     case PREDECREMENT_EXPR:
9007     case POSTINCREMENT_EXPR:
9008     case POSTDECREMENT_EXPR:
9009       /* There are no opcodes for these operations.  */
9010       return 0;
9011
9012     case ADDR_EXPR:
9013       /* If we already want an address, there's nothing we can do.  */
9014       if (want_address)
9015         return 0;
9016
9017       /* Otherwise, process the argument and look for the address.  */
9018       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9019
9020     case VAR_DECL:
9021       if (DECL_THREAD_LOCAL_P (loc))
9022         {
9023           rtx rtl;
9024
9025           /* If this is not defined, we have no way to emit the data.  */
9026           if (!targetm.asm_out.output_dwarf_dtprel)
9027             return 0;
9028
9029           /* The way DW_OP_GNU_push_tls_address is specified, we can only
9030              look up addresses of objects in the current module.  */
9031           if (DECL_EXTERNAL (loc))
9032             return 0;
9033
9034           rtl = rtl_for_decl_location (loc);
9035           if (rtl == NULL_RTX)
9036             return 0;
9037
9038           if (!MEM_P (rtl))
9039             return 0;
9040           rtl = XEXP (rtl, 0);
9041           if (! CONSTANT_P (rtl))
9042             return 0;
9043
9044           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9045           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9046           ret->dw_loc_oprnd1.v.val_addr = rtl;
9047
9048           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9049           add_loc_descr (&ret, ret1);
9050
9051           have_address = 1;
9052           break;
9053         }
9054       /* FALLTHRU */
9055
9056     case PARM_DECL:
9057       if (DECL_HAS_VALUE_EXPR_P (loc))
9058         return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9059                                            want_address);
9060       /* FALLTHRU */
9061
9062     case RESULT_DECL:
9063       {
9064         rtx rtl = rtl_for_decl_location (loc);
9065
9066         if (rtl == NULL_RTX)
9067           return 0;
9068         else if (GET_CODE (rtl) == CONST_INT)
9069           {
9070             HOST_WIDE_INT val = INTVAL (rtl);
9071             if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9072               val &= GET_MODE_MASK (DECL_MODE (loc));
9073             ret = int_loc_descriptor (val);
9074           }
9075         else if (GET_CODE (rtl) == CONST_STRING)
9076           return 0;
9077         else if (CONSTANT_P (rtl))
9078           {
9079             ret = new_loc_descr (DW_OP_addr, 0, 0);
9080             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9081             ret->dw_loc_oprnd1.v.val_addr = rtl;
9082           }
9083         else
9084           {
9085             enum machine_mode mode;
9086
9087             /* Certain constructs can only be represented at top-level.  */
9088             if (want_address == 2)
9089               return loc_descriptor (rtl);
9090
9091             mode = GET_MODE (rtl);
9092             if (MEM_P (rtl))
9093               {
9094                 rtl = XEXP (rtl, 0);
9095                 have_address = 1;
9096               }
9097             ret = mem_loc_descriptor (rtl, mode);
9098           }
9099       }
9100       break;
9101
9102     case INDIRECT_REF:
9103       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9104       have_address = 1;
9105       break;
9106
9107     case COMPOUND_EXPR:
9108       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9109
9110     case NOP_EXPR:
9111     case CONVERT_EXPR:
9112     case NON_LVALUE_EXPR:
9113     case VIEW_CONVERT_EXPR:
9114     case SAVE_EXPR:
9115     case MODIFY_EXPR:
9116       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9117
9118     case COMPONENT_REF:
9119     case BIT_FIELD_REF:
9120     case ARRAY_REF:
9121     case ARRAY_RANGE_REF:
9122       {
9123         tree obj, offset;
9124         HOST_WIDE_INT bitsize, bitpos, bytepos;
9125         enum machine_mode mode;
9126         int volatilep;
9127         int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9128
9129         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9130                                    &unsignedp, &volatilep, false);
9131
9132         if (obj == loc)
9133           return 0;
9134
9135         ret = loc_descriptor_from_tree_1 (obj, 1);
9136         if (ret == 0
9137             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9138           return 0;
9139
9140         if (offset != NULL_TREE)
9141           {
9142             /* Variable offset.  */
9143             add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9144             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9145           }
9146
9147         bytepos = bitpos / BITS_PER_UNIT;
9148         if (bytepos > 0)
9149           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9150         else if (bytepos < 0)
9151           {
9152             add_loc_descr (&ret, int_loc_descriptor (bytepos));
9153             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9154           }
9155
9156         have_address = 1;
9157         break;
9158       }
9159
9160     case INTEGER_CST:
9161       if (host_integerp (loc, 0))
9162         ret = int_loc_descriptor (tree_low_cst (loc, 0));
9163       else
9164         return 0;
9165       break;
9166
9167     case CONSTRUCTOR:
9168       {
9169         /* Get an RTL for this, if something has been emitted.  */
9170         rtx rtl = lookup_constant_def (loc);
9171         enum machine_mode mode;
9172
9173         if (!rtl || !MEM_P (rtl))
9174           return 0;
9175         mode = GET_MODE (rtl);
9176         rtl = XEXP (rtl, 0);
9177         ret = mem_loc_descriptor (rtl, mode);
9178         have_address = 1;
9179         break;
9180       }
9181
9182     case TRUTH_AND_EXPR:
9183     case TRUTH_ANDIF_EXPR:
9184     case BIT_AND_EXPR:
9185       op = DW_OP_and;
9186       goto do_binop;
9187
9188     case TRUTH_XOR_EXPR:
9189     case BIT_XOR_EXPR:
9190       op = DW_OP_xor;
9191       goto do_binop;
9192
9193     case TRUTH_OR_EXPR:
9194     case TRUTH_ORIF_EXPR:
9195     case BIT_IOR_EXPR:
9196       op = DW_OP_or;
9197       goto do_binop;
9198
9199     case FLOOR_DIV_EXPR:
9200     case CEIL_DIV_EXPR:
9201     case ROUND_DIV_EXPR:
9202     case TRUNC_DIV_EXPR:
9203       op = DW_OP_div;
9204       goto do_binop;
9205
9206     case MINUS_EXPR:
9207       op = DW_OP_minus;
9208       goto do_binop;
9209
9210     case FLOOR_MOD_EXPR:
9211     case CEIL_MOD_EXPR:
9212     case ROUND_MOD_EXPR:
9213     case TRUNC_MOD_EXPR:
9214       op = DW_OP_mod;
9215       goto do_binop;
9216
9217     case MULT_EXPR:
9218       op = DW_OP_mul;
9219       goto do_binop;
9220
9221     case LSHIFT_EXPR:
9222       op = DW_OP_shl;
9223       goto do_binop;
9224
9225     case RSHIFT_EXPR:
9226       op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9227       goto do_binop;
9228
9229     case PLUS_EXPR:
9230       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9231           && host_integerp (TREE_OPERAND (loc, 1), 0))
9232         {
9233           ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9234           if (ret == 0)
9235             return 0;
9236
9237           add_loc_descr (&ret,
9238                          new_loc_descr (DW_OP_plus_uconst,
9239                                         tree_low_cst (TREE_OPERAND (loc, 1),
9240                                                       0),
9241                                         0));
9242           break;
9243         }
9244
9245       op = DW_OP_plus;
9246       goto do_binop;
9247
9248     case LE_EXPR:
9249       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9250         return 0;
9251
9252       op = DW_OP_le;
9253       goto do_binop;
9254
9255     case GE_EXPR:
9256       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9257         return 0;
9258
9259       op = DW_OP_ge;
9260       goto do_binop;
9261
9262     case LT_EXPR:
9263       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9264         return 0;
9265
9266       op = DW_OP_lt;
9267       goto do_binop;
9268
9269     case GT_EXPR:
9270       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9271         return 0;
9272
9273       op = DW_OP_gt;
9274       goto do_binop;
9275
9276     case EQ_EXPR:
9277       op = DW_OP_eq;
9278       goto do_binop;
9279
9280     case NE_EXPR:
9281       op = DW_OP_ne;
9282       goto do_binop;
9283
9284     do_binop:
9285       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9286       ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9287       if (ret == 0 || ret1 == 0)
9288         return 0;
9289
9290       add_loc_descr (&ret, ret1);
9291       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9292       break;
9293
9294     case TRUTH_NOT_EXPR:
9295     case BIT_NOT_EXPR:
9296       op = DW_OP_not;
9297       goto do_unop;
9298
9299     case ABS_EXPR:
9300       op = DW_OP_abs;
9301       goto do_unop;
9302
9303     case NEGATE_EXPR:
9304       op = DW_OP_neg;
9305       goto do_unop;
9306
9307     do_unop:
9308       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9309       if (ret == 0)
9310         return 0;
9311
9312       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9313       break;
9314
9315     case MIN_EXPR:
9316     case MAX_EXPR:
9317       {
9318         const enum tree_code code =
9319           TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9320
9321         loc = build3 (COND_EXPR, TREE_TYPE (loc),
9322                       build2 (code, integer_type_node,
9323                               TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9324                       TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9325       }
9326
9327       /* ... fall through ...  */
9328
9329     case COND_EXPR:
9330       {
9331         dw_loc_descr_ref lhs
9332           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9333         dw_loc_descr_ref rhs
9334           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9335         dw_loc_descr_ref bra_node, jump_node, tmp;
9336
9337         ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9338         if (ret == 0 || lhs == 0 || rhs == 0)
9339           return 0;
9340
9341         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9342         add_loc_descr (&ret, bra_node);
9343
9344         add_loc_descr (&ret, rhs);
9345         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9346         add_loc_descr (&ret, jump_node);
9347
9348         add_loc_descr (&ret, lhs);
9349         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9350         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9351
9352         /* ??? Need a node to point the skip at.  Use a nop.  */
9353         tmp = new_loc_descr (DW_OP_nop, 0, 0);
9354         add_loc_descr (&ret, tmp);
9355         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9356         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9357       }
9358       break;
9359
9360     case FIX_TRUNC_EXPR:
9361     case FIX_CEIL_EXPR:
9362     case FIX_FLOOR_EXPR:
9363     case FIX_ROUND_EXPR:
9364       return 0;
9365
9366     default:
9367       /* Leave front-end specific codes as simply unknown.  This comes
9368          up, for instance, with the C STMT_EXPR.  */
9369       if ((unsigned int) TREE_CODE (loc)
9370           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9371         return 0;
9372
9373 #ifdef ENABLE_CHECKING
9374       /* Otherwise this is a generic code; we should just lists all of
9375          these explicitly.  We forgot one.  */
9376       gcc_unreachable ();
9377 #else
9378       /* In a release build, we want to degrade gracefully: better to
9379          generate incomplete debugging information than to crash.  */
9380       return NULL;
9381 #endif
9382     }
9383
9384   /* Show if we can't fill the request for an address.  */
9385   if (want_address && !have_address)
9386     return 0;
9387
9388   /* If we've got an address and don't want one, dereference.  */
9389   if (!want_address && have_address && ret)
9390     {
9391       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9392
9393       if (size > DWARF2_ADDR_SIZE || size == -1)
9394         return 0;
9395       else if (size == DWARF2_ADDR_SIZE)
9396         op = DW_OP_deref;
9397       else
9398         op = DW_OP_deref_size;
9399
9400       add_loc_descr (&ret, new_loc_descr (op, size, 0));
9401     }
9402
9403   return ret;
9404 }
9405
9406 static inline dw_loc_descr_ref
9407 loc_descriptor_from_tree (tree loc)
9408 {
9409   return loc_descriptor_from_tree_1 (loc, 2);
9410 }
9411
9412 /* Given a value, round it up to the lowest multiple of `boundary'
9413    which is not less than the value itself.  */
9414
9415 static inline HOST_WIDE_INT
9416 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9417 {
9418   return (((value + boundary - 1) / boundary) * boundary);
9419 }
9420
9421 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9422    pointer to the declared type for the relevant field variable, or return
9423    `integer_type_node' if the given node turns out to be an
9424    ERROR_MARK node.  */
9425
9426 static inline tree
9427 field_type (tree decl)
9428 {
9429   tree type;
9430
9431   if (TREE_CODE (decl) == ERROR_MARK)
9432     return integer_type_node;
9433
9434   type = DECL_BIT_FIELD_TYPE (decl);
9435   if (type == NULL_TREE)
9436     type = TREE_TYPE (decl);
9437
9438   return type;
9439 }
9440
9441 /* Given a pointer to a tree node, return the alignment in bits for
9442    it, or else return BITS_PER_WORD if the node actually turns out to
9443    be an ERROR_MARK node.  */
9444
9445 static inline unsigned
9446 simple_type_align_in_bits (tree type)
9447 {
9448   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9449 }
9450
9451 static inline unsigned
9452 simple_decl_align_in_bits (tree decl)
9453 {
9454   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9455 }
9456
9457 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9458    lowest addressed byte of the "containing object" for the given FIELD_DECL,
9459    or return 0 if we are unable to determine what that offset is, either
9460    because the argument turns out to be a pointer to an ERROR_MARK node, or
9461    because the offset is actually variable.  (We can't handle the latter case
9462    just yet).  */
9463
9464 static HOST_WIDE_INT
9465 field_byte_offset (tree decl)
9466 {
9467   unsigned int type_align_in_bits;
9468   unsigned int decl_align_in_bits;
9469   unsigned HOST_WIDE_INT type_size_in_bits;
9470   HOST_WIDE_INT object_offset_in_bits;
9471   tree type;
9472   tree field_size_tree;
9473   HOST_WIDE_INT bitpos_int;
9474   HOST_WIDE_INT deepest_bitpos;
9475   unsigned HOST_WIDE_INT field_size_in_bits;
9476
9477   if (TREE_CODE (decl) == ERROR_MARK)
9478     return 0;
9479
9480   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9481
9482   type = field_type (decl);
9483   field_size_tree = DECL_SIZE (decl);
9484
9485   /* The size could be unspecified if there was an error, or for
9486      a flexible array member.  */
9487   if (! field_size_tree)
9488     field_size_tree = bitsize_zero_node;
9489
9490   /* We cannot yet cope with fields whose positions are variable, so
9491      for now, when we see such things, we simply return 0.  Someday, we may
9492      be able to handle such cases, but it will be damn difficult.  */
9493   if (! host_integerp (bit_position (decl), 0))
9494     return 0;
9495
9496   bitpos_int = int_bit_position (decl);
9497
9498   /* If we don't know the size of the field, pretend it's a full word.  */
9499   if (host_integerp (field_size_tree, 1))
9500     field_size_in_bits = tree_low_cst (field_size_tree, 1);
9501   else
9502     field_size_in_bits = BITS_PER_WORD;
9503
9504   type_size_in_bits = simple_type_size_in_bits (type);
9505   type_align_in_bits = simple_type_align_in_bits (type);
9506   decl_align_in_bits = simple_decl_align_in_bits (decl);
9507
9508   /* The GCC front-end doesn't make any attempt to keep track of the starting
9509      bit offset (relative to the start of the containing structure type) of the
9510      hypothetical "containing object" for a bit-field.  Thus, when computing
9511      the byte offset value for the start of the "containing object" of a
9512      bit-field, we must deduce this information on our own. This can be rather
9513      tricky to do in some cases.  For example, handling the following structure
9514      type definition when compiling for an i386/i486 target (which only aligns
9515      long long's to 32-bit boundaries) can be very tricky:
9516
9517          struct S { int field1; long long field2:31; };
9518
9519      Fortunately, there is a simple rule-of-thumb which can be used in such
9520      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
9521      structure shown above.  It decides to do this based upon one simple rule
9522      for bit-field allocation.  GCC allocates each "containing object" for each
9523      bit-field at the first (i.e. lowest addressed) legitimate alignment
9524      boundary (based upon the required minimum alignment for the declared type
9525      of the field) which it can possibly use, subject to the condition that
9526      there is still enough available space remaining in the containing object
9527      (when allocated at the selected point) to fully accommodate all of the
9528      bits of the bit-field itself.
9529
9530      This simple rule makes it obvious why GCC allocates 8 bytes for each
9531      object of the structure type shown above.  When looking for a place to
9532      allocate the "containing object" for `field2', the compiler simply tries
9533      to allocate a 64-bit "containing object" at each successive 32-bit
9534      boundary (starting at zero) until it finds a place to allocate that 64-
9535      bit field such that at least 31 contiguous (and previously unallocated)
9536      bits remain within that selected 64 bit field.  (As it turns out, for the
9537      example above, the compiler finds it is OK to allocate the "containing
9538      object" 64-bit field at bit-offset zero within the structure type.)
9539
9540      Here we attempt to work backwards from the limited set of facts we're
9541      given, and we try to deduce from those facts, where GCC must have believed
9542      that the containing object started (within the structure type). The value
9543      we deduce is then used (by the callers of this routine) to generate
9544      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9545      and, in the case of DW_AT_location, regular fields as well).  */
9546
9547   /* Figure out the bit-distance from the start of the structure to the
9548      "deepest" bit of the bit-field.  */
9549   deepest_bitpos = bitpos_int + field_size_in_bits;
9550
9551   /* This is the tricky part.  Use some fancy footwork to deduce where the
9552      lowest addressed bit of the containing object must be.  */
9553   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9554
9555   /* Round up to type_align by default.  This works best for bitfields.  */
9556   object_offset_in_bits += type_align_in_bits - 1;
9557   object_offset_in_bits /= type_align_in_bits;
9558   object_offset_in_bits *= type_align_in_bits;
9559
9560   if (object_offset_in_bits > bitpos_int)
9561     {
9562       /* Sigh, the decl must be packed.  */
9563       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9564
9565       /* Round up to decl_align instead.  */
9566       object_offset_in_bits += decl_align_in_bits - 1;
9567       object_offset_in_bits /= decl_align_in_bits;
9568       object_offset_in_bits *= decl_align_in_bits;
9569     }
9570
9571   return object_offset_in_bits / BITS_PER_UNIT;
9572 }
9573 \f
9574 /* The following routines define various Dwarf attributes and any data
9575    associated with them.  */
9576
9577 /* Add a location description attribute value to a DIE.
9578
9579    This emits location attributes suitable for whole variables and
9580    whole parameters.  Note that the location attributes for struct fields are
9581    generated by the routine `data_member_location_attribute' below.  */
9582
9583 static inline void
9584 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9585                              dw_loc_descr_ref descr)
9586 {
9587   if (descr != 0)
9588     add_AT_loc (die, attr_kind, descr);
9589 }
9590
9591 /* Attach the specialized form of location attribute used for data members of
9592    struct and union types.  In the special case of a FIELD_DECL node which
9593    represents a bit-field, the "offset" part of this special location
9594    descriptor must indicate the distance in bytes from the lowest-addressed
9595    byte of the containing struct or union type to the lowest-addressed byte of
9596    the "containing object" for the bit-field.  (See the `field_byte_offset'
9597    function above).
9598
9599    For any given bit-field, the "containing object" is a hypothetical object
9600    (of some integral or enum type) within which the given bit-field lives.  The
9601    type of this hypothetical "containing object" is always the same as the
9602    declared type of the individual bit-field itself (for GCC anyway... the
9603    DWARF spec doesn't actually mandate this).  Note that it is the size (in
9604    bytes) of the hypothetical "containing object" which will be given in the
9605    DW_AT_byte_size attribute for this bit-field.  (See the
9606    `byte_size_attribute' function below.)  It is also used when calculating the
9607    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
9608    function below.)  */
9609
9610 static void
9611 add_data_member_location_attribute (dw_die_ref die, tree decl)
9612 {
9613   HOST_WIDE_INT offset;
9614   dw_loc_descr_ref loc_descr = 0;
9615
9616   if (TREE_CODE (decl) == TREE_BINFO)
9617     {
9618       /* We're working on the TAG_inheritance for a base class.  */
9619       if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9620         {
9621           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9622              aren't at a fixed offset from all (sub)objects of the same
9623              type.  We need to extract the appropriate offset from our
9624              vtable.  The following dwarf expression means
9625
9626                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9627
9628              This is specific to the V3 ABI, of course.  */
9629
9630           dw_loc_descr_ref tmp;
9631
9632           /* Make a copy of the object address.  */
9633           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9634           add_loc_descr (&loc_descr, tmp);
9635
9636           /* Extract the vtable address.  */
9637           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9638           add_loc_descr (&loc_descr, tmp);
9639
9640           /* Calculate the address of the offset.  */
9641           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9642           gcc_assert (offset < 0);
9643
9644           tmp = int_loc_descriptor (-offset);
9645           add_loc_descr (&loc_descr, tmp);
9646           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9647           add_loc_descr (&loc_descr, tmp);
9648
9649           /* Extract the offset.  */
9650           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9651           add_loc_descr (&loc_descr, tmp);
9652
9653           /* Add it to the object address.  */
9654           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9655           add_loc_descr (&loc_descr, tmp);
9656         }
9657       else
9658         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9659     }
9660   else
9661     offset = field_byte_offset (decl);
9662
9663   if (! loc_descr)
9664     {
9665       enum dwarf_location_atom op;
9666
9667       /* The DWARF2 standard says that we should assume that the structure
9668          address is already on the stack, so we can specify a structure field
9669          address by using DW_OP_plus_uconst.  */
9670
9671 #ifdef MIPS_DEBUGGING_INFO
9672       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9673          operator correctly.  It works only if we leave the offset on the
9674          stack.  */
9675       op = DW_OP_constu;
9676 #else
9677       op = DW_OP_plus_uconst;
9678 #endif
9679
9680       loc_descr = new_loc_descr (op, offset, 0);
9681     }
9682
9683   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9684 }
9685
9686 /* Writes integer values to dw_vec_const array.  */
9687
9688 static void
9689 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9690 {
9691   while (size != 0)
9692     {
9693       *dest++ = val & 0xff;
9694       val >>= 8;
9695       --size;
9696     }
9697 }
9698
9699 /* Reads integers from dw_vec_const array.  Inverse of insert_int.  */
9700
9701 static HOST_WIDE_INT
9702 extract_int (const unsigned char *src, unsigned int size)
9703 {
9704   HOST_WIDE_INT val = 0;
9705
9706   src += size;
9707   while (size != 0)
9708     {
9709       val <<= 8;
9710       val |= *--src & 0xff;
9711       --size;
9712     }
9713   return val;
9714 }
9715
9716 /* Writes floating point values to dw_vec_const array.  */
9717
9718 static void
9719 insert_float (rtx rtl, unsigned char *array)
9720 {
9721   REAL_VALUE_TYPE rv;
9722   long val[4];
9723   int i;
9724
9725   REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9726   real_to_target (val, &rv, GET_MODE (rtl));
9727
9728   /* real_to_target puts 32-bit pieces in each long.  Pack them.  */
9729   for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9730     {
9731       insert_int (val[i], 4, array);
9732       array += 4;
9733     }
9734 }
9735
9736 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9737    does not have a "location" either in memory or in a register.  These
9738    things can arise in GNU C when a constant is passed as an actual parameter
9739    to an inlined function.  They can also arise in C++ where declared
9740    constants do not necessarily get memory "homes".  */
9741
9742 static void
9743 add_const_value_attribute (dw_die_ref die, rtx rtl)
9744 {
9745   switch (GET_CODE (rtl))
9746     {
9747     case CONST_INT:
9748       {
9749         HOST_WIDE_INT val = INTVAL (rtl);
9750
9751         if (val < 0)
9752           add_AT_int (die, DW_AT_const_value, val);
9753         else
9754           add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9755       }
9756       break;
9757
9758     case CONST_DOUBLE:
9759       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9760          floating-point constant.  A CONST_DOUBLE is used whenever the
9761          constant requires more than one word in order to be adequately
9762          represented.  We output CONST_DOUBLEs as blocks.  */
9763       {
9764         enum machine_mode mode = GET_MODE (rtl);
9765
9766         if (SCALAR_FLOAT_MODE_P (mode))
9767           {
9768             unsigned int length = GET_MODE_SIZE (mode);
9769             unsigned char *array = ggc_alloc (length);
9770
9771             insert_float (rtl, array);
9772             add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9773           }
9774         else
9775           {
9776             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9777             gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9778
9779             add_AT_long_long (die, DW_AT_const_value,
9780                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9781           }
9782       }
9783       break;
9784
9785     case CONST_VECTOR:
9786       {
9787         enum machine_mode mode = GET_MODE (rtl);
9788         unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9789         unsigned int length = CONST_VECTOR_NUNITS (rtl);
9790         unsigned char *array = ggc_alloc (length * elt_size);
9791         unsigned int i;
9792         unsigned char *p;
9793
9794         switch (GET_MODE_CLASS (mode))
9795           {
9796           case MODE_VECTOR_INT:
9797             for (i = 0, p = array; i < length; i++, p += elt_size)
9798               {
9799                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9800                 HOST_WIDE_INT lo, hi;
9801
9802                 switch (GET_CODE (elt))
9803                   {
9804                   case CONST_INT:
9805                     lo = INTVAL (elt);
9806                     hi = -(lo < 0);
9807                     break;
9808
9809                   case CONST_DOUBLE:
9810                     lo = CONST_DOUBLE_LOW (elt);
9811                     hi = CONST_DOUBLE_HIGH (elt);
9812                     break;
9813
9814                   default:
9815                     gcc_unreachable ();
9816                   }
9817
9818                 if (elt_size <= sizeof (HOST_WIDE_INT))
9819                   insert_int (lo, elt_size, p);
9820                 else
9821                   {
9822                     unsigned char *p0 = p;
9823                     unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9824
9825                     gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9826                     if (WORDS_BIG_ENDIAN)
9827                       {
9828                         p0 = p1;
9829                         p1 = p;
9830                       }
9831                     insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9832                     insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9833                   }
9834               }
9835             break;
9836
9837           case MODE_VECTOR_FLOAT:
9838             for (i = 0, p = array; i < length; i++, p += elt_size)
9839               {
9840                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9841                 insert_float (elt, p);
9842               }
9843             break;
9844
9845           default:
9846             gcc_unreachable ();
9847           }
9848
9849         add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
9850       }
9851       break;
9852
9853     case CONST_STRING:
9854       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9855       break;
9856
9857     case SYMBOL_REF:
9858     case LABEL_REF:
9859     case CONST:
9860       add_AT_addr (die, DW_AT_const_value, rtl);
9861       VEC_safe_push (rtx, gc, used_rtx_array, rtl);
9862       break;
9863
9864     case PLUS:
9865       /* In cases where an inlined instance of an inline function is passed
9866          the address of an `auto' variable (which is local to the caller) we
9867          can get a situation where the DECL_RTL of the artificial local
9868          variable (for the inlining) which acts as a stand-in for the
9869          corresponding formal parameter (of the inline function) will look
9870          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
9871          exactly a compile-time constant expression, but it isn't the address
9872          of the (artificial) local variable either.  Rather, it represents the
9873          *value* which the artificial local variable always has during its
9874          lifetime.  We currently have no way to represent such quasi-constant
9875          values in Dwarf, so for now we just punt and generate nothing.  */
9876       break;
9877
9878     default:
9879       /* No other kinds of rtx should be possible here.  */
9880       gcc_unreachable ();
9881     }
9882
9883 }
9884
9885 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
9886    for use in a later add_const_value_attribute call.  */
9887
9888 static rtx
9889 rtl_for_decl_init (tree init, tree type)
9890 {
9891   rtx rtl = NULL_RTX;
9892
9893   /* If a variable is initialized with a string constant without embedded
9894      zeros, build CONST_STRING.  */
9895   if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
9896     {
9897       tree enttype = TREE_TYPE (type);
9898       tree domain = TYPE_DOMAIN (type);
9899       enum machine_mode mode = TYPE_MODE (enttype);
9900
9901       if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9902           && domain
9903           && integer_zerop (TYPE_MIN_VALUE (domain))
9904           && compare_tree_int (TYPE_MAX_VALUE (domain),
9905                                TREE_STRING_LENGTH (init) - 1) == 0
9906           && ((size_t) TREE_STRING_LENGTH (init)
9907               == strlen (TREE_STRING_POINTER (init)) + 1))
9908         rtl = gen_rtx_CONST_STRING (VOIDmode,
9909                                     ggc_strdup (TREE_STRING_POINTER (init)));
9910     }
9911   /* If the initializer is something that we know will expand into an
9912      immediate RTL constant, expand it now.  Expanding anything else
9913      tends to produce unresolved symbols; see debug/5770 and c++/6381.  */
9914   /* Aggregate, vector, and complex types may contain constructors that may
9915      result in code being generated when expand_expr is called, so we can't
9916      handle them here.  Integer and float are useful and safe types to handle
9917      here.  */
9918   else if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
9919            && initializer_constant_valid_p (init, type) == null_pointer_node)
9920     {
9921       rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
9922
9923       /* If expand_expr returns a MEM, it wasn't immediate.  */
9924       gcc_assert (!rtl || !MEM_P (rtl));
9925     }
9926
9927   return rtl;
9928 }
9929
9930 /* Generate RTL for the variable DECL to represent its location.  */
9931
9932 static rtx
9933 rtl_for_decl_location (tree decl)
9934 {
9935   rtx rtl;
9936
9937   /* Here we have to decide where we are going to say the parameter "lives"
9938      (as far as the debugger is concerned).  We only have a couple of
9939      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9940
9941      DECL_RTL normally indicates where the parameter lives during most of the
9942      activation of the function.  If optimization is enabled however, this
9943      could be either NULL or else a pseudo-reg.  Both of those cases indicate
9944      that the parameter doesn't really live anywhere (as far as the code
9945      generation parts of GCC are concerned) during most of the function's
9946      activation.  That will happen (for example) if the parameter is never
9947      referenced within the function.
9948
9949      We could just generate a location descriptor here for all non-NULL
9950      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9951      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9952      where DECL_RTL is NULL or is a pseudo-reg.
9953
9954      Note however that we can only get away with using DECL_INCOMING_RTL as
9955      a backup substitute for DECL_RTL in certain limited cases.  In cases
9956      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9957      we can be sure that the parameter was passed using the same type as it is
9958      declared to have within the function, and that its DECL_INCOMING_RTL
9959      points us to a place where a value of that type is passed.
9960
9961      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9962      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9963      because in these cases DECL_INCOMING_RTL points us to a value of some
9964      type which is *different* from the type of the parameter itself.  Thus,
9965      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9966      such cases, the debugger would end up (for example) trying to fetch a
9967      `float' from a place which actually contains the first part of a
9968      `double'.  That would lead to really incorrect and confusing
9969      output at debug-time.
9970
9971      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9972      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
9973      are a couple of exceptions however.  On little-endian machines we can
9974      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9975      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9976      an integral type that is smaller than TREE_TYPE (decl). These cases arise
9977      when (on a little-endian machine) a non-prototyped function has a
9978      parameter declared to be of type `short' or `char'.  In such cases,
9979      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9980      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9981      passed `int' value.  If the debugger then uses that address to fetch
9982      a `short' or a `char' (on a little-endian machine) the result will be
9983      the correct data, so we allow for such exceptional cases below.
9984
9985      Note that our goal here is to describe the place where the given formal
9986      parameter lives during most of the function's activation (i.e. between the
9987      end of the prologue and the start of the epilogue).  We'll do that as best
9988      as we can. Note however that if the given formal parameter is modified
9989      sometime during the execution of the function, then a stack backtrace (at
9990      debug-time) will show the function as having been called with the *new*
9991      value rather than the value which was originally passed in.  This happens
9992      rarely enough that it is not a major problem, but it *is* a problem, and
9993      I'd like to fix it.
9994
9995      A future version of dwarf2out.c may generate two additional attributes for
9996      any given DW_TAG_formal_parameter DIE which will describe the "passed
9997      type" and the "passed location" for the given formal parameter in addition
9998      to the attributes we now generate to indicate the "declared type" and the
9999      "active location" for each parameter.  This additional set of attributes
10000      could be used by debuggers for stack backtraces. Separately, note that
10001      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10002      This happens (for example) for inlined-instances of inline function formal
10003      parameters which are never referenced.  This really shouldn't be
10004      happening.  All PARM_DECL nodes should get valid non-NULL
10005      DECL_INCOMING_RTL values.  FIXME.  */
10006
10007   /* Use DECL_RTL as the "location" unless we find something better.  */
10008   rtl = DECL_RTL_IF_SET (decl);
10009
10010   /* When generating abstract instances, ignore everything except
10011      constants, symbols living in memory, and symbols living in
10012      fixed registers.  */
10013   if (! reload_completed)
10014     {
10015       if (rtl
10016           && (CONSTANT_P (rtl)
10017               || (MEM_P (rtl)
10018                   && CONSTANT_P (XEXP (rtl, 0)))
10019               || (REG_P (rtl)
10020                   && TREE_CODE (decl) == VAR_DECL
10021                   && TREE_STATIC (decl))))
10022         {
10023           rtl = targetm.delegitimize_address (rtl);
10024           return rtl;
10025         }
10026       rtl = NULL_RTX;
10027     }
10028   else if (TREE_CODE (decl) == PARM_DECL)
10029     {
10030       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10031         {
10032           tree declared_type = TREE_TYPE (decl);
10033           tree passed_type = DECL_ARG_TYPE (decl);
10034           enum machine_mode dmode = TYPE_MODE (declared_type);
10035           enum machine_mode pmode = TYPE_MODE (passed_type);
10036
10037           /* This decl represents a formal parameter which was optimized out.
10038              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10039              all cases where (rtl == NULL_RTX) just below.  */
10040           if (dmode == pmode)
10041             rtl = DECL_INCOMING_RTL (decl);
10042           else if (SCALAR_INT_MODE_P (dmode)
10043                    && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10044                    && DECL_INCOMING_RTL (decl))
10045             {
10046               rtx inc = DECL_INCOMING_RTL (decl);
10047               if (REG_P (inc))
10048                 rtl = inc;
10049               else if (MEM_P (inc))
10050                 {
10051                   if (BYTES_BIG_ENDIAN)
10052                     rtl = adjust_address_nv (inc, dmode,
10053                                              GET_MODE_SIZE (pmode)
10054                                              - GET_MODE_SIZE (dmode));
10055                   else
10056                     rtl = inc;
10057                 }
10058             }
10059         }
10060
10061       /* If the parm was passed in registers, but lives on the stack, then
10062          make a big endian correction if the mode of the type of the
10063          parameter is not the same as the mode of the rtl.  */
10064       /* ??? This is the same series of checks that are made in dbxout.c before
10065          we reach the big endian correction code there.  It isn't clear if all
10066          of these checks are necessary here, but keeping them all is the safe
10067          thing to do.  */
10068       else if (MEM_P (rtl)
10069                && XEXP (rtl, 0) != const0_rtx
10070                && ! CONSTANT_P (XEXP (rtl, 0))
10071                /* Not passed in memory.  */
10072                && !MEM_P (DECL_INCOMING_RTL (decl))
10073                /* Not passed by invisible reference.  */
10074                && (!REG_P (XEXP (rtl, 0))
10075                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10076                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10077 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10078                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10079 #endif
10080                      )
10081                /* Big endian correction check.  */
10082                && BYTES_BIG_ENDIAN
10083                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10084                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10085                    < UNITS_PER_WORD))
10086         {
10087           int offset = (UNITS_PER_WORD
10088                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10089
10090           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10091                              plus_constant (XEXP (rtl, 0), offset));
10092         }
10093     }
10094   else if (TREE_CODE (decl) == VAR_DECL
10095            && rtl
10096            && MEM_P (rtl)
10097            && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10098            && BYTES_BIG_ENDIAN)
10099     {
10100       int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10101       int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10102
10103       /* If a variable is declared "register" yet is smaller than
10104          a register, then if we store the variable to memory, it
10105          looks like we're storing a register-sized value, when in
10106          fact we are not.  We need to adjust the offset of the
10107          storage location to reflect the actual value's bytes,
10108          else gdb will not be able to display it.  */
10109       if (rsize > dsize)
10110         rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10111                            plus_constant (XEXP (rtl, 0), rsize-dsize));
10112     }
10113
10114   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10115      and will have been substituted directly into all expressions that use it.
10116      C does not have such a concept, but C++ and other languages do.  */
10117   if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10118     rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10119
10120   if (rtl)
10121     rtl = targetm.delegitimize_address (rtl);
10122
10123   /* If we don't look past the constant pool, we risk emitting a
10124      reference to a constant pool entry that isn't referenced from
10125      code, and thus is not emitted.  */
10126   if (rtl)
10127     rtl = avoid_constant_pool_reference (rtl);
10128
10129   return rtl;
10130 }
10131
10132 /* We need to figure out what section we should use as the base for the
10133    address ranges where a given location is valid.
10134    1. If this particular DECL has a section associated with it, use that.
10135    2. If this function has a section associated with it, use that.
10136    3. Otherwise, use the text section.
10137    XXX: If you split a variable across multiple sections, we won't notice.  */
10138
10139 static const char *
10140 secname_for_decl (tree decl)
10141 {
10142   const char *secname;
10143
10144   if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10145     {
10146       tree sectree = DECL_SECTION_NAME (decl);
10147       secname = TREE_STRING_POINTER (sectree);
10148     }
10149   else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10150     {
10151       tree sectree = DECL_SECTION_NAME (current_function_decl);
10152       secname = TREE_STRING_POINTER (sectree);
10153     }
10154   else if (cfun && in_cold_section_p)
10155     secname = cfun->cold_section_label;
10156   else
10157     secname = text_section_label;
10158
10159   return secname;
10160 }
10161
10162 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10163    data attribute for a variable or a parameter.  We generate the
10164    DW_AT_const_value attribute only in those cases where the given variable
10165    or parameter does not have a true "location" either in memory or in a
10166    register.  This can happen (for example) when a constant is passed as an
10167    actual argument in a call to an inline function.  (It's possible that
10168    these things can crop up in other ways also.)  Note that one type of
10169    constant value which can be passed into an inlined function is a constant
10170    pointer.  This can happen for example if an actual argument in an inlined
10171    function call evaluates to a compile-time constant address.  */
10172
10173 static void
10174 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10175                                        enum dwarf_attribute attr)
10176 {
10177   rtx rtl;
10178   dw_loc_descr_ref descr;
10179   var_loc_list *loc_list;
10180   struct var_loc_node *node;
10181   if (TREE_CODE (decl) == ERROR_MARK)
10182     return;
10183
10184   gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10185               || TREE_CODE (decl) == RESULT_DECL);
10186
10187   /* See if we possibly have multiple locations for this variable.  */
10188   loc_list = lookup_decl_loc (decl);
10189
10190   /* If it truly has multiple locations, the first and last node will
10191      differ.  */
10192   if (loc_list && loc_list->first != loc_list->last)
10193     {
10194       const char *endname, *secname;
10195       dw_loc_list_ref list;
10196       rtx varloc;
10197
10198       /* Now that we know what section we are using for a base,
10199          actually construct the list of locations.
10200          The first location information is what is passed to the
10201          function that creates the location list, and the remaining
10202          locations just get added on to that list.
10203          Note that we only know the start address for a location
10204          (IE location changes), so to build the range, we use
10205          the range [current location start, next location start].
10206          This means we have to special case the last node, and generate
10207          a range of [last location start, end of function label].  */
10208
10209       node = loc_list->first;
10210       varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10211       secname = secname_for_decl (decl);
10212
10213       list = new_loc_list (loc_descriptor (varloc),
10214                            node->label, node->next->label, secname, 1);
10215       node = node->next;
10216
10217       for (; node->next; node = node->next)
10218         if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10219           {
10220             /* The variable has a location between NODE->LABEL and
10221                NODE->NEXT->LABEL.  */
10222             varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10223             add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10224                                        node->label, node->next->label, secname);
10225           }
10226
10227       /* If the variable has a location at the last label
10228          it keeps its location until the end of function.  */
10229       if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10230         {
10231           char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10232
10233           varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10234           if (!current_function_decl)
10235             endname = text_end_label;
10236           else
10237             {
10238               ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10239                                            current_function_funcdef_no);
10240               endname = ggc_strdup (label_id);
10241             }
10242           add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10243                                      node->label, endname, secname);
10244         }
10245
10246       /* Finally, add the location list to the DIE, and we are done.  */
10247       add_AT_loc_list (die, attr, list);
10248       return;
10249     }
10250
10251   /* Try to get some constant RTL for this decl, and use that as the value of
10252      the location.  */
10253
10254   rtl = rtl_for_decl_location (decl);
10255   if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10256     {
10257       add_const_value_attribute (die, rtl);
10258       return;
10259     }
10260
10261   /* If we have tried to generate the location otherwise, and it
10262      didn't work out (we wouldn't be here if we did), and we have a one entry
10263      location list, try generating a location from that.  */
10264   if (loc_list && loc_list->first)
10265     {
10266       node = loc_list->first;
10267       descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10268       if (descr)
10269         {
10270           add_AT_location_description (die, attr, descr);
10271           return;
10272         }
10273     }
10274
10275   /* We couldn't get any rtl, so try directly generating the location
10276      description from the tree.  */
10277   descr = loc_descriptor_from_tree (decl);
10278   if (descr)
10279     {
10280       add_AT_location_description (die, attr, descr);
10281       return;
10282     }
10283 }
10284
10285 /* If we don't have a copy of this variable in memory for some reason (such
10286    as a C++ member constant that doesn't have an out-of-line definition),
10287    we should tell the debugger about the constant value.  */
10288
10289 static void
10290 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10291 {
10292   tree init = DECL_INITIAL (decl);
10293   tree type = TREE_TYPE (decl);
10294   rtx rtl;
10295
10296   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10297     /* OK */;
10298   else
10299     return;
10300
10301   rtl = rtl_for_decl_init (init, type);
10302   if (rtl)
10303     add_const_value_attribute (var_die, rtl);
10304 }
10305
10306 /* Convert the CFI instructions for the current function into a location
10307    list.  This is used for DW_AT_frame_base when we targeting a dwarf2
10308    consumer that does not support the dwarf3 DW_OP_call_frame_cfa.  */
10309
10310 static dw_loc_list_ref
10311 convert_cfa_to_loc_list (void)
10312 {
10313   dw_fde_ref fde;
10314   dw_loc_list_ref list, *list_tail;
10315   dw_cfi_ref cfi;
10316   dw_cfa_location last_cfa, next_cfa;
10317   const char *start_label, *last_label, *section;
10318
10319   fde = &fde_table[fde_table_in_use - 1];
10320
10321   section = secname_for_decl (current_function_decl);
10322   list_tail = &list;
10323   list = NULL;
10324
10325   next_cfa.reg = INVALID_REGNUM;
10326   next_cfa.offset = 0;
10327   next_cfa.indirect = 0;
10328   next_cfa.base_offset = 0;
10329
10330   start_label = fde->dw_fde_begin;
10331
10332   /* ??? Bald assumption that the CIE opcode list does not contain
10333      advance opcodes.  */
10334   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10335     lookup_cfa_1 (cfi, &next_cfa);
10336
10337   last_cfa = next_cfa;
10338   last_label = start_label;
10339
10340   for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10341     switch (cfi->dw_cfi_opc)
10342       {
10343       case DW_CFA_advance_loc1:
10344       case DW_CFA_advance_loc2:
10345       case DW_CFA_advance_loc4:
10346         if (!cfa_equal_p (&last_cfa, &next_cfa))
10347           {
10348             *list_tail = new_loc_list (build_cfa_loc (&last_cfa), start_label,
10349                                        last_label, section, list == NULL);
10350
10351             list_tail = &(*list_tail)->dw_loc_next;
10352             last_cfa = next_cfa;
10353             start_label = last_label;
10354           }
10355         last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10356         break;
10357
10358       case DW_CFA_advance_loc:
10359         /* The encoding is complex enough that we should never emit this.  */
10360       case DW_CFA_remember_state:
10361       case DW_CFA_restore_state:
10362         /* We don't handle these two in this function.  It would be possible
10363            if it were to be required.  */
10364         gcc_unreachable ();
10365
10366       default:
10367         lookup_cfa_1 (cfi, &next_cfa);
10368         break;
10369       }
10370
10371   if (!cfa_equal_p (&last_cfa, &next_cfa))
10372     {
10373       *list_tail = new_loc_list (build_cfa_loc (&last_cfa), start_label,
10374                                  last_label, section, list == NULL);
10375       list_tail = &(*list_tail)->dw_loc_next;
10376       start_label = last_label;
10377     }
10378   *list_tail = new_loc_list (build_cfa_loc (&next_cfa), start_label,
10379                              fde->dw_fde_end, section, list == NULL);
10380
10381   return list;
10382 }
10383
10384 /* Compute a displacement from the "steady-state frame pointer" to
10385    the CFA, and store it in frame_pointer_cfa_offset.  */
10386
10387 static void
10388 compute_frame_pointer_to_cfa_displacement (void)
10389 {
10390   HOST_WIDE_INT offset;
10391   rtx reg, elim;
10392
10393 #ifdef FRAME_POINTER_CFA_OFFSET
10394   reg = frame_pointer_rtx;
10395   offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10396 #else
10397   reg = arg_pointer_rtx;
10398   offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
10399 #endif
10400
10401   elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10402   if (GET_CODE (elim) == PLUS)
10403     {
10404       offset += INTVAL (XEXP (elim, 1));
10405       elim = XEXP (elim, 0);
10406     }
10407   gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10408                        : stack_pointer_rtx));
10409
10410   frame_pointer_cfa_offset = -offset;
10411 }
10412
10413 /* Generate a DW_AT_name attribute given some string value to be included as
10414    the value of the attribute.  */
10415
10416 static void
10417 add_name_attribute (dw_die_ref die, const char *name_string)
10418 {
10419   if (name_string != NULL && *name_string != 0)
10420     {
10421       if (demangle_name_func)
10422         name_string = (*demangle_name_func) (name_string);
10423
10424       add_AT_string (die, DW_AT_name, name_string);
10425     }
10426 }
10427
10428 /* Generate a DW_AT_comp_dir attribute for DIE.  */
10429
10430 static void
10431 add_comp_dir_attribute (dw_die_ref die)
10432 {
10433   const char *wd = get_src_pwd ();
10434   if (wd != NULL)
10435     add_AT_string (die, DW_AT_comp_dir, wd);
10436 }
10437
10438 /* Given a tree node describing an array bound (either lower or upper) output
10439    a representation for that bound.  */
10440
10441 static void
10442 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10443 {
10444   switch (TREE_CODE (bound))
10445     {
10446     case ERROR_MARK:
10447       return;
10448
10449     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
10450     case INTEGER_CST:
10451       if (! host_integerp (bound, 0)
10452           || (bound_attr == DW_AT_lower_bound
10453               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
10454                   || (is_fortran () && integer_onep (bound)))))
10455         /* Use the default.  */
10456         ;
10457       else
10458         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10459       break;
10460
10461     case CONVERT_EXPR:
10462     case NOP_EXPR:
10463     case NON_LVALUE_EXPR:
10464     case VIEW_CONVERT_EXPR:
10465       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10466       break;
10467
10468     case SAVE_EXPR:
10469       break;
10470
10471     case VAR_DECL:
10472     case PARM_DECL:
10473     case RESULT_DECL:
10474       {
10475         dw_die_ref decl_die = lookup_decl_die (bound);
10476
10477         /* ??? Can this happen, or should the variable have been bound
10478            first?  Probably it can, since I imagine that we try to create
10479            the types of parameters in the order in which they exist in
10480            the list, and won't have created a forward reference to a
10481            later parameter.  */
10482         if (decl_die != NULL)
10483           add_AT_die_ref (subrange_die, bound_attr, decl_die);
10484         break;
10485       }
10486
10487     default:
10488       {
10489         /* Otherwise try to create a stack operation procedure to
10490            evaluate the value of the array bound.  */
10491
10492         dw_die_ref ctx, decl_die;
10493         dw_loc_descr_ref loc;
10494
10495         loc = loc_descriptor_from_tree (bound);
10496         if (loc == NULL)
10497           break;
10498
10499         if (current_function_decl == 0)
10500           ctx = comp_unit_die;
10501         else
10502           ctx = lookup_decl_die (current_function_decl);
10503
10504         decl_die = new_die (DW_TAG_variable, ctx, bound);
10505         add_AT_flag (decl_die, DW_AT_artificial, 1);
10506         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10507         add_AT_loc (decl_die, DW_AT_location, loc);
10508
10509         add_AT_die_ref (subrange_die, bound_attr, decl_die);
10510         break;
10511       }
10512     }
10513 }
10514
10515 /* Note that the block of subscript information for an array type also
10516    includes information about the element type of type given array type.  */
10517
10518 static void
10519 add_subscript_info (dw_die_ref type_die, tree type)
10520 {
10521 #ifndef MIPS_DEBUGGING_INFO
10522   unsigned dimension_number;
10523 #endif
10524   tree lower, upper;
10525   dw_die_ref subrange_die;
10526
10527   /* The GNU compilers represent multidimensional array types as sequences of
10528      one dimensional array types whose element types are themselves array
10529      types.  Here we squish that down, so that each multidimensional array
10530      type gets only one array_type DIE in the Dwarf debugging info. The draft
10531      Dwarf specification say that we are allowed to do this kind of
10532      compression in C (because there is no difference between an array or
10533      arrays and a multidimensional array in C) but for other source languages
10534      (e.g. Ada) we probably shouldn't do this.  */
10535
10536   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10537      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10538      We work around this by disabling this feature.  See also
10539      gen_array_type_die.  */
10540 #ifndef MIPS_DEBUGGING_INFO
10541   for (dimension_number = 0;
10542        TREE_CODE (type) == ARRAY_TYPE;
10543        type = TREE_TYPE (type), dimension_number++)
10544 #endif
10545     {
10546       tree domain = TYPE_DOMAIN (type);
10547
10548       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10549          and (in GNU C only) variable bounds.  Handle all three forms
10550          here.  */
10551       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10552       if (domain)
10553         {
10554           /* We have an array type with specified bounds.  */
10555           lower = TYPE_MIN_VALUE (domain);
10556           upper = TYPE_MAX_VALUE (domain);
10557
10558           /* Define the index type.  */
10559           if (TREE_TYPE (domain))
10560             {
10561               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
10562                  TREE_TYPE field.  We can't emit debug info for this
10563                  because it is an unnamed integral type.  */
10564               if (TREE_CODE (domain) == INTEGER_TYPE
10565                   && TYPE_NAME (domain) == NULL_TREE
10566                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10567                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10568                 ;
10569               else
10570                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10571                                     type_die);
10572             }
10573
10574           /* ??? If upper is NULL, the array has unspecified length,
10575              but it does have a lower bound.  This happens with Fortran
10576                dimension arr(N:*)
10577              Since the debugger is definitely going to need to know N
10578              to produce useful results, go ahead and output the lower
10579              bound solo, and hope the debugger can cope.  */
10580
10581           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10582           if (upper)
10583             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10584         }
10585
10586       /* Otherwise we have an array type with an unspecified length.  The
10587          DWARF-2 spec does not say how to handle this; let's just leave out the
10588          bounds.  */
10589     }
10590 }
10591
10592 static void
10593 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10594 {
10595   unsigned size;
10596
10597   switch (TREE_CODE (tree_node))
10598     {
10599     case ERROR_MARK:
10600       size = 0;
10601       break;
10602     case ENUMERAL_TYPE:
10603     case RECORD_TYPE:
10604     case UNION_TYPE:
10605     case QUAL_UNION_TYPE:
10606       size = int_size_in_bytes (tree_node);
10607       break;
10608     case FIELD_DECL:
10609       /* For a data member of a struct or union, the DW_AT_byte_size is
10610          generally given as the number of bytes normally allocated for an
10611          object of the *declared* type of the member itself.  This is true
10612          even for bit-fields.  */
10613       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10614       break;
10615     default:
10616       gcc_unreachable ();
10617     }
10618
10619   /* Note that `size' might be -1 when we get to this point.  If it is, that
10620      indicates that the byte size of the entity in question is variable.  We
10621      have no good way of expressing this fact in Dwarf at the present time,
10622      so just let the -1 pass on through.  */
10623   add_AT_unsigned (die, DW_AT_byte_size, size);
10624 }
10625
10626 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10627    which specifies the distance in bits from the highest order bit of the
10628    "containing object" for the bit-field to the highest order bit of the
10629    bit-field itself.
10630
10631    For any given bit-field, the "containing object" is a hypothetical object
10632    (of some integral or enum type) within which the given bit-field lives.  The
10633    type of this hypothetical "containing object" is always the same as the
10634    declared type of the individual bit-field itself.  The determination of the
10635    exact location of the "containing object" for a bit-field is rather
10636    complicated.  It's handled by the `field_byte_offset' function (above).
10637
10638    Note that it is the size (in bytes) of the hypothetical "containing object"
10639    which will be given in the DW_AT_byte_size attribute for this bit-field.
10640    (See `byte_size_attribute' above).  */
10641
10642 static inline void
10643 add_bit_offset_attribute (dw_die_ref die, tree decl)
10644 {
10645   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10646   tree type = DECL_BIT_FIELD_TYPE (decl);
10647   HOST_WIDE_INT bitpos_int;
10648   HOST_WIDE_INT highest_order_object_bit_offset;
10649   HOST_WIDE_INT highest_order_field_bit_offset;
10650   HOST_WIDE_INT unsigned bit_offset;
10651
10652   /* Must be a field and a bit field.  */
10653   gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10654
10655   /* We can't yet handle bit-fields whose offsets are variable, so if we
10656      encounter such things, just return without generating any attribute
10657      whatsoever.  Likewise for variable or too large size.  */
10658   if (! host_integerp (bit_position (decl), 0)
10659       || ! host_integerp (DECL_SIZE (decl), 1))
10660     return;
10661
10662   bitpos_int = int_bit_position (decl);
10663
10664   /* Note that the bit offset is always the distance (in bits) from the
10665      highest-order bit of the "containing object" to the highest-order bit of
10666      the bit-field itself.  Since the "high-order end" of any object or field
10667      is different on big-endian and little-endian machines, the computation
10668      below must take account of these differences.  */
10669   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10670   highest_order_field_bit_offset = bitpos_int;
10671
10672   if (! BYTES_BIG_ENDIAN)
10673     {
10674       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10675       highest_order_object_bit_offset += simple_type_size_in_bits (type);
10676     }
10677
10678   bit_offset
10679     = (! BYTES_BIG_ENDIAN
10680        ? highest_order_object_bit_offset - highest_order_field_bit_offset
10681        : highest_order_field_bit_offset - highest_order_object_bit_offset);
10682
10683   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10684 }
10685
10686 /* For a FIELD_DECL node which represents a bit field, output an attribute
10687    which specifies the length in bits of the given field.  */
10688
10689 static inline void
10690 add_bit_size_attribute (dw_die_ref die, tree decl)
10691 {
10692   /* Must be a field and a bit field.  */
10693   gcc_assert (TREE_CODE (decl) == FIELD_DECL
10694               && DECL_BIT_FIELD_TYPE (decl));
10695
10696   if (host_integerp (DECL_SIZE (decl), 1))
10697     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10698 }
10699
10700 /* If the compiled language is ANSI C, then add a 'prototyped'
10701    attribute, if arg types are given for the parameters of a function.  */
10702
10703 static inline void
10704 add_prototyped_attribute (dw_die_ref die, tree func_type)
10705 {
10706   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10707       && TYPE_ARG_TYPES (func_type) != NULL)
10708     add_AT_flag (die, DW_AT_prototyped, 1);
10709 }
10710
10711 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
10712    by looking in either the type declaration or object declaration
10713    equate table.  */
10714
10715 static inline void
10716 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10717 {
10718   dw_die_ref origin_die = NULL;
10719
10720   if (TREE_CODE (origin) != FUNCTION_DECL)
10721     {
10722       /* We may have gotten separated from the block for the inlined
10723          function, if we're in an exception handler or some such; make
10724          sure that the abstract function has been written out.
10725
10726          Doing this for nested functions is wrong, however; functions are
10727          distinct units, and our context might not even be inline.  */
10728       tree fn = origin;
10729
10730       if (TYPE_P (fn))
10731         fn = TYPE_STUB_DECL (fn);
10732
10733       fn = decl_function_context (fn);
10734       if (fn)
10735         dwarf2out_abstract_function (fn);
10736     }
10737
10738   if (DECL_P (origin))
10739     origin_die = lookup_decl_die (origin);
10740   else if (TYPE_P (origin))
10741     origin_die = lookup_type_die (origin);
10742
10743   /* XXX: Functions that are never lowered don't always have correct block
10744      trees (in the case of java, they simply have no block tree, in some other
10745      languages).  For these functions, there is nothing we can really do to
10746      output correct debug info for inlined functions in all cases.  Rather
10747      than die, we'll just produce deficient debug info now, in that we will
10748      have variables without a proper abstract origin.  In the future, when all
10749      functions are lowered, we should re-add a gcc_assert (origin_die)
10750      here.  */
10751
10752   if (origin_die)
10753       add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10754 }
10755
10756 /* We do not currently support the pure_virtual attribute.  */
10757
10758 static inline void
10759 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10760 {
10761   if (DECL_VINDEX (func_decl))
10762     {
10763       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10764
10765       if (host_integerp (DECL_VINDEX (func_decl), 0))
10766         add_AT_loc (die, DW_AT_vtable_elem_location,
10767                     new_loc_descr (DW_OP_constu,
10768                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
10769                                    0));
10770
10771       /* GNU extension: Record what type this method came from originally.  */
10772       if (debug_info_level > DINFO_LEVEL_TERSE)
10773         add_AT_die_ref (die, DW_AT_containing_type,
10774                         lookup_type_die (DECL_CONTEXT (func_decl)));
10775     }
10776 }
10777 \f
10778 /* Add source coordinate attributes for the given decl.  */
10779
10780 static void
10781 add_src_coords_attributes (dw_die_ref die, tree decl)
10782 {
10783   expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
10784   unsigned file_index = lookup_filename (s.file);
10785
10786   add_AT_unsigned (die, DW_AT_decl_file, file_index);
10787   add_AT_unsigned (die, DW_AT_decl_line, s.line);
10788 }
10789
10790 /* Add a DW_AT_name attribute and source coordinate attribute for the
10791    given decl, but only if it actually has a name.  */
10792
10793 static void
10794 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
10795 {
10796   tree decl_name;
10797
10798   decl_name = DECL_NAME (decl);
10799   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10800     {
10801       add_name_attribute (die, dwarf2_name (decl, 0));
10802       if (! DECL_ARTIFICIAL (decl))
10803         add_src_coords_attributes (die, decl);
10804
10805       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10806           && TREE_PUBLIC (decl)
10807           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10808           && !DECL_ABSTRACT (decl)
10809           && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
10810         add_AT_string (die, DW_AT_MIPS_linkage_name,
10811                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10812     }
10813
10814 #ifdef VMS_DEBUGGING_INFO
10815   /* Get the function's name, as described by its RTL.  This may be different
10816      from the DECL_NAME name used in the source file.  */
10817   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10818     {
10819       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10820                    XEXP (DECL_RTL (decl), 0));
10821       VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
10822     }
10823 #endif
10824 }
10825
10826 /* Push a new declaration scope.  */
10827
10828 static void
10829 push_decl_scope (tree scope)
10830 {
10831   VEC_safe_push (tree, gc, decl_scope_table, scope);
10832 }
10833
10834 /* Pop a declaration scope.  */
10835
10836 static inline void
10837 pop_decl_scope (void)
10838 {
10839   VEC_pop (tree, decl_scope_table);
10840 }
10841
10842 /* Return the DIE for the scope that immediately contains this type.
10843    Non-named types get global scope.  Named types nested in other
10844    types get their containing scope if it's open, or global scope
10845    otherwise.  All other types (i.e. function-local named types) get
10846    the current active scope.  */
10847
10848 static dw_die_ref
10849 scope_die_for (tree t, dw_die_ref context_die)
10850 {
10851   dw_die_ref scope_die = NULL;
10852   tree containing_scope;
10853   int i;
10854
10855   /* Non-types always go in the current scope.  */
10856   gcc_assert (TYPE_P (t));
10857
10858   containing_scope = TYPE_CONTEXT (t);
10859
10860   /* Use the containing namespace if it was passed in (for a declaration).  */
10861   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
10862     {
10863       if (context_die == lookup_decl_die (containing_scope))
10864         /* OK */;
10865       else
10866         containing_scope = NULL_TREE;
10867     }
10868
10869   /* Ignore function type "scopes" from the C frontend.  They mean that
10870      a tagged type is local to a parmlist of a function declarator, but
10871      that isn't useful to DWARF.  */
10872   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
10873     containing_scope = NULL_TREE;
10874
10875   if (containing_scope == NULL_TREE)
10876     scope_die = comp_unit_die;
10877   else if (TYPE_P (containing_scope))
10878     {
10879       /* For types, we can just look up the appropriate DIE.  But
10880          first we check to see if we're in the middle of emitting it
10881          so we know where the new DIE should go.  */
10882       for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
10883         if (VEC_index (tree, decl_scope_table, i) == containing_scope)
10884           break;
10885
10886       if (i < 0)
10887         {
10888           gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
10889                       || TREE_ASM_WRITTEN (containing_scope));
10890
10891           /* If none of the current dies are suitable, we get file scope.  */
10892           scope_die = comp_unit_die;
10893         }
10894       else
10895         scope_die = lookup_type_die (containing_scope);
10896     }
10897   else
10898     scope_die = context_die;
10899
10900   return scope_die;
10901 }
10902
10903 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
10904
10905 static inline int
10906 local_scope_p (dw_die_ref context_die)
10907 {
10908   for (; context_die; context_die = context_die->die_parent)
10909     if (context_die->die_tag == DW_TAG_inlined_subroutine
10910         || context_die->die_tag == DW_TAG_subprogram)
10911       return 1;
10912
10913   return 0;
10914 }
10915
10916 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
10917    whether or not to treat a DIE in this context as a declaration.  */
10918
10919 static inline int
10920 class_or_namespace_scope_p (dw_die_ref context_die)
10921 {
10922   return (context_die
10923           && (context_die->die_tag == DW_TAG_structure_type
10924               || context_die->die_tag == DW_TAG_union_type
10925               || context_die->die_tag == DW_TAG_namespace));
10926 }
10927
10928 /* Many forms of DIEs require a "type description" attribute.  This
10929    routine locates the proper "type descriptor" die for the type given
10930    by 'type', and adds a DW_AT_type attribute below the given die.  */
10931
10932 static void
10933 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
10934                     int decl_volatile, dw_die_ref context_die)
10935 {
10936   enum tree_code code  = TREE_CODE (type);
10937   dw_die_ref type_die  = NULL;
10938
10939   /* ??? If this type is an unnamed subrange type of an integral or
10940      floating-point type, use the inner type.  This is because we have no
10941      support for unnamed types in base_type_die.  This can happen if this is
10942      an Ada subrange type.  Correct solution is emit a subrange type die.  */
10943   if ((code == INTEGER_TYPE || code == REAL_TYPE)
10944       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
10945     type = TREE_TYPE (type), code = TREE_CODE (type);
10946
10947   if (code == ERROR_MARK
10948       /* Handle a special case.  For functions whose return type is void, we
10949          generate *no* type attribute.  (Note that no object may have type
10950          `void', so this only applies to function return types).  */
10951       || code == VOID_TYPE)
10952     return;
10953
10954   type_die = modified_type_die (type,
10955                                 decl_const || TYPE_READONLY (type),
10956                                 decl_volatile || TYPE_VOLATILE (type),
10957                                 context_die);
10958
10959   if (type_die != NULL)
10960     add_AT_die_ref (object_die, DW_AT_type, type_die);
10961 }
10962
10963 /* Given an object die, add the calling convention attribute for the
10964    function call type.  */
10965 static void
10966 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
10967 {
10968   enum dwarf_calling_convention value = DW_CC_normal;
10969
10970   value = targetm.dwarf_calling_convention (type);
10971
10972   /* Only add the attribute if the backend requests it, and
10973      is not DW_CC_normal.  */
10974   if (value && (value != DW_CC_normal))
10975     add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
10976 }
10977
10978 /* Given a tree pointer to a struct, class, union, or enum type node, return
10979    a pointer to the (string) tag name for the given type, or zero if the type
10980    was declared without a tag.  */
10981
10982 static const char *
10983 type_tag (tree type)
10984 {
10985   const char *name = 0;
10986
10987   if (TYPE_NAME (type) != 0)
10988     {
10989       tree t = 0;
10990
10991       /* Find the IDENTIFIER_NODE for the type name.  */
10992       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
10993         t = TYPE_NAME (type);
10994
10995       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
10996          a TYPE_DECL node, regardless of whether or not a `typedef' was
10997          involved.  */
10998       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10999                && ! DECL_IGNORED_P (TYPE_NAME (type)))
11000         t = DECL_NAME (TYPE_NAME (type));
11001
11002       /* Now get the name as a string, or invent one.  */
11003       if (t != 0)
11004         name = IDENTIFIER_POINTER (t);
11005     }
11006
11007   return (name == 0 || *name == '\0') ? 0 : name;
11008 }
11009
11010 /* Return the type associated with a data member, make a special check
11011    for bit field types.  */
11012
11013 static inline tree
11014 member_declared_type (tree member)
11015 {
11016   return (DECL_BIT_FIELD_TYPE (member)
11017           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11018 }
11019
11020 /* Get the decl's label, as described by its RTL. This may be different
11021    from the DECL_NAME name used in the source file.  */
11022
11023 #if 0
11024 static const char *
11025 decl_start_label (tree decl)
11026 {
11027   rtx x;
11028   const char *fnname;
11029
11030   x = DECL_RTL (decl);
11031   gcc_assert (MEM_P (x));
11032
11033   x = XEXP (x, 0);
11034   gcc_assert (GET_CODE (x) == SYMBOL_REF);
11035
11036   fnname = XSTR (x, 0);
11037   return fnname;
11038 }
11039 #endif
11040 \f
11041 /* These routines generate the internal representation of the DIE's for
11042    the compilation unit.  Debugging information is collected by walking
11043    the declaration trees passed in from dwarf2out_decl().  */
11044
11045 static void
11046 gen_array_type_die (tree type, dw_die_ref context_die)
11047 {
11048   dw_die_ref scope_die = scope_die_for (type, context_die);
11049   dw_die_ref array_die;
11050   tree element_type;
11051
11052   /* ??? The SGI dwarf reader fails for array of array of enum types unless
11053      the inner array type comes before the outer array type.  Thus we must
11054      call gen_type_die before we call new_die.  See below also.  */
11055 #ifdef MIPS_DEBUGGING_INFO
11056   gen_type_die (TREE_TYPE (type), context_die);
11057 #endif
11058
11059   array_die = new_die (DW_TAG_array_type, scope_die, type);
11060   add_name_attribute (array_die, type_tag (type));
11061   equate_type_number_to_die (type, array_die);
11062
11063   if (TREE_CODE (type) == VECTOR_TYPE)
11064     {
11065       /* The frontend feeds us a representation for the vector as a struct
11066          containing an array.  Pull out the array type.  */
11067       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11068       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11069     }
11070
11071 #if 0
11072   /* We default the array ordering.  SDB will probably do
11073      the right things even if DW_AT_ordering is not present.  It's not even
11074      an issue until we start to get into multidimensional arrays anyway.  If
11075      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11076      then we'll have to put the DW_AT_ordering attribute back in.  (But if
11077      and when we find out that we need to put these in, we will only do so
11078      for multidimensional arrays.  */
11079   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11080 #endif
11081
11082 #ifdef MIPS_DEBUGGING_INFO
11083   /* The SGI compilers handle arrays of unknown bound by setting
11084      AT_declaration and not emitting any subrange DIEs.  */
11085   if (! TYPE_DOMAIN (type))
11086     add_AT_flag (array_die, DW_AT_declaration, 1);
11087   else
11088 #endif
11089     add_subscript_info (array_die, type);
11090
11091   /* Add representation of the type of the elements of this array type.  */
11092   element_type = TREE_TYPE (type);
11093
11094   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11095      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
11096      We work around this by disabling this feature.  See also
11097      add_subscript_info.  */
11098 #ifndef MIPS_DEBUGGING_INFO
11099   while (TREE_CODE (element_type) == ARRAY_TYPE)
11100     element_type = TREE_TYPE (element_type);
11101
11102   gen_type_die (element_type, context_die);
11103 #endif
11104
11105   add_type_attribute (array_die, element_type, 0, 0, context_die);
11106 }
11107
11108 #if 0
11109 static void
11110 gen_entry_point_die (tree decl, dw_die_ref context_die)
11111 {
11112   tree origin = decl_ultimate_origin (decl);
11113   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11114
11115   if (origin != NULL)
11116     add_abstract_origin_attribute (decl_die, origin);
11117   else
11118     {
11119       add_name_and_src_coords_attributes (decl_die, decl);
11120       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11121                           0, 0, context_die);
11122     }
11123
11124   if (DECL_ABSTRACT (decl))
11125     equate_decl_number_to_die (decl, decl_die);
11126   else
11127     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11128 }
11129 #endif
11130
11131 /* Walk through the list of incomplete types again, trying once more to
11132    emit full debugging info for them.  */
11133
11134 static void
11135 retry_incomplete_types (void)
11136 {
11137   int i;
11138
11139   for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11140     gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11141 }
11142
11143 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
11144
11145 static void
11146 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11147 {
11148   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11149
11150   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11151      be incomplete and such types are not marked.  */
11152   add_abstract_origin_attribute (type_die, type);
11153 }
11154
11155 /* Generate a DIE to represent an inlined instance of a structure type.  */
11156
11157 static void
11158 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11159 {
11160   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11161
11162   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11163      be incomplete and such types are not marked.  */
11164   add_abstract_origin_attribute (type_die, type);
11165 }
11166
11167 /* Generate a DIE to represent an inlined instance of a union type.  */
11168
11169 static void
11170 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11171 {
11172   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11173
11174   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11175      be incomplete and such types are not marked.  */
11176   add_abstract_origin_attribute (type_die, type);
11177 }
11178
11179 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
11180    include all of the information about the enumeration values also. Each
11181    enumerated type name/value is listed as a child of the enumerated type
11182    DIE.  */
11183
11184 static dw_die_ref
11185 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11186 {
11187   dw_die_ref type_die = lookup_type_die (type);
11188
11189   if (type_die == NULL)
11190     {
11191       type_die = new_die (DW_TAG_enumeration_type,
11192                           scope_die_for (type, context_die), type);
11193       equate_type_number_to_die (type, type_die);
11194       add_name_attribute (type_die, type_tag (type));
11195     }
11196   else if (! TYPE_SIZE (type))
11197     return type_die;
11198   else
11199     remove_AT (type_die, DW_AT_declaration);
11200
11201   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
11202      given enum type is incomplete, do not generate the DW_AT_byte_size
11203      attribute or the DW_AT_element_list attribute.  */
11204   if (TYPE_SIZE (type))
11205     {
11206       tree link;
11207
11208       TREE_ASM_WRITTEN (type) = 1;
11209       add_byte_size_attribute (type_die, type);
11210       if (TYPE_STUB_DECL (type) != NULL_TREE)
11211         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11212
11213       /* If the first reference to this type was as the return type of an
11214          inline function, then it may not have a parent.  Fix this now.  */
11215       if (type_die->die_parent == NULL)
11216         add_child_die (scope_die_for (type, context_die), type_die);
11217
11218       for (link = TYPE_VALUES (type);
11219            link != NULL; link = TREE_CHAIN (link))
11220         {
11221           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11222           tree value = TREE_VALUE (link);
11223
11224           add_name_attribute (enum_die,
11225                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11226
11227           if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11228             /* DWARF2 does not provide a way of indicating whether or
11229                not enumeration constants are signed or unsigned.  GDB
11230                always assumes the values are signed, so we output all
11231                values as if they were signed.  That means that
11232                enumeration constants with very large unsigned values
11233                will appear to have negative values in the debugger.  */
11234             add_AT_int (enum_die, DW_AT_const_value,
11235                         tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11236         }
11237     }
11238   else
11239     add_AT_flag (type_die, DW_AT_declaration, 1);
11240
11241   return type_die;
11242 }
11243
11244 /* Generate a DIE to represent either a real live formal parameter decl or to
11245    represent just the type of some formal parameter position in some function
11246    type.
11247
11248    Note that this routine is a bit unusual because its argument may be a
11249    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11250    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11251    node.  If it's the former then this function is being called to output a
11252    DIE to represent a formal parameter object (or some inlining thereof).  If
11253    it's the latter, then this function is only being called to output a
11254    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11255    argument type of some subprogram type.  */
11256
11257 static dw_die_ref
11258 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11259 {
11260   dw_die_ref parm_die
11261     = new_die (DW_TAG_formal_parameter, context_die, node);
11262   tree origin;
11263
11264   switch (TREE_CODE_CLASS (TREE_CODE (node)))
11265     {
11266     case tcc_declaration:
11267       origin = decl_ultimate_origin (node);
11268       if (origin != NULL)
11269         add_abstract_origin_attribute (parm_die, origin);
11270       else
11271         {
11272           add_name_and_src_coords_attributes (parm_die, node);
11273           add_type_attribute (parm_die, TREE_TYPE (node),
11274                               TREE_READONLY (node),
11275                               TREE_THIS_VOLATILE (node),
11276                               context_die);
11277           if (DECL_ARTIFICIAL (node))
11278             add_AT_flag (parm_die, DW_AT_artificial, 1);
11279         }
11280
11281       equate_decl_number_to_die (node, parm_die);
11282       if (! DECL_ABSTRACT (node))
11283         add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11284
11285       break;
11286
11287     case tcc_type:
11288       /* We were called with some kind of a ..._TYPE node.  */
11289       add_type_attribute (parm_die, node, 0, 0, context_die);
11290       break;
11291
11292     default:
11293       gcc_unreachable ();
11294     }
11295
11296   return parm_die;
11297 }
11298
11299 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11300    at the end of an (ANSI prototyped) formal parameters list.  */
11301
11302 static void
11303 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11304 {
11305   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11306 }
11307
11308 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11309    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11310    parameters as specified in some function type specification (except for
11311    those which appear as part of a function *definition*).  */
11312
11313 static void
11314 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11315 {
11316   tree link;
11317   tree formal_type = NULL;
11318   tree first_parm_type;
11319   tree arg;
11320
11321   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11322     {
11323       arg = DECL_ARGUMENTS (function_or_method_type);
11324       function_or_method_type = TREE_TYPE (function_or_method_type);
11325     }
11326   else
11327     arg = NULL_TREE;
11328
11329   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11330
11331   /* Make our first pass over the list of formal parameter types and output a
11332      DW_TAG_formal_parameter DIE for each one.  */
11333   for (link = first_parm_type; link; )
11334     {
11335       dw_die_ref parm_die;
11336
11337       formal_type = TREE_VALUE (link);
11338       if (formal_type == void_type_node)
11339         break;
11340
11341       /* Output a (nameless) DIE to represent the formal parameter itself.  */
11342       parm_die = gen_formal_parameter_die (formal_type, context_die);
11343       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11344            && link == first_parm_type)
11345           || (arg && DECL_ARTIFICIAL (arg)))
11346         add_AT_flag (parm_die, DW_AT_artificial, 1);
11347
11348       link = TREE_CHAIN (link);
11349       if (arg)
11350         arg = TREE_CHAIN (arg);
11351     }
11352
11353   /* If this function type has an ellipsis, add a
11354      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
11355   if (formal_type != void_type_node)
11356     gen_unspecified_parameters_die (function_or_method_type, context_die);
11357
11358   /* Make our second (and final) pass over the list of formal parameter types
11359      and output DIEs to represent those types (as necessary).  */
11360   for (link = TYPE_ARG_TYPES (function_or_method_type);
11361        link && TREE_VALUE (link);
11362        link = TREE_CHAIN (link))
11363     gen_type_die (TREE_VALUE (link), context_die);
11364 }
11365
11366 /* We want to generate the DIE for TYPE so that we can generate the
11367    die for MEMBER, which has been defined; we will need to refer back
11368    to the member declaration nested within TYPE.  If we're trying to
11369    generate minimal debug info for TYPE, processing TYPE won't do the
11370    trick; we need to attach the member declaration by hand.  */
11371
11372 static void
11373 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11374 {
11375   gen_type_die (type, context_die);
11376
11377   /* If we're trying to avoid duplicate debug info, we may not have
11378      emitted the member decl for this function.  Emit it now.  */
11379   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11380       && ! lookup_decl_die (member))
11381     {
11382       dw_die_ref type_die;
11383       gcc_assert (!decl_ultimate_origin (member));
11384
11385       push_decl_scope (type);
11386       type_die = lookup_type_die (type);
11387       if (TREE_CODE (member) == FUNCTION_DECL)
11388         gen_subprogram_die (member, type_die);
11389       else if (TREE_CODE (member) == FIELD_DECL)
11390         {
11391           /* Ignore the nameless fields that are used to skip bits but handle
11392              C++ anonymous unions and structs.  */
11393           if (DECL_NAME (member) != NULL_TREE
11394               || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11395               || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11396             {
11397               gen_type_die (member_declared_type (member), type_die);
11398               gen_field_die (member, type_die);
11399             }
11400         }
11401       else
11402         gen_variable_die (member, type_die);
11403
11404       pop_decl_scope ();
11405     }
11406 }
11407
11408 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11409    may later generate inlined and/or out-of-line instances of.  */
11410
11411 static void
11412 dwarf2out_abstract_function (tree decl)
11413 {
11414   dw_die_ref old_die;
11415   tree save_fn;
11416   tree context;
11417   int was_abstract = DECL_ABSTRACT (decl);
11418
11419   /* Make sure we have the actual abstract inline, not a clone.  */
11420   decl = DECL_ORIGIN (decl);
11421
11422   old_die = lookup_decl_die (decl);
11423   if (old_die && get_AT (old_die, DW_AT_inline))
11424     /* We've already generated the abstract instance.  */
11425     return;
11426
11427   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11428      we don't get confused by DECL_ABSTRACT.  */
11429   if (debug_info_level > DINFO_LEVEL_TERSE)
11430     {
11431       context = decl_class_context (decl);
11432       if (context)
11433         gen_type_die_for_member
11434           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11435     }
11436
11437   /* Pretend we've just finished compiling this function.  */
11438   save_fn = current_function_decl;
11439   current_function_decl = decl;
11440
11441   set_decl_abstract_flags (decl, 1);
11442   dwarf2out_decl (decl);
11443   if (! was_abstract)
11444     set_decl_abstract_flags (decl, 0);
11445
11446   current_function_decl = save_fn;
11447 }
11448
11449 /* Generate a DIE to represent a declared function (either file-scope or
11450    block-local).  */
11451
11452 static void
11453 gen_subprogram_die (tree decl, dw_die_ref context_die)
11454 {
11455   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11456   tree origin = decl_ultimate_origin (decl);
11457   dw_die_ref subr_die;
11458   tree fn_arg_types;
11459   tree outer_scope;
11460   dw_die_ref old_die = lookup_decl_die (decl);
11461   int declaration = (current_function_decl != decl
11462                      || class_or_namespace_scope_p (context_die));
11463
11464   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11465      started to generate the abstract instance of an inline, decided to output
11466      its containing class, and proceeded to emit the declaration of the inline
11467      from the member list for the class.  If so, DECLARATION takes priority;
11468      we'll get back to the abstract instance when done with the class.  */
11469
11470   /* The class-scope declaration DIE must be the primary DIE.  */
11471   if (origin && declaration && class_or_namespace_scope_p (context_die))
11472     {
11473       origin = NULL;
11474       gcc_assert (!old_die);
11475     }
11476
11477   /* Now that the C++ front end lazily declares artificial member fns, we
11478      might need to retrofit the declaration into its class.  */
11479   if (!declaration && !origin && !old_die
11480       && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11481       && !class_or_namespace_scope_p (context_die)
11482       && debug_info_level > DINFO_LEVEL_TERSE)
11483     old_die = force_decl_die (decl);
11484
11485   if (origin != NULL)
11486     {
11487       gcc_assert (!declaration || local_scope_p (context_die));
11488
11489       /* Fixup die_parent for the abstract instance of a nested
11490          inline function.  */
11491       if (old_die && old_die->die_parent == NULL)
11492         add_child_die (context_die, old_die);
11493
11494       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11495       add_abstract_origin_attribute (subr_die, origin);
11496     }
11497   else if (old_die)
11498     {
11499       expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11500       unsigned file_index = lookup_filename (s.file);
11501
11502       if (!get_AT_flag (old_die, DW_AT_declaration)
11503           /* We can have a normal definition following an inline one in the
11504              case of redefinition of GNU C extern inlines.
11505              It seems reasonable to use AT_specification in this case.  */
11506           && !get_AT (old_die, DW_AT_inline))
11507         {
11508           /* Detect and ignore this case, where we are trying to output
11509              something we have already output.  */
11510           return;
11511         }
11512
11513       /* If the definition comes from the same place as the declaration,
11514          maybe use the old DIE.  We always want the DIE for this function
11515          that has the *_pc attributes to be under comp_unit_die so the
11516          debugger can find it.  We also need to do this for abstract
11517          instances of inlines, since the spec requires the out-of-line copy
11518          to have the same parent.  For local class methods, this doesn't
11519          apply; we just use the old DIE.  */
11520       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11521           && (DECL_ARTIFICIAL (decl)
11522               || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
11523                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
11524                       == (unsigned) s.line))))
11525         {
11526           subr_die = old_die;
11527
11528           /* Clear out the declaration attribute and the formal parameters.
11529              Do not remove all children, because it is possible that this
11530              declaration die was forced using force_decl_die(). In such
11531              cases die that forced declaration die (e.g. TAG_imported_module)
11532              is one of the children that we do not want to remove.  */
11533           remove_AT (subr_die, DW_AT_declaration);
11534           remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11535         }
11536       else
11537         {
11538           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11539           add_AT_specification (subr_die, old_die);
11540           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11541             add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
11542           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11543               != (unsigned) s.line)
11544             add_AT_unsigned
11545               (subr_die, DW_AT_decl_line, s.line);
11546         }
11547     }
11548   else
11549     {
11550       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11551
11552       if (TREE_PUBLIC (decl))
11553         add_AT_flag (subr_die, DW_AT_external, 1);
11554
11555       add_name_and_src_coords_attributes (subr_die, decl);
11556       if (debug_info_level > DINFO_LEVEL_TERSE)
11557         {
11558           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11559           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11560                               0, 0, context_die);
11561         }
11562
11563       add_pure_or_virtual_attribute (subr_die, decl);
11564       if (DECL_ARTIFICIAL (decl))
11565         add_AT_flag (subr_die, DW_AT_artificial, 1);
11566
11567       if (TREE_PROTECTED (decl))
11568         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11569       else if (TREE_PRIVATE (decl))
11570         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11571     }
11572
11573   if (declaration)
11574     {
11575       if (!old_die || !get_AT (old_die, DW_AT_inline))
11576         {
11577           add_AT_flag (subr_die, DW_AT_declaration, 1);
11578
11579           /* The first time we see a member function, it is in the context of
11580              the class to which it belongs.  We make sure of this by emitting
11581              the class first.  The next time is the definition, which is
11582              handled above.  The two may come from the same source text.
11583
11584              Note that force_decl_die() forces function declaration die. It is
11585              later reused to represent definition.  */
11586           equate_decl_number_to_die (decl, subr_die);
11587         }
11588     }
11589   else if (DECL_ABSTRACT (decl))
11590     {
11591       if (DECL_DECLARED_INLINE_P (decl))
11592         {
11593           if (cgraph_function_possibly_inlined_p (decl))
11594             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11595           else
11596             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11597         }
11598       else
11599         {
11600           if (cgraph_function_possibly_inlined_p (decl))
11601             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11602           else
11603             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11604         }
11605
11606       equate_decl_number_to_die (decl, subr_die);
11607     }
11608   else if (!DECL_EXTERNAL (decl))
11609     {
11610       if (!old_die || !get_AT (old_die, DW_AT_inline))
11611         equate_decl_number_to_die (decl, subr_die);
11612
11613       if (!flag_reorder_blocks_and_partition)
11614         {
11615           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11616                                        current_function_funcdef_no);
11617           add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11618           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11619                                        current_function_funcdef_no);
11620           add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11621
11622           add_pubname (decl, subr_die);
11623           add_arange (decl, subr_die);
11624         }
11625       else
11626         {  /* Do nothing for now; maybe need to duplicate die, one for
11627               hot section and ond for cold section, then use the hot/cold
11628               section begin/end labels to generate the aranges...  */
11629           /*
11630             add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11631             add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11632             add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11633             add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11634
11635             add_pubname (decl, subr_die);
11636             add_arange (decl, subr_die);
11637             add_arange (decl, subr_die);
11638            */
11639         }
11640
11641 #ifdef MIPS_DEBUGGING_INFO
11642       /* Add a reference to the FDE for this routine.  */
11643       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11644 #endif
11645
11646       /* We define the "frame base" as the function's CFA.  This is more
11647          convenient for several reasons: (1) It's stable across the prologue
11648          and epilogue, which makes it better than just a frame pointer,
11649          (2) With dwarf3, there exists a one-byte encoding that allows us
11650          to reference the .debug_frame data by proxy, but failing that,
11651          (3) We can at least reuse the code inspection and interpretation
11652          code that determines the CFA position at various points in the
11653          function.  */
11654       /* ??? Use some command-line or configury switch to enable the use
11655          of dwarf3 DW_OP_call_frame_cfa.  At present there are no dwarf
11656          consumers that understand it; fall back to "pure" dwarf2 and
11657          convert the CFA data into a location list.  */
11658       {
11659         dw_loc_list_ref list = convert_cfa_to_loc_list ();
11660         if (list->dw_loc_next)
11661           add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11662         else
11663           add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11664       }
11665
11666       /* Compute a displacement from the "steady-state frame pointer" to
11667          the CFA.  The former is what all stack slots and argument slots
11668          will reference in the rtl; the later is what we've told the
11669          debugger about.  We'll need to adjust all frame_base references
11670          by this displacement.  */
11671       compute_frame_pointer_to_cfa_displacement ();
11672
11673       if (cfun->static_chain_decl)
11674         add_AT_location_description (subr_die, DW_AT_static_link,
11675                  loc_descriptor_from_tree (cfun->static_chain_decl));
11676     }
11677
11678   /* Now output descriptions of the arguments for this function. This gets
11679      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11680      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11681      `...' at the end of the formal parameter list.  In order to find out if
11682      there was a trailing ellipsis or not, we must instead look at the type
11683      associated with the FUNCTION_DECL.  This will be a node of type
11684      FUNCTION_TYPE. If the chain of type nodes hanging off of this
11685      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11686      an ellipsis at the end.  */
11687
11688   /* In the case where we are describing a mere function declaration, all we
11689      need to do here (and all we *can* do here) is to describe the *types* of
11690      its formal parameters.  */
11691   if (debug_info_level <= DINFO_LEVEL_TERSE)
11692     ;
11693   else if (declaration)
11694     gen_formal_types_die (decl, subr_die);
11695   else
11696     {
11697       /* Generate DIEs to represent all known formal parameters.  */
11698       tree arg_decls = DECL_ARGUMENTS (decl);
11699       tree parm;
11700
11701       /* When generating DIEs, generate the unspecified_parameters DIE
11702          instead if we come across the arg "__builtin_va_alist" */
11703       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11704         if (TREE_CODE (parm) == PARM_DECL)
11705           {
11706             if (DECL_NAME (parm)
11707                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11708                             "__builtin_va_alist"))
11709               gen_unspecified_parameters_die (parm, subr_die);
11710             else
11711               gen_decl_die (parm, subr_die);
11712           }
11713
11714       /* Decide whether we need an unspecified_parameters DIE at the end.
11715          There are 2 more cases to do this for: 1) the ansi ... declaration -
11716          this is detectable when the end of the arg list is not a
11717          void_type_node 2) an unprototyped function declaration (not a
11718          definition).  This just means that we have no info about the
11719          parameters at all.  */
11720       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11721       if (fn_arg_types != NULL)
11722         {
11723           /* This is the prototyped case, check for....  */
11724           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11725             gen_unspecified_parameters_die (decl, subr_die);
11726         }
11727       else if (DECL_INITIAL (decl) == NULL_TREE)
11728         gen_unspecified_parameters_die (decl, subr_die);
11729     }
11730
11731   /* Output Dwarf info for all of the stuff within the body of the function
11732      (if it has one - it may be just a declaration).  */
11733   outer_scope = DECL_INITIAL (decl);
11734
11735   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11736      a function.  This BLOCK actually represents the outermost binding contour
11737      for the function, i.e. the contour in which the function's formal
11738      parameters and labels get declared. Curiously, it appears that the front
11739      end doesn't actually put the PARM_DECL nodes for the current function onto
11740      the BLOCK_VARS list for this outer scope, but are strung off of the
11741      DECL_ARGUMENTS list for the function instead.
11742
11743      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11744      the LABEL_DECL nodes for the function however, and we output DWARF info
11745      for those in decls_for_scope.  Just within the `outer_scope' there will be
11746      a BLOCK node representing the function's outermost pair of curly braces,
11747      and any blocks used for the base and member initializers of a C++
11748      constructor function.  */
11749   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11750     {
11751       /* Emit a DW_TAG_variable DIE for a named return value.  */
11752       if (DECL_NAME (DECL_RESULT (decl)))
11753         gen_decl_die (DECL_RESULT (decl), subr_die);
11754
11755       current_function_has_inlines = 0;
11756       decls_for_scope (outer_scope, subr_die, 0);
11757
11758 #if 0 && defined (MIPS_DEBUGGING_INFO)
11759       if (current_function_has_inlines)
11760         {
11761           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11762           if (! comp_unit_has_inlines)
11763             {
11764               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11765               comp_unit_has_inlines = 1;
11766             }
11767         }
11768 #endif
11769     }
11770   /* Add the calling convention attribute if requested.  */
11771   add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
11772
11773 }
11774
11775 /* Generate a DIE to represent a declared data object.  */
11776
11777 static void
11778 gen_variable_die (tree decl, dw_die_ref context_die)
11779 {
11780   tree origin = decl_ultimate_origin (decl);
11781   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11782
11783   dw_die_ref old_die = lookup_decl_die (decl);
11784   int declaration = (DECL_EXTERNAL (decl)
11785                      /* If DECL is COMDAT and has not actually been
11786                         emitted, we cannot take its address; there
11787                         might end up being no definition anywhere in
11788                         the program.  For example, consider the C++
11789                         test case:
11790
11791                           template <class T>
11792                           struct S { static const int i = 7; };
11793
11794                           template <class T>
11795                           const int S<T>::i;
11796
11797                           int f() { return S<int>::i; }
11798
11799                         Here, S<int>::i is not DECL_EXTERNAL, but no
11800                         definition is required, so the compiler will
11801                         not emit a definition.  */
11802                      || (TREE_CODE (decl) == VAR_DECL
11803                          && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
11804                      || class_or_namespace_scope_p (context_die));
11805
11806   if (origin != NULL)
11807     add_abstract_origin_attribute (var_die, origin);
11808
11809   /* Loop unrolling can create multiple blocks that refer to the same
11810      static variable, so we must test for the DW_AT_declaration flag.
11811
11812      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11813      copy decls and set the DECL_ABSTRACT flag on them instead of
11814      sharing them.
11815
11816      ??? Duplicated blocks have been rewritten to use .debug_ranges.
11817
11818      ??? The declare_in_namespace support causes us to get two DIEs for one
11819      variable, both of which are declarations.  We want to avoid considering
11820      one to be a specification, so we must test that this DIE is not a
11821      declaration.  */
11822   else if (old_die && TREE_STATIC (decl) && ! declaration
11823            && get_AT_flag (old_die, DW_AT_declaration) == 1)
11824     {
11825       /* This is a definition of a C++ class level static.  */
11826       add_AT_specification (var_die, old_die);
11827       if (DECL_NAME (decl))
11828         {
11829           expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11830           unsigned file_index = lookup_filename (s.file);
11831
11832           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11833             add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
11834
11835           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11836               != (unsigned) s.line)
11837
11838             add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
11839         }
11840     }
11841   else
11842     {
11843       add_name_and_src_coords_attributes (var_die, decl);
11844       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
11845                           TREE_THIS_VOLATILE (decl), context_die);
11846
11847       if (TREE_PUBLIC (decl))
11848         add_AT_flag (var_die, DW_AT_external, 1);
11849
11850       if (DECL_ARTIFICIAL (decl))
11851         add_AT_flag (var_die, DW_AT_artificial, 1);
11852
11853       if (TREE_PROTECTED (decl))
11854         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
11855       else if (TREE_PRIVATE (decl))
11856         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
11857     }
11858
11859   if (declaration)
11860     add_AT_flag (var_die, DW_AT_declaration, 1);
11861
11862   if (DECL_ABSTRACT (decl) || declaration)
11863     equate_decl_number_to_die (decl, var_die);
11864
11865   if (! declaration && ! DECL_ABSTRACT (decl))
11866     {
11867       add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
11868       add_pubname (decl, var_die);
11869     }
11870   else
11871     tree_add_const_value_attribute (var_die, decl);
11872 }
11873
11874 /* Generate a DIE to represent a label identifier.  */
11875
11876 static void
11877 gen_label_die (tree decl, dw_die_ref context_die)
11878 {
11879   tree origin = decl_ultimate_origin (decl);
11880   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
11881   rtx insn;
11882   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11883
11884   if (origin != NULL)
11885     add_abstract_origin_attribute (lbl_die, origin);
11886   else
11887     add_name_and_src_coords_attributes (lbl_die, decl);
11888
11889   if (DECL_ABSTRACT (decl))
11890     equate_decl_number_to_die (decl, lbl_die);
11891   else
11892     {
11893       insn = DECL_RTL_IF_SET (decl);
11894
11895       /* Deleted labels are programmer specified labels which have been
11896          eliminated because of various optimizations.  We still emit them
11897          here so that it is possible to put breakpoints on them.  */
11898       if (insn
11899           && (LABEL_P (insn)
11900               || ((NOTE_P (insn)
11901                    && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
11902         {
11903           /* When optimization is enabled (via -O) some parts of the compiler
11904              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11905              represent source-level labels which were explicitly declared by
11906              the user.  This really shouldn't be happening though, so catch
11907              it if it ever does happen.  */
11908           gcc_assert (!INSN_DELETED_P (insn));
11909
11910           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
11911           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
11912         }
11913     }
11914 }
11915
11916 /* A helper function for gen_inlined_subroutine_die.  Add source coordinate
11917    attributes to the DIE for a block STMT, to describe where the inlined
11918    function was called from.  This is similar to add_src_coords_attributes.  */
11919
11920 static inline void
11921 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
11922 {
11923   expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
11924   unsigned file_index = lookup_filename (s.file);
11925
11926   add_AT_unsigned (die, DW_AT_call_file, file_index);
11927   add_AT_unsigned (die, DW_AT_call_line, s.line);
11928 }
11929
11930 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
11931    Add low_pc and high_pc attributes to the DIE for a block STMT.  */
11932
11933 static inline void
11934 add_high_low_attributes (tree stmt, dw_die_ref die)
11935 {
11936   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11937
11938   if (BLOCK_FRAGMENT_CHAIN (stmt))
11939     {
11940       tree chain;
11941
11942       add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
11943
11944       chain = BLOCK_FRAGMENT_CHAIN (stmt);
11945       do
11946         {
11947           add_ranges (chain);
11948           chain = BLOCK_FRAGMENT_CHAIN (chain);
11949         }
11950       while (chain);
11951       add_ranges (NULL);
11952     }
11953   else
11954     {
11955       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11956                                    BLOCK_NUMBER (stmt));
11957       add_AT_lbl_id (die, DW_AT_low_pc, label);
11958       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11959                                    BLOCK_NUMBER (stmt));
11960       add_AT_lbl_id (die, DW_AT_high_pc, label);
11961     }
11962 }
11963
11964 /* Generate a DIE for a lexical block.  */
11965
11966 static void
11967 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
11968 {
11969   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
11970
11971   if (! BLOCK_ABSTRACT (stmt))
11972     add_high_low_attributes (stmt, stmt_die);
11973
11974   decls_for_scope (stmt, stmt_die, depth);
11975 }
11976
11977 /* Generate a DIE for an inlined subprogram.  */
11978
11979 static void
11980 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
11981 {
11982   tree decl = block_ultimate_origin (stmt);
11983
11984   /* Emit info for the abstract instance first, if we haven't yet.  We
11985      must emit this even if the block is abstract, otherwise when we
11986      emit the block below (or elsewhere), we may end up trying to emit
11987      a die whose origin die hasn't been emitted, and crashing.  */
11988   dwarf2out_abstract_function (decl);
11989
11990   if (! BLOCK_ABSTRACT (stmt))
11991     {
11992       dw_die_ref subr_die
11993         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
11994
11995       add_abstract_origin_attribute (subr_die, decl);
11996       add_high_low_attributes (stmt, subr_die);
11997       add_call_src_coords_attributes (stmt, subr_die);
11998
11999       decls_for_scope (stmt, subr_die, depth);
12000       current_function_has_inlines = 1;
12001     }
12002   else
12003     /* We may get here if we're the outer block of function A that was
12004        inlined into function B that was inlined into function C.  When
12005        generating debugging info for C, dwarf2out_abstract_function(B)
12006        would mark all inlined blocks as abstract, including this one.
12007        So, we wouldn't (and shouldn't) expect labels to be generated
12008        for this one.  Instead, just emit debugging info for
12009        declarations within the block.  This is particularly important
12010        in the case of initializers of arguments passed from B to us:
12011        if they're statement expressions containing declarations, we
12012        wouldn't generate dies for their abstract variables, and then,
12013        when generating dies for the real variables, we'd die (pun
12014        intended :-)  */
12015     gen_lexical_block_die (stmt, context_die, depth);
12016 }
12017
12018 /* Generate a DIE for a field in a record, or structure.  */
12019
12020 static void
12021 gen_field_die (tree decl, dw_die_ref context_die)
12022 {
12023   dw_die_ref decl_die;
12024
12025   if (TREE_TYPE (decl) == error_mark_node)
12026     return;
12027
12028   decl_die = new_die (DW_TAG_member, context_die, decl);
12029   add_name_and_src_coords_attributes (decl_die, decl);
12030   add_type_attribute (decl_die, member_declared_type (decl),
12031                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12032                       context_die);
12033
12034   if (DECL_BIT_FIELD_TYPE (decl))
12035     {
12036       add_byte_size_attribute (decl_die, decl);
12037       add_bit_size_attribute (decl_die, decl);
12038       add_bit_offset_attribute (decl_die, decl);
12039     }
12040
12041   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12042     add_data_member_location_attribute (decl_die, decl);
12043
12044   if (DECL_ARTIFICIAL (decl))
12045     add_AT_flag (decl_die, DW_AT_artificial, 1);
12046
12047   if (TREE_PROTECTED (decl))
12048     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12049   else if (TREE_PRIVATE (decl))
12050     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12051
12052   /* Equate decl number to die, so that we can look up this decl later on.  */
12053   equate_decl_number_to_die (decl, decl_die);
12054 }
12055
12056 #if 0
12057 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12058    Use modified_type_die instead.
12059    We keep this code here just in case these types of DIEs may be needed to
12060    represent certain things in other languages (e.g. Pascal) someday.  */
12061
12062 static void
12063 gen_pointer_type_die (tree type, dw_die_ref context_die)
12064 {
12065   dw_die_ref ptr_die
12066     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12067
12068   equate_type_number_to_die (type, ptr_die);
12069   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12070   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12071 }
12072
12073 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12074    Use modified_type_die instead.
12075    We keep this code here just in case these types of DIEs may be needed to
12076    represent certain things in other languages (e.g. Pascal) someday.  */
12077
12078 static void
12079 gen_reference_type_die (tree type, dw_die_ref context_die)
12080 {
12081   dw_die_ref ref_die
12082     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12083
12084   equate_type_number_to_die (type, ref_die);
12085   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12086   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12087 }
12088 #endif
12089
12090 /* Generate a DIE for a pointer to a member type.  */
12091
12092 static void
12093 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12094 {
12095   dw_die_ref ptr_die
12096     = new_die (DW_TAG_ptr_to_member_type,
12097                scope_die_for (type, context_die), type);
12098
12099   equate_type_number_to_die (type, ptr_die);
12100   add_AT_die_ref (ptr_die, DW_AT_containing_type,
12101                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12102   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12103 }
12104
12105 /* Generate the DIE for the compilation unit.  */
12106
12107 static dw_die_ref
12108 gen_compile_unit_die (const char *filename)
12109 {
12110   dw_die_ref die;
12111   char producer[250];
12112   const char *language_string = lang_hooks.name;
12113   int language;
12114
12115   die = new_die (DW_TAG_compile_unit, NULL, NULL);
12116
12117   if (filename)
12118     {
12119       add_name_attribute (die, filename);
12120       /* Don't add cwd for <built-in>.  */
12121       if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
12122         add_comp_dir_attribute (die);
12123     }
12124
12125   sprintf (producer, "%s %s", language_string, version_string);
12126
12127 #ifdef MIPS_DEBUGGING_INFO
12128   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12129      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12130      not appear in the producer string, the debugger reaches the conclusion
12131      that the object file is stripped and has no debugging information.
12132      To get the MIPS/SGI debugger to believe that there is debugging
12133      information in the object file, we add a -g to the producer string.  */
12134   if (debug_info_level > DINFO_LEVEL_TERSE)
12135     strcat (producer, " -g");
12136 #endif
12137
12138   add_AT_string (die, DW_AT_producer, producer);
12139
12140   if (strcmp (language_string, "GNU C++") == 0)
12141     language = DW_LANG_C_plus_plus;
12142   else if (strcmp (language_string, "GNU Ada") == 0)
12143     language = DW_LANG_Ada95;
12144   else if (strcmp (language_string, "GNU F77") == 0)
12145     language = DW_LANG_Fortran77;
12146   else if (strcmp (language_string, "GNU F95") == 0)
12147     language = DW_LANG_Fortran95;
12148   else if (strcmp (language_string, "GNU Pascal") == 0)
12149     language = DW_LANG_Pascal83;
12150   else if (strcmp (language_string, "GNU Java") == 0)
12151     language = DW_LANG_Java;
12152   else
12153     language = DW_LANG_C89;
12154
12155   add_AT_unsigned (die, DW_AT_language, language);
12156   return die;
12157 }
12158
12159 /* Generate the DIE for a base class.  */
12160
12161 static void
12162 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12163 {
12164   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12165
12166   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12167   add_data_member_location_attribute (die, binfo);
12168
12169   if (BINFO_VIRTUAL_P (binfo))
12170     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12171
12172   if (access == access_public_node)
12173     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12174   else if (access == access_protected_node)
12175     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12176 }
12177
12178 /* Generate a DIE for a class member.  */
12179
12180 static void
12181 gen_member_die (tree type, dw_die_ref context_die)
12182 {
12183   tree member;
12184   tree binfo = TYPE_BINFO (type);
12185   dw_die_ref child;
12186
12187   /* If this is not an incomplete type, output descriptions of each of its
12188      members. Note that as we output the DIEs necessary to represent the
12189      members of this record or union type, we will also be trying to output
12190      DIEs to represent the *types* of those members. However the `type'
12191      function (above) will specifically avoid generating type DIEs for member
12192      types *within* the list of member DIEs for this (containing) type except
12193      for those types (of members) which are explicitly marked as also being
12194      members of this (containing) type themselves.  The g++ front- end can
12195      force any given type to be treated as a member of some other (containing)
12196      type by setting the TYPE_CONTEXT of the given (member) type to point to
12197      the TREE node representing the appropriate (containing) type.  */
12198
12199   /* First output info about the base classes.  */
12200   if (binfo)
12201     {
12202       VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12203       int i;
12204       tree base;
12205
12206       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12207         gen_inheritance_die (base,
12208                              (accesses ? VEC_index (tree, accesses, i)
12209                               : access_public_node), context_die);
12210     }
12211
12212   /* Now output info about the data members and type members.  */
12213   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12214     {
12215       /* If we thought we were generating minimal debug info for TYPE
12216          and then changed our minds, some of the member declarations
12217          may have already been defined.  Don't define them again, but
12218          do put them in the right order.  */
12219
12220       child = lookup_decl_die (member);
12221       if (child)
12222         splice_child_die (context_die, child);
12223       else
12224         gen_decl_die (member, context_die);
12225     }
12226
12227   /* Now output info about the function members (if any).  */
12228   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12229     {
12230       /* Don't include clones in the member list.  */
12231       if (DECL_ABSTRACT_ORIGIN (member))
12232         continue;
12233
12234       child = lookup_decl_die (member);
12235       if (child)
12236         splice_child_die (context_die, child);
12237       else
12238         gen_decl_die (member, context_die);
12239     }
12240 }
12241
12242 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
12243    is set, we pretend that the type was never defined, so we only get the
12244    member DIEs needed by later specification DIEs.  */
12245
12246 static void
12247 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12248 {
12249   dw_die_ref type_die = lookup_type_die (type);
12250   dw_die_ref scope_die = 0;
12251   int nested = 0;
12252   int complete = (TYPE_SIZE (type)
12253                   && (! TYPE_STUB_DECL (type)
12254                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12255   int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12256
12257   if (type_die && ! complete)
12258     return;
12259
12260   if (TYPE_CONTEXT (type) != NULL_TREE
12261       && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12262           || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12263     nested = 1;
12264
12265   scope_die = scope_die_for (type, context_die);
12266
12267   if (! type_die || (nested && scope_die == comp_unit_die))
12268     /* First occurrence of type or toplevel definition of nested class.  */
12269     {
12270       dw_die_ref old_die = type_die;
12271
12272       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12273                           ? DW_TAG_structure_type : DW_TAG_union_type,
12274                           scope_die, type);
12275       equate_type_number_to_die (type, type_die);
12276       if (old_die)
12277         add_AT_specification (type_die, old_die);
12278       else
12279         add_name_attribute (type_die, type_tag (type));
12280     }
12281   else
12282     remove_AT (type_die, DW_AT_declaration);
12283
12284   /* If this type has been completed, then give it a byte_size attribute and
12285      then give a list of members.  */
12286   if (complete && !ns_decl)
12287     {
12288       /* Prevent infinite recursion in cases where the type of some member of
12289          this type is expressed in terms of this type itself.  */
12290       TREE_ASM_WRITTEN (type) = 1;
12291       add_byte_size_attribute (type_die, type);
12292       if (TYPE_STUB_DECL (type) != NULL_TREE)
12293         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12294
12295       /* If the first reference to this type was as the return type of an
12296          inline function, then it may not have a parent.  Fix this now.  */
12297       if (type_die->die_parent == NULL)
12298         add_child_die (scope_die, type_die);
12299
12300       push_decl_scope (type);
12301       gen_member_die (type, type_die);
12302       pop_decl_scope ();
12303
12304       /* GNU extension: Record what type our vtable lives in.  */
12305       if (TYPE_VFIELD (type))
12306         {
12307           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12308
12309           gen_type_die (vtype, context_die);
12310           add_AT_die_ref (type_die, DW_AT_containing_type,
12311                           lookup_type_die (vtype));
12312         }
12313     }
12314   else
12315     {
12316       add_AT_flag (type_die, DW_AT_declaration, 1);
12317
12318       /* We don't need to do this for function-local types.  */
12319       if (TYPE_STUB_DECL (type)
12320           && ! decl_function_context (TYPE_STUB_DECL (type)))
12321         VEC_safe_push (tree, gc, incomplete_types, type);
12322     }
12323 }
12324
12325 /* Generate a DIE for a subroutine _type_.  */
12326
12327 static void
12328 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12329 {
12330   tree return_type = TREE_TYPE (type);
12331   dw_die_ref subr_die
12332     = new_die (DW_TAG_subroutine_type,
12333                scope_die_for (type, context_die), type);
12334
12335   equate_type_number_to_die (type, subr_die);
12336   add_prototyped_attribute (subr_die, type);
12337   add_type_attribute (subr_die, return_type, 0, 0, context_die);
12338   gen_formal_types_die (type, subr_die);
12339 }
12340
12341 /* Generate a DIE for a type definition.  */
12342
12343 static void
12344 gen_typedef_die (tree decl, dw_die_ref context_die)
12345 {
12346   dw_die_ref type_die;
12347   tree origin;
12348
12349   if (TREE_ASM_WRITTEN (decl))
12350     return;
12351
12352   TREE_ASM_WRITTEN (decl) = 1;
12353   type_die = new_die (DW_TAG_typedef, context_die, decl);
12354   origin = decl_ultimate_origin (decl);
12355   if (origin != NULL)
12356     add_abstract_origin_attribute (type_die, origin);
12357   else
12358     {
12359       tree type;
12360
12361       add_name_and_src_coords_attributes (type_die, decl);
12362       if (DECL_ORIGINAL_TYPE (decl))
12363         {
12364           type = DECL_ORIGINAL_TYPE (decl);
12365
12366           gcc_assert (type != TREE_TYPE (decl));
12367           equate_type_number_to_die (TREE_TYPE (decl), type_die);
12368         }
12369       else
12370         type = TREE_TYPE (decl);
12371
12372       add_type_attribute (type_die, type, TREE_READONLY (decl),
12373                           TREE_THIS_VOLATILE (decl), context_die);
12374     }
12375
12376   if (DECL_ABSTRACT (decl))
12377     equate_decl_number_to_die (decl, type_die);
12378 }
12379
12380 /* Generate a type description DIE.  */
12381
12382 static void
12383 gen_type_die (tree type, dw_die_ref context_die)
12384 {
12385   int need_pop;
12386
12387   if (type == NULL_TREE || type == error_mark_node)
12388     return;
12389
12390   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12391       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12392     {
12393       if (TREE_ASM_WRITTEN (type))
12394         return;
12395
12396       /* Prevent broken recursion; we can't hand off to the same type.  */
12397       gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12398
12399       TREE_ASM_WRITTEN (type) = 1;
12400       gen_decl_die (TYPE_NAME (type), context_die);
12401       return;
12402     }
12403
12404   /* We are going to output a DIE to represent the unqualified version
12405      of this type (i.e. without any const or volatile qualifiers) so
12406      get the main variant (i.e. the unqualified version) of this type
12407      now.  (Vectors are special because the debugging info is in the
12408      cloned type itself).  */
12409   if (TREE_CODE (type) != VECTOR_TYPE)
12410     type = type_main_variant (type);
12411
12412   if (TREE_ASM_WRITTEN (type))
12413     return;
12414
12415   switch (TREE_CODE (type))
12416     {
12417     case ERROR_MARK:
12418       break;
12419
12420     case POINTER_TYPE:
12421     case REFERENCE_TYPE:
12422       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
12423          ensures that the gen_type_die recursion will terminate even if the
12424          type is recursive.  Recursive types are possible in Ada.  */
12425       /* ??? We could perhaps do this for all types before the switch
12426          statement.  */
12427       TREE_ASM_WRITTEN (type) = 1;
12428
12429       /* For these types, all that is required is that we output a DIE (or a
12430          set of DIEs) to represent the "basis" type.  */
12431       gen_type_die (TREE_TYPE (type), context_die);
12432       break;
12433
12434     case OFFSET_TYPE:
12435       /* This code is used for C++ pointer-to-data-member types.
12436          Output a description of the relevant class type.  */
12437       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12438
12439       /* Output a description of the type of the object pointed to.  */
12440       gen_type_die (TREE_TYPE (type), context_die);
12441
12442       /* Now output a DIE to represent this pointer-to-data-member type
12443          itself.  */
12444       gen_ptr_to_mbr_type_die (type, context_die);
12445       break;
12446
12447     case FUNCTION_TYPE:
12448       /* Force out return type (in case it wasn't forced out already).  */
12449       gen_type_die (TREE_TYPE (type), context_die);
12450       gen_subroutine_type_die (type, context_die);
12451       break;
12452
12453     case METHOD_TYPE:
12454       /* Force out return type (in case it wasn't forced out already).  */
12455       gen_type_die (TREE_TYPE (type), context_die);
12456       gen_subroutine_type_die (type, context_die);
12457       break;
12458
12459     case ARRAY_TYPE:
12460       gen_array_type_die (type, context_die);
12461       break;
12462
12463     case VECTOR_TYPE:
12464       gen_array_type_die (type, context_die);
12465       break;
12466
12467     case ENUMERAL_TYPE:
12468     case RECORD_TYPE:
12469     case UNION_TYPE:
12470     case QUAL_UNION_TYPE:
12471       /* If this is a nested type whose containing class hasn't been written
12472          out yet, writing it out will cover this one, too.  This does not apply
12473          to instantiations of member class templates; they need to be added to
12474          the containing class as they are generated.  FIXME: This hurts the
12475          idea of combining type decls from multiple TUs, since we can't predict
12476          what set of template instantiations we'll get.  */
12477       if (TYPE_CONTEXT (type)
12478           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12479           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12480         {
12481           gen_type_die (TYPE_CONTEXT (type), context_die);
12482
12483           if (TREE_ASM_WRITTEN (type))
12484             return;
12485
12486           /* If that failed, attach ourselves to the stub.  */
12487           push_decl_scope (TYPE_CONTEXT (type));
12488           context_die = lookup_type_die (TYPE_CONTEXT (type));
12489           need_pop = 1;
12490         }
12491       else
12492         {
12493           declare_in_namespace (type, context_die);
12494           need_pop = 0;
12495         }
12496
12497       if (TREE_CODE (type) == ENUMERAL_TYPE)
12498         gen_enumeration_type_die (type, context_die);
12499       else
12500         gen_struct_or_union_type_die (type, context_die);
12501
12502       if (need_pop)
12503         pop_decl_scope ();
12504
12505       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12506          it up if it is ever completed.  gen_*_type_die will set it for us
12507          when appropriate.  */
12508       return;
12509
12510     case VOID_TYPE:
12511     case INTEGER_TYPE:
12512     case REAL_TYPE:
12513     case COMPLEX_TYPE:
12514     case BOOLEAN_TYPE:
12515       /* No DIEs needed for fundamental types.  */
12516       break;
12517
12518     case LANG_TYPE:
12519       /* No Dwarf representation currently defined.  */
12520       break;
12521
12522     default:
12523       gcc_unreachable ();
12524     }
12525
12526   TREE_ASM_WRITTEN (type) = 1;
12527 }
12528
12529 /* Generate a DIE for a tagged type instantiation.  */
12530
12531 static void
12532 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12533 {
12534   if (type == NULL_TREE || type == error_mark_node)
12535     return;
12536
12537   /* We are going to output a DIE to represent the unqualified version of
12538      this type (i.e. without any const or volatile qualifiers) so make sure
12539      that we have the main variant (i.e. the unqualified version) of this
12540      type now.  */
12541   gcc_assert (type == type_main_variant (type));
12542
12543   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12544      an instance of an unresolved type.  */
12545
12546   switch (TREE_CODE (type))
12547     {
12548     case ERROR_MARK:
12549       break;
12550
12551     case ENUMERAL_TYPE:
12552       gen_inlined_enumeration_type_die (type, context_die);
12553       break;
12554
12555     case RECORD_TYPE:
12556       gen_inlined_structure_type_die (type, context_die);
12557       break;
12558
12559     case UNION_TYPE:
12560     case QUAL_UNION_TYPE:
12561       gen_inlined_union_type_die (type, context_die);
12562       break;
12563
12564     default:
12565       gcc_unreachable ();
12566     }
12567 }
12568
12569 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12570    things which are local to the given block.  */
12571
12572 static void
12573 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12574 {
12575   int must_output_die = 0;
12576   tree origin;
12577   tree decl;
12578   enum tree_code origin_code;
12579
12580   /* Ignore blocks that are NULL.  */
12581   if (stmt == NULL_TREE)
12582     return;
12583
12584   /* If the block is one fragment of a non-contiguous block, do not
12585      process the variables, since they will have been done by the
12586      origin block.  Do process subblocks.  */
12587   if (BLOCK_FRAGMENT_ORIGIN (stmt))
12588     {
12589       tree sub;
12590
12591       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12592         gen_block_die (sub, context_die, depth + 1);
12593
12594       return;
12595     }
12596
12597   /* Determine the "ultimate origin" of this block.  This block may be an
12598      inlined instance of an inlined instance of inline function, so we have
12599      to trace all of the way back through the origin chain to find out what
12600      sort of node actually served as the original seed for the creation of
12601      the current block.  */
12602   origin = block_ultimate_origin (stmt);
12603   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12604
12605   /* Determine if we need to output any Dwarf DIEs at all to represent this
12606      block.  */
12607   if (origin_code == FUNCTION_DECL)
12608     /* The outer scopes for inlinings *must* always be represented.  We
12609        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
12610     must_output_die = 1;
12611   else
12612     {
12613       /* In the case where the current block represents an inlining of the
12614          "body block" of an inline function, we must *NOT* output any DIE for
12615          this block because we have already output a DIE to represent the whole
12616          inlined function scope and the "body block" of any function doesn't
12617          really represent a different scope according to ANSI C rules.  So we
12618          check here to make sure that this block does not represent a "body
12619          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
12620       if (! is_body_block (origin ? origin : stmt))
12621         {
12622           /* Determine if this block directly contains any "significant"
12623              local declarations which we will need to output DIEs for.  */
12624           if (debug_info_level > DINFO_LEVEL_TERSE)
12625             /* We are not in terse mode so *any* local declaration counts
12626                as being a "significant" one.  */
12627             must_output_die = (BLOCK_VARS (stmt) != NULL
12628                                && (TREE_USED (stmt)
12629                                    || TREE_ASM_WRITTEN (stmt)
12630                                    || BLOCK_ABSTRACT (stmt)));
12631           else
12632             /* We are in terse mode, so only local (nested) function
12633                definitions count as "significant" local declarations.  */
12634             for (decl = BLOCK_VARS (stmt);
12635                  decl != NULL; decl = TREE_CHAIN (decl))
12636               if (TREE_CODE (decl) == FUNCTION_DECL
12637                   && DECL_INITIAL (decl))
12638                 {
12639                   must_output_die = 1;
12640                   break;
12641                 }
12642         }
12643     }
12644
12645   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12646      DIE for any block which contains no significant local declarations at
12647      all.  Rather, in such cases we just call `decls_for_scope' so that any
12648      needed Dwarf info for any sub-blocks will get properly generated. Note
12649      that in terse mode, our definition of what constitutes a "significant"
12650      local declaration gets restricted to include only inlined function
12651      instances and local (nested) function definitions.  */
12652   if (must_output_die)
12653     {
12654       if (origin_code == FUNCTION_DECL)
12655         gen_inlined_subroutine_die (stmt, context_die, depth);
12656       else
12657         gen_lexical_block_die (stmt, context_die, depth);
12658     }
12659   else
12660     decls_for_scope (stmt, context_die, depth);
12661 }
12662
12663 /* Generate all of the decls declared within a given scope and (recursively)
12664    all of its sub-blocks.  */
12665
12666 static void
12667 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12668 {
12669   tree decl;
12670   tree subblocks;
12671
12672   /* Ignore NULL blocks.  */
12673   if (stmt == NULL_TREE)
12674     return;
12675
12676   if (TREE_USED (stmt))
12677     {
12678       /* Output the DIEs to represent all of the data objects and typedefs
12679          declared directly within this block but not within any nested
12680          sub-blocks.  Also, nested function and tag DIEs have been
12681          generated with a parent of NULL; fix that up now.  */
12682       for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12683         {
12684           dw_die_ref die;
12685
12686           if (TREE_CODE (decl) == FUNCTION_DECL)
12687             die = lookup_decl_die (decl);
12688           else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12689             die = lookup_type_die (TREE_TYPE (decl));
12690           else
12691             die = NULL;
12692
12693           if (die != NULL && die->die_parent == NULL)
12694             add_child_die (context_die, die);
12695           /* Do not produce debug information for static variables since
12696              these might be optimized out.  We are called for these later
12697              in cgraph_varpool_analyze_pending_decls. */
12698           if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12699             ;
12700           else
12701             gen_decl_die (decl, context_die);
12702         }
12703     }
12704
12705   /* If we're at -g1, we're not interested in subblocks.  */
12706   if (debug_info_level <= DINFO_LEVEL_TERSE)
12707     return;
12708
12709   /* Output the DIEs to represent all sub-blocks (and the items declared
12710      therein) of this block.  */
12711   for (subblocks = BLOCK_SUBBLOCKS (stmt);
12712        subblocks != NULL;
12713        subblocks = BLOCK_CHAIN (subblocks))
12714     gen_block_die (subblocks, context_die, depth + 1);
12715 }
12716
12717 /* Is this a typedef we can avoid emitting?  */
12718
12719 static inline int
12720 is_redundant_typedef (tree decl)
12721 {
12722   if (TYPE_DECL_IS_STUB (decl))
12723     return 1;
12724
12725   if (DECL_ARTIFICIAL (decl)
12726       && DECL_CONTEXT (decl)
12727       && is_tagged_type (DECL_CONTEXT (decl))
12728       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12729       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12730     /* Also ignore the artificial member typedef for the class name.  */
12731     return 1;
12732
12733   return 0;
12734 }
12735
12736 /* Returns the DIE for decl.  A DIE will always be returned.  */
12737
12738 static dw_die_ref
12739 force_decl_die (tree decl)
12740 {
12741   dw_die_ref decl_die;
12742   unsigned saved_external_flag;
12743   tree save_fn = NULL_TREE;
12744   decl_die = lookup_decl_die (decl);
12745   if (!decl_die)
12746     {
12747       dw_die_ref context_die;
12748       tree decl_context = DECL_CONTEXT (decl);
12749       if (decl_context)
12750         {
12751           /* Find die that represents this context.  */
12752           if (TYPE_P (decl_context))
12753             context_die = force_type_die (decl_context);
12754           else
12755             context_die = force_decl_die (decl_context);
12756         }
12757       else
12758         context_die = comp_unit_die;
12759
12760       decl_die = lookup_decl_die (decl);
12761       if (decl_die)
12762         return decl_die;
12763
12764       switch (TREE_CODE (decl))
12765         {
12766         case FUNCTION_DECL:
12767           /* Clear current_function_decl, so that gen_subprogram_die thinks
12768              that this is a declaration. At this point, we just want to force
12769              declaration die.  */
12770           save_fn = current_function_decl;
12771           current_function_decl = NULL_TREE;
12772           gen_subprogram_die (decl, context_die);
12773           current_function_decl = save_fn;
12774           break;
12775
12776         case VAR_DECL:
12777           /* Set external flag to force declaration die. Restore it after
12778            gen_decl_die() call.  */
12779           saved_external_flag = DECL_EXTERNAL (decl);
12780           DECL_EXTERNAL (decl) = 1;
12781           gen_decl_die (decl, context_die);
12782           DECL_EXTERNAL (decl) = saved_external_flag;
12783           break;
12784
12785         case NAMESPACE_DECL:
12786           dwarf2out_decl (decl);
12787           break;
12788
12789         default:
12790           gcc_unreachable ();
12791         }
12792
12793       /* We should be able to find the DIE now.  */
12794       if (!decl_die)
12795         decl_die = lookup_decl_die (decl);
12796       gcc_assert (decl_die);
12797     }
12798
12799   return decl_die;
12800 }
12801
12802 /* Returns the DIE for TYPE.  A DIE is always returned.  */
12803
12804 static dw_die_ref
12805 force_type_die (tree type)
12806 {
12807   dw_die_ref type_die;
12808
12809   type_die = lookup_type_die (type);
12810   if (!type_die)
12811     {
12812       dw_die_ref context_die;
12813       if (TYPE_CONTEXT (type))
12814         {
12815           if (TYPE_P (TYPE_CONTEXT (type)))
12816             context_die = force_type_die (TYPE_CONTEXT (type));
12817           else
12818             context_die = force_decl_die (TYPE_CONTEXT (type));
12819         }
12820       else
12821         context_die = comp_unit_die;
12822
12823       type_die = lookup_type_die (type);
12824       if (type_die)
12825         return type_die;
12826       gen_type_die (type, context_die);
12827       type_die = lookup_type_die (type);
12828       gcc_assert (type_die);
12829     }
12830   return type_die;
12831 }
12832
12833 /* Force out any required namespaces to be able to output DECL,
12834    and return the new context_die for it, if it's changed.  */
12835
12836 static dw_die_ref
12837 setup_namespace_context (tree thing, dw_die_ref context_die)
12838 {
12839   tree context = (DECL_P (thing)
12840                   ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
12841   if (context && TREE_CODE (context) == NAMESPACE_DECL)
12842     /* Force out the namespace.  */
12843     context_die = force_decl_die (context);
12844
12845   return context_die;
12846 }
12847
12848 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
12849    type) within its namespace, if appropriate.
12850
12851    For compatibility with older debuggers, namespace DIEs only contain
12852    declarations; all definitions are emitted at CU scope.  */
12853
12854 static void
12855 declare_in_namespace (tree thing, dw_die_ref context_die)
12856 {
12857   dw_die_ref ns_context;
12858
12859   if (debug_info_level <= DINFO_LEVEL_TERSE)
12860     return;
12861
12862   /* If this decl is from an inlined function, then don't try to emit it in its
12863      namespace, as we will get confused.  It would have already been emitted
12864      when the abstract instance of the inline function was emitted anyways.  */
12865   if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
12866     return;
12867
12868   ns_context = setup_namespace_context (thing, context_die);
12869
12870   if (ns_context != context_die)
12871     {
12872       if (DECL_P (thing))
12873         gen_decl_die (thing, ns_context);
12874       else
12875         gen_type_die (thing, ns_context);
12876     }
12877 }
12878
12879 /* Generate a DIE for a namespace or namespace alias.  */
12880
12881 static void
12882 gen_namespace_die (tree decl)
12883 {
12884   dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
12885
12886   /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
12887      they are an alias of.  */
12888   if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
12889     {
12890       /* Output a real namespace.  */
12891       dw_die_ref namespace_die
12892         = new_die (DW_TAG_namespace, context_die, decl);
12893       add_name_and_src_coords_attributes (namespace_die, decl);
12894       equate_decl_number_to_die (decl, namespace_die);
12895     }
12896   else
12897     {
12898       /* Output a namespace alias.  */
12899
12900       /* Force out the namespace we are an alias of, if necessary.  */
12901       dw_die_ref origin_die
12902         = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
12903
12904       /* Now create the namespace alias DIE.  */
12905       dw_die_ref namespace_die
12906         = new_die (DW_TAG_imported_declaration, context_die, decl);
12907       add_name_and_src_coords_attributes (namespace_die, decl);
12908       add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
12909       equate_decl_number_to_die (decl, namespace_die);
12910     }
12911 }
12912
12913 /* Generate Dwarf debug information for a decl described by DECL.  */
12914
12915 static void
12916 gen_decl_die (tree decl, dw_die_ref context_die)
12917 {
12918   tree origin;
12919
12920   if (DECL_P (decl) && DECL_IGNORED_P (decl))
12921     return;
12922
12923   switch (TREE_CODE (decl))
12924     {
12925     case ERROR_MARK:
12926       break;
12927
12928     case CONST_DECL:
12929       /* The individual enumerators of an enum type get output when we output
12930          the Dwarf representation of the relevant enum type itself.  */
12931       break;
12932
12933     case FUNCTION_DECL:
12934       /* Don't output any DIEs to represent mere function declarations,
12935          unless they are class members or explicit block externs.  */
12936       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
12937           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
12938         break;
12939
12940 #if 0
12941       /* FIXME */
12942       /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
12943          on local redeclarations of global functions.  That seems broken.  */
12944       if (current_function_decl != decl)
12945         /* This is only a declaration.  */;
12946 #endif
12947
12948       /* If we're emitting a clone, emit info for the abstract instance.  */
12949       if (DECL_ORIGIN (decl) != decl)
12950         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
12951
12952       /* If we're emitting an out-of-line copy of an inline function,
12953          emit info for the abstract instance and set up to refer to it.  */
12954       else if (cgraph_function_possibly_inlined_p (decl)
12955                && ! DECL_ABSTRACT (decl)
12956                && ! class_or_namespace_scope_p (context_die)
12957                /* dwarf2out_abstract_function won't emit a die if this is just
12958                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
12959                   that case, because that works only if we have a die.  */
12960                && DECL_INITIAL (decl) != NULL_TREE)
12961         {
12962           dwarf2out_abstract_function (decl);
12963           set_decl_origin_self (decl);
12964         }
12965
12966       /* Otherwise we're emitting the primary DIE for this decl.  */
12967       else if (debug_info_level > DINFO_LEVEL_TERSE)
12968         {
12969           /* Before we describe the FUNCTION_DECL itself, make sure that we
12970              have described its return type.  */
12971           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
12972
12973           /* And its virtual context.  */
12974           if (DECL_VINDEX (decl) != NULL_TREE)
12975             gen_type_die (DECL_CONTEXT (decl), context_die);
12976
12977           /* And its containing type.  */
12978           origin = decl_class_context (decl);
12979           if (origin != NULL_TREE)
12980             gen_type_die_for_member (origin, decl, context_die);
12981
12982           /* And its containing namespace.  */
12983           declare_in_namespace (decl, context_die);
12984         }
12985
12986       /* Now output a DIE to represent the function itself.  */
12987       gen_subprogram_die (decl, context_die);
12988       break;
12989
12990     case TYPE_DECL:
12991       /* If we are in terse mode, don't generate any DIEs to represent any
12992          actual typedefs.  */
12993       if (debug_info_level <= DINFO_LEVEL_TERSE)
12994         break;
12995
12996       /* In the special case of a TYPE_DECL node representing the declaration
12997          of some type tag, if the given TYPE_DECL is marked as having been
12998          instantiated from some other (original) TYPE_DECL node (e.g. one which
12999          was generated within the original definition of an inline function) we
13000          have to generate a special (abbreviated) DW_TAG_structure_type,
13001          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
13002       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
13003         {
13004           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13005           break;
13006         }
13007
13008       if (is_redundant_typedef (decl))
13009         gen_type_die (TREE_TYPE (decl), context_die);
13010       else
13011         /* Output a DIE to represent the typedef itself.  */
13012         gen_typedef_die (decl, context_die);
13013       break;
13014
13015     case LABEL_DECL:
13016       if (debug_info_level >= DINFO_LEVEL_NORMAL)
13017         gen_label_die (decl, context_die);
13018       break;
13019
13020     case VAR_DECL:
13021     case RESULT_DECL:
13022       /* If we are in terse mode, don't generate any DIEs to represent any
13023          variable declarations or definitions.  */
13024       if (debug_info_level <= DINFO_LEVEL_TERSE)
13025         break;
13026
13027       /* Output any DIEs that are needed to specify the type of this data
13028          object.  */
13029       gen_type_die (TREE_TYPE (decl), context_die);
13030
13031       /* And its containing type.  */
13032       origin = decl_class_context (decl);
13033       if (origin != NULL_TREE)
13034         gen_type_die_for_member (origin, decl, context_die);
13035
13036       /* And its containing namespace.  */
13037       declare_in_namespace (decl, context_die);
13038
13039       /* Now output the DIE to represent the data object itself.  This gets
13040          complicated because of the possibility that the VAR_DECL really
13041          represents an inlined instance of a formal parameter for an inline
13042          function.  */
13043       origin = decl_ultimate_origin (decl);
13044       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13045         gen_formal_parameter_die (decl, context_die);
13046       else
13047         gen_variable_die (decl, context_die);
13048       break;
13049
13050     case FIELD_DECL:
13051       /* Ignore the nameless fields that are used to skip bits but handle C++
13052          anonymous unions and structs.  */
13053       if (DECL_NAME (decl) != NULL_TREE
13054           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13055           || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13056         {
13057           gen_type_die (member_declared_type (decl), context_die);
13058           gen_field_die (decl, context_die);
13059         }
13060       break;
13061
13062     case PARM_DECL:
13063       gen_type_die (TREE_TYPE (decl), context_die);
13064       gen_formal_parameter_die (decl, context_die);
13065       break;
13066
13067     case NAMESPACE_DECL:
13068       gen_namespace_die (decl);
13069       break;
13070
13071     default:
13072       /* Probably some frontend-internal decl.  Assume we don't care.  */
13073       gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13074       break;
13075     }
13076 }
13077 \f
13078 /* Add Ada "use" clause information for SGI Workshop debugger.  */
13079
13080 void
13081 dwarf2out_add_library_unit_info (const char *filename, const char *context_list)
13082 {
13083   unsigned int file_index;
13084
13085   if (filename != NULL)
13086     {
13087       dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die, NULL);
13088       tree context_list_decl
13089         = build_decl (LABEL_DECL, get_identifier (context_list),
13090                       void_type_node);
13091
13092       TREE_PUBLIC (context_list_decl) = TRUE;
13093       add_name_attribute (unit_die, context_list);
13094       file_index = lookup_filename (filename);
13095       add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
13096       add_pubname (context_list_decl, unit_die);
13097     }
13098 }
13099
13100 /* Output debug information for global decl DECL.  Called from toplev.c after
13101    compilation proper has finished.  */
13102
13103 static void
13104 dwarf2out_global_decl (tree decl)
13105 {
13106   /* Output DWARF2 information for file-scope tentative data object
13107      declarations, file-scope (extern) function declarations (which had no
13108      corresponding body) and file-scope tagged type declarations and
13109      definitions which have not yet been forced out.  */
13110   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13111     dwarf2out_decl (decl);
13112 }
13113
13114 /* Output debug information for type decl DECL.  Called from toplev.c
13115    and from language front ends (to record built-in types).  */
13116 static void
13117 dwarf2out_type_decl (tree decl, int local)
13118 {
13119   if (!local)
13120     dwarf2out_decl (decl);
13121 }
13122
13123 /* Output debug information for imported module or decl.  */
13124
13125 static void
13126 dwarf2out_imported_module_or_decl (tree decl, tree context)
13127 {
13128   dw_die_ref imported_die, at_import_die;
13129   dw_die_ref scope_die;
13130   unsigned file_index;
13131   expanded_location xloc;
13132
13133   if (debug_info_level <= DINFO_LEVEL_TERSE)
13134     return;
13135
13136   gcc_assert (decl);
13137
13138   /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13139      We need decl DIE for reference and scope die. First, get DIE for the decl
13140      itself.  */
13141
13142   /* Get the scope die for decl context. Use comp_unit_die for global module
13143      or decl. If die is not found for non globals, force new die.  */
13144   if (!context)
13145     scope_die = comp_unit_die;
13146   else if (TYPE_P (context))
13147     scope_die = force_type_die (context);
13148   else
13149     scope_die = force_decl_die (context);
13150
13151   /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE.  */
13152   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13153     at_import_die = force_type_die (TREE_TYPE (decl));
13154   else
13155     {
13156       at_import_die = lookup_decl_die (decl);
13157       if (!at_import_die)
13158         {
13159           /* If we're trying to avoid duplicate debug info, we may not have
13160              emitted the member decl for this field.  Emit it now.  */
13161           if (TREE_CODE (decl) == FIELD_DECL)
13162             {
13163               tree type = DECL_CONTEXT (decl);
13164               dw_die_ref type_context_die;
13165
13166               if (TYPE_CONTEXT (type))
13167                 if (TYPE_P (TYPE_CONTEXT (type)))
13168                   type_context_die = force_type_die (TYPE_CONTEXT (type));
13169               else
13170                 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13171               else
13172                 type_context_die = comp_unit_die;
13173               gen_type_die_for_member (type, decl, type_context_die);
13174             }
13175           at_import_die = force_decl_die (decl);
13176         }
13177     }
13178
13179   /* OK, now we have DIEs for decl as well as scope. Emit imported die.  */
13180   if (TREE_CODE (decl) == NAMESPACE_DECL)
13181     imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13182   else
13183     imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13184
13185   xloc = expand_location (input_location);
13186   file_index = lookup_filename (xloc.file);
13187   add_AT_unsigned (imported_die, DW_AT_decl_file, file_index);
13188   add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13189   add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13190 }
13191
13192 /* Write the debugging output for DECL.  */
13193
13194 void
13195 dwarf2out_decl (tree decl)
13196 {
13197   dw_die_ref context_die = comp_unit_die;
13198
13199   switch (TREE_CODE (decl))
13200     {
13201     case ERROR_MARK:
13202       return;
13203
13204     case FUNCTION_DECL:
13205       /* What we would really like to do here is to filter out all mere
13206          file-scope declarations of file-scope functions which are never
13207          referenced later within this translation unit (and keep all of ones
13208          that *are* referenced later on) but we aren't clairvoyant, so we have
13209          no idea which functions will be referenced in the future (i.e. later
13210          on within the current translation unit). So here we just ignore all
13211          file-scope function declarations which are not also definitions.  If
13212          and when the debugger needs to know something about these functions,
13213          it will have to hunt around and find the DWARF information associated
13214          with the definition of the function.
13215
13216          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13217          nodes represent definitions and which ones represent mere
13218          declarations.  We have to check DECL_INITIAL instead. That's because
13219          the C front-end supports some weird semantics for "extern inline"
13220          function definitions.  These can get inlined within the current
13221          translation unit (and thus, we need to generate Dwarf info for their
13222          abstract instances so that the Dwarf info for the concrete inlined
13223          instances can have something to refer to) but the compiler never
13224          generates any out-of-lines instances of such things (despite the fact
13225          that they *are* definitions).
13226
13227          The important point is that the C front-end marks these "extern
13228          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13229          them anyway. Note that the C++ front-end also plays some similar games
13230          for inline function definitions appearing within include files which
13231          also contain `#pragma interface' pragmas.  */
13232       if (DECL_INITIAL (decl) == NULL_TREE)
13233         return;
13234
13235       /* If we're a nested function, initially use a parent of NULL; if we're
13236          a plain function, this will be fixed up in decls_for_scope.  If
13237          we're a method, it will be ignored, since we already have a DIE.  */
13238       if (decl_function_context (decl)
13239           /* But if we're in terse mode, we don't care about scope.  */
13240           && debug_info_level > DINFO_LEVEL_TERSE)
13241         context_die = NULL;
13242       break;
13243
13244     case VAR_DECL:
13245       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13246          declaration and if the declaration was never even referenced from
13247          within this entire compilation unit.  We suppress these DIEs in
13248          order to save space in the .debug section (by eliminating entries
13249          which are probably useless).  Note that we must not suppress
13250          block-local extern declarations (whether used or not) because that
13251          would screw-up the debugger's name lookup mechanism and cause it to
13252          miss things which really ought to be in scope at a given point.  */
13253       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13254         return;
13255
13256       /* For local statics lookup proper context die.  */
13257       if (TREE_STATIC (decl) && decl_function_context (decl))
13258         context_die = lookup_decl_die (DECL_CONTEXT (decl));
13259
13260       /* If we are in terse mode, don't generate any DIEs to represent any
13261          variable declarations or definitions.  */
13262       if (debug_info_level <= DINFO_LEVEL_TERSE)
13263         return;
13264       break;
13265
13266     case NAMESPACE_DECL:
13267       if (debug_info_level <= DINFO_LEVEL_TERSE)
13268         return;
13269       if (lookup_decl_die (decl) != NULL)
13270         return;
13271       break;
13272
13273     case TYPE_DECL:
13274       /* Don't emit stubs for types unless they are needed by other DIEs.  */
13275       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13276         return;
13277
13278       /* Don't bother trying to generate any DIEs to represent any of the
13279          normal built-in types for the language we are compiling.  */
13280       if (DECL_IS_BUILTIN (decl))
13281         {
13282           /* OK, we need to generate one for `bool' so GDB knows what type
13283              comparisons have.  */
13284           if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
13285                == DW_LANG_C_plus_plus)
13286               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13287               && ! DECL_IGNORED_P (decl))
13288             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13289
13290           return;
13291         }
13292
13293       /* If we are in terse mode, don't generate any DIEs for types.  */
13294       if (debug_info_level <= DINFO_LEVEL_TERSE)
13295         return;
13296
13297       /* If we're a function-scope tag, initially use a parent of NULL;
13298          this will be fixed up in decls_for_scope.  */
13299       if (decl_function_context (decl))
13300         context_die = NULL;
13301
13302       break;
13303
13304     default:
13305       return;
13306     }
13307
13308   gen_decl_die (decl, context_die);
13309 }
13310
13311 /* Output a marker (i.e. a label) for the beginning of the generated code for
13312    a lexical block.  */
13313
13314 static void
13315 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13316                        unsigned int blocknum)
13317 {
13318   switch_to_section (current_function_section ());
13319   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13320 }
13321
13322 /* Output a marker (i.e. a label) for the end of the generated code for a
13323    lexical block.  */
13324
13325 static void
13326 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13327 {
13328   switch_to_section (current_function_section ());
13329   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13330 }
13331
13332 /* Returns nonzero if it is appropriate not to emit any debugging
13333    information for BLOCK, because it doesn't contain any instructions.
13334
13335    Don't allow this for blocks with nested functions or local classes
13336    as we would end up with orphans, and in the presence of scheduling
13337    we may end up calling them anyway.  */
13338
13339 static bool
13340 dwarf2out_ignore_block (tree block)
13341 {
13342   tree decl;
13343
13344   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13345     if (TREE_CODE (decl) == FUNCTION_DECL
13346         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13347       return 0;
13348
13349   return 1;
13350 }
13351
13352 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13353    dwarf2out.c) and return its "index".  The index of each (known) filename is
13354    just a unique number which is associated with only that one filename.  We
13355    need such numbers for the sake of generating labels (in the .debug_sfnames
13356    section) and references to those files numbers (in the .debug_srcinfo
13357    and.debug_macinfo sections).  If the filename given as an argument is not
13358    found in our current list, add it to the list and assign it the next
13359    available unique index number.  In order to speed up searches, we remember
13360    the index of the filename was looked up last.  This handles the majority of
13361    all searches.  */
13362
13363 static unsigned
13364 lookup_filename (const char *file_name)
13365 {
13366   size_t i, n;
13367   char *save_file_name;
13368
13369   /* Check to see if the file name that was searched on the previous
13370      call matches this file name.  If so, return the index.  */
13371   if (file_table_last_lookup_index != 0)
13372     {
13373       const char *last
13374         = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
13375       if (strcmp (file_name, last) == 0)
13376         return file_table_last_lookup_index;
13377     }
13378
13379   /* Didn't match the previous lookup, search the table.  */
13380   n = VARRAY_ACTIVE_SIZE (file_table);
13381   for (i = 1; i < n; i++)
13382     if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
13383       {
13384         file_table_last_lookup_index = i;
13385         return i;
13386       }
13387
13388   /* Add the new entry to the end of the filename table.  */
13389   file_table_last_lookup_index = n;
13390   save_file_name = (char *) ggc_strdup (file_name);
13391   VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
13392   VARRAY_PUSH_UINT (file_table_emitted, 0);
13393
13394   /* If the assembler is emitting the file table, and we aren't eliminating
13395      unused debug types, then we must emit .file here.  If we are eliminating
13396      unused debug types, then this will be done by the maybe_emit_file call in
13397      prune_unused_types_walk_attribs.  */
13398
13399   if (DWARF2_ASM_LINE_DEBUG_INFO && ! flag_eliminate_unused_debug_types)
13400     return maybe_emit_file (i);
13401
13402   return i;
13403 }
13404
13405 /* If the assembler will construct the file table, then translate the compiler
13406    internal file table number into the assembler file table number, and emit
13407    a .file directive if we haven't already emitted one yet.  The file table
13408    numbers are different because we prune debug info for unused variables and
13409    types, which may include filenames.  */
13410
13411 static int
13412 maybe_emit_file (int fileno)
13413 {
13414   if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
13415     {
13416       if (!VARRAY_UINT (file_table_emitted, fileno))
13417         {
13418           VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
13419           fprintf (asm_out_file, "\t.file %u ",
13420                    VARRAY_UINT (file_table_emitted, fileno));
13421           output_quoted_string (asm_out_file,
13422                                 VARRAY_CHAR_PTR (file_table, fileno));
13423           fputc ('\n', asm_out_file);
13424         }
13425       return VARRAY_UINT (file_table_emitted, fileno);
13426     }
13427   else
13428     return fileno;
13429 }
13430
13431 /* Initialize the compiler internal file table.  */
13432
13433 static void
13434 init_file_table (void)
13435 {
13436   /* Allocate the initial hunk of the file_table.  */
13437   VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
13438   VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
13439
13440   /* Skip the first entry - file numbers begin at 1.  */
13441   VARRAY_PUSH_CHAR_PTR (file_table, NULL);
13442   VARRAY_PUSH_UINT (file_table_emitted, 0);
13443   file_table_last_lookup_index = 0;
13444 }
13445
13446 /* Called by the final INSN scan whenever we see a var location.  We
13447    use it to drop labels in the right places, and throw the location in
13448    our lookup table.  */
13449
13450 static void
13451 dwarf2out_var_location (rtx loc_note)
13452 {
13453   char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13454   struct var_loc_node *newloc;
13455   rtx prev_insn;
13456   static rtx last_insn;
13457   static const char *last_label;
13458   tree decl;
13459
13460   if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13461     return;
13462   prev_insn = PREV_INSN (loc_note);
13463
13464   newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13465   /* If the insn we processed last time is the previous insn
13466      and it is also a var location note, use the label we emitted
13467      last time.  */
13468   if (last_insn != NULL_RTX
13469       && last_insn == prev_insn
13470       && NOTE_P (prev_insn)
13471       && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13472     {
13473       newloc->label = last_label;
13474     }
13475   else
13476     {
13477       ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13478       ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13479       loclabel_num++;
13480       newloc->label = ggc_strdup (loclabel);
13481     }
13482   newloc->var_loc_note = loc_note;
13483   newloc->next = NULL;
13484
13485   if (cfun && in_cold_section_p)
13486     newloc->section_label = cfun->cold_section_label;
13487   else
13488     newloc->section_label = text_section_label;
13489
13490   last_insn = loc_note;
13491   last_label = newloc->label;
13492   decl = NOTE_VAR_LOCATION_DECL (loc_note);
13493   if (DECL_DEBUG_EXPR_IS_FROM (decl) && DECL_DEBUG_EXPR (decl)
13494       && DECL_P (DECL_DEBUG_EXPR (decl)))
13495     decl = DECL_DEBUG_EXPR (decl);
13496   add_var_loc_to_decl (decl, newloc);
13497 }
13498
13499 /* We need to reset the locations at the beginning of each
13500    function. We can't do this in the end_function hook, because the
13501    declarations that use the locations won't have been output when
13502    that hook is called.  Also compute have_multiple_function_sections here.  */
13503
13504 static void
13505 dwarf2out_begin_function (tree fun)
13506 {
13507   htab_empty (decl_loc_table);
13508
13509   if (function_section (fun) != text_section)
13510     have_multiple_function_sections = true;
13511 }
13512
13513 /* Output a label to mark the beginning of a source code line entry
13514    and record information relating to this source line, in
13515    'line_info_table' for later output of the .debug_line section.  */
13516
13517 static void
13518 dwarf2out_source_line (unsigned int line, const char *filename)
13519 {
13520   if (debug_info_level >= DINFO_LEVEL_NORMAL
13521       && line != 0)
13522     {
13523       switch_to_section (current_function_section ());
13524
13525       /* If requested, emit something human-readable.  */
13526       if (flag_debug_asm)
13527         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13528                  filename, line);
13529
13530       if (DWARF2_ASM_LINE_DEBUG_INFO)
13531         {
13532           unsigned file_num = lookup_filename (filename);
13533
13534           file_num = maybe_emit_file (file_num);
13535
13536           /* Emit the .loc directive understood by GNU as.  */
13537           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13538
13539           /* Indicate that line number info exists.  */
13540           line_info_table_in_use++;
13541         }
13542       else if (function_section (current_function_decl) != text_section)
13543         {
13544           dw_separate_line_info_ref line_info;
13545           targetm.asm_out.internal_label (asm_out_file, SEPARATE_LINE_CODE_LABEL,
13546                                      separate_line_info_table_in_use);
13547
13548           /* Expand the line info table if necessary.  */
13549           if (separate_line_info_table_in_use
13550               == separate_line_info_table_allocated)
13551             {
13552               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13553               separate_line_info_table
13554                 = ggc_realloc (separate_line_info_table,
13555                                separate_line_info_table_allocated
13556                                * sizeof (dw_separate_line_info_entry));
13557               memset (separate_line_info_table
13558                        + separate_line_info_table_in_use,
13559                       0,
13560                       (LINE_INFO_TABLE_INCREMENT
13561                        * sizeof (dw_separate_line_info_entry)));
13562             }
13563
13564           /* Add the new entry at the end of the line_info_table.  */
13565           line_info
13566             = &separate_line_info_table[separate_line_info_table_in_use++];
13567           line_info->dw_file_num = lookup_filename (filename);
13568           line_info->dw_line_num = line;
13569           line_info->function = current_function_funcdef_no;
13570         }
13571       else
13572         {
13573           dw_line_info_ref line_info;
13574
13575           targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13576                                      line_info_table_in_use);
13577
13578           /* Expand the line info table if necessary.  */
13579           if (line_info_table_in_use == line_info_table_allocated)
13580             {
13581               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13582               line_info_table
13583                 = ggc_realloc (line_info_table,
13584                                (line_info_table_allocated
13585                                 * sizeof (dw_line_info_entry)));
13586               memset (line_info_table + line_info_table_in_use, 0,
13587                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13588             }
13589
13590           /* Add the new entry at the end of the line_info_table.  */
13591           line_info = &line_info_table[line_info_table_in_use++];
13592           line_info->dw_file_num = lookup_filename (filename);
13593           line_info->dw_line_num = line;
13594         }
13595     }
13596 }
13597
13598 /* Record the beginning of a new source file.  */
13599
13600 static void
13601 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13602 {
13603   if (flag_eliminate_dwarf2_dups)
13604     {
13605       /* Record the beginning of the file for break_out_includes.  */
13606       dw_die_ref bincl_die;
13607
13608       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13609       add_AT_string (bincl_die, DW_AT_name, filename);
13610     }
13611
13612   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13613     {
13614       int fileno;
13615
13616       switch_to_section (debug_macinfo_section);
13617       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13618       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13619                                    lineno);
13620
13621       fileno = maybe_emit_file (lookup_filename (filename));
13622       dw2_asm_output_data_uleb128 (fileno, "Filename we just started");
13623     }
13624 }
13625
13626 /* Record the end of a source file.  */
13627
13628 static void
13629 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13630 {
13631   if (flag_eliminate_dwarf2_dups)
13632     /* Record the end of the file for break_out_includes.  */
13633     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13634
13635   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13636     {
13637       switch_to_section (debug_macinfo_section);
13638       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13639     }
13640 }
13641
13642 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
13643    the tail part of the directive line, i.e. the part which is past the
13644    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13645
13646 static void
13647 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13648                   const char *buffer ATTRIBUTE_UNUSED)
13649 {
13650   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13651     {
13652       switch_to_section (debug_macinfo_section);
13653       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13654       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13655       dw2_asm_output_nstring (buffer, -1, "The macro");
13656     }
13657 }
13658
13659 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
13660    the tail part of the directive line, i.e. the part which is past the
13661    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13662
13663 static void
13664 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13665                  const char *buffer ATTRIBUTE_UNUSED)
13666 {
13667   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13668     {
13669       switch_to_section (debug_macinfo_section);
13670       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13671       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13672       dw2_asm_output_nstring (buffer, -1, "The macro");
13673     }
13674 }
13675
13676 /* Set up for Dwarf output at the start of compilation.  */
13677
13678 static void
13679 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13680 {
13681   init_file_table ();
13682
13683   /* Allocate the decl_die_table.  */
13684   decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13685                                     decl_die_table_eq, NULL);
13686
13687   /* Allocate the decl_loc_table.  */
13688   decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13689                                     decl_loc_table_eq, NULL);
13690
13691   /* Allocate the initial hunk of the decl_scope_table.  */
13692   decl_scope_table = VEC_alloc (tree, gc, 256);
13693
13694   /* Allocate the initial hunk of the abbrev_die_table.  */
13695   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13696                                         * sizeof (dw_die_ref));
13697   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13698   /* Zero-th entry is allocated, but unused.  */
13699   abbrev_die_table_in_use = 1;
13700
13701   /* Allocate the initial hunk of the line_info_table.  */
13702   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13703                                        * sizeof (dw_line_info_entry));
13704   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13705
13706   /* Zero-th entry is allocated, but unused.  */
13707   line_info_table_in_use = 1;
13708
13709   /* Generate the initial DIE for the .debug section.  Note that the (string)
13710      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13711      will (typically) be a relative pathname and that this pathname should be
13712      taken as being relative to the directory from which the compiler was
13713      invoked when the given (base) source file was compiled.  We will fill
13714      in this value in dwarf2out_finish.  */
13715   comp_unit_die = gen_compile_unit_die (NULL);
13716
13717   incomplete_types = VEC_alloc (tree, gc, 64);
13718
13719   used_rtx_array = VEC_alloc (rtx, gc, 32);
13720
13721   debug_info_section = get_section (DEBUG_INFO_SECTION,
13722                                     SECTION_DEBUG, NULL);
13723   debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
13724                                       SECTION_DEBUG, NULL);
13725   debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
13726                                        SECTION_DEBUG, NULL);
13727   debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
13728                                        SECTION_DEBUG, NULL);
13729   debug_line_section = get_section (DEBUG_LINE_SECTION,
13730                                     SECTION_DEBUG, NULL);
13731   debug_loc_section = get_section (DEBUG_LOC_SECTION,
13732                                    SECTION_DEBUG, NULL);
13733   debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
13734                                         SECTION_DEBUG, NULL);
13735   debug_str_section = get_section (DEBUG_STR_SECTION,
13736                                    DEBUG_STR_SECTION_FLAGS, NULL);
13737   debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
13738                                       SECTION_DEBUG, NULL);
13739
13740   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13741   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13742                                DEBUG_ABBREV_SECTION_LABEL, 0);
13743   ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13744   ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13745                                COLD_TEXT_SECTION_LABEL, 0);
13746   ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13747
13748   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13749                                DEBUG_INFO_SECTION_LABEL, 0);
13750   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
13751                                DEBUG_LINE_SECTION_LABEL, 0);
13752   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
13753                                DEBUG_RANGES_SECTION_LABEL, 0);
13754   switch_to_section (debug_abbrev_section);
13755   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
13756   switch_to_section (debug_info_section);
13757   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
13758   switch_to_section (debug_line_section);
13759   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
13760
13761   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13762     {
13763       switch_to_section (debug_macinfo_section);
13764       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
13765                                    DEBUG_MACINFO_SECTION_LABEL, 0);
13766       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
13767     }
13768
13769   switch_to_section (text_section);
13770   ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
13771   if (flag_reorder_blocks_and_partition)
13772     {
13773       switch_to_section (unlikely_text_section ());
13774       ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
13775     }
13776 }
13777
13778 /* A helper function for dwarf2out_finish called through
13779    ht_forall.  Emit one queued .debug_str string.  */
13780
13781 static int
13782 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
13783 {
13784   struct indirect_string_node *node = (struct indirect_string_node *) *h;
13785
13786   if (node->form == DW_FORM_strp)
13787     {
13788       switch_to_section (debug_str_section);
13789       ASM_OUTPUT_LABEL (asm_out_file, node->label);
13790       assemble_string (node->str, strlen (node->str) + 1);
13791     }
13792
13793   return 1;
13794 }
13795
13796
13797
13798 /* Clear the marks for a die and its children.
13799    Be cool if the mark isn't set.  */
13800
13801 static void
13802 prune_unmark_dies (dw_die_ref die)
13803 {
13804   dw_die_ref c;
13805   die->die_mark = 0;
13806   for (c = die->die_child; c; c = c->die_sib)
13807     prune_unmark_dies (c);
13808 }
13809
13810
13811 /* Given DIE that we're marking as used, find any other dies
13812    it references as attributes and mark them as used.  */
13813
13814 static void
13815 prune_unused_types_walk_attribs (dw_die_ref die)
13816 {
13817   dw_attr_ref a;
13818
13819   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
13820     {
13821       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
13822         {
13823           /* A reference to another DIE.
13824              Make sure that it will get emitted.  */
13825           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
13826         }
13827       else if (a->dw_attr == DW_AT_decl_file || a->dw_attr == DW_AT_call_file)
13828         {
13829           /* A reference to a file.  Make sure the file name is emitted.  */
13830           a->dw_attr_val.v.val_unsigned =
13831             maybe_emit_file (a->dw_attr_val.v.val_unsigned);
13832         }
13833     }
13834 }
13835
13836
13837 /* Mark DIE as being used.  If DOKIDS is true, then walk down
13838    to DIE's children.  */
13839
13840 static void
13841 prune_unused_types_mark (dw_die_ref die, int dokids)
13842 {
13843   dw_die_ref c;
13844
13845   if (die->die_mark == 0)
13846     {
13847       /* We haven't done this node yet.  Mark it as used.  */
13848       die->die_mark = 1;
13849
13850       /* We also have to mark its parents as used.
13851          (But we don't want to mark our parents' kids due to this.)  */
13852       if (die->die_parent)
13853         prune_unused_types_mark (die->die_parent, 0);
13854
13855       /* Mark any referenced nodes.  */
13856       prune_unused_types_walk_attribs (die);
13857
13858       /* If this node is a specification,
13859          also mark the definition, if it exists.  */
13860       if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
13861         prune_unused_types_mark (die->die_definition, 1);
13862     }
13863
13864   if (dokids && die->die_mark != 2)
13865     {
13866       /* We need to walk the children, but haven't done so yet.
13867          Remember that we've walked the kids.  */
13868       die->die_mark = 2;
13869
13870       /* Walk them.  */
13871       for (c = die->die_child; c; c = c->die_sib)
13872         {
13873           /* If this is an array type, we need to make sure our
13874              kids get marked, even if they're types.  */
13875           if (die->die_tag == DW_TAG_array_type)
13876             prune_unused_types_mark (c, 1);
13877           else
13878             prune_unused_types_walk (c);
13879         }
13880     }
13881 }
13882
13883
13884 /* Walk the tree DIE and mark types that we actually use.  */
13885
13886 static void
13887 prune_unused_types_walk (dw_die_ref die)
13888 {
13889   dw_die_ref c;
13890
13891   /* Don't do anything if this node is already marked.  */
13892   if (die->die_mark)
13893     return;
13894
13895   switch (die->die_tag) {
13896   case DW_TAG_const_type:
13897   case DW_TAG_packed_type:
13898   case DW_TAG_pointer_type:
13899   case DW_TAG_reference_type:
13900   case DW_TAG_volatile_type:
13901   case DW_TAG_typedef:
13902   case DW_TAG_array_type:
13903   case DW_TAG_structure_type:
13904   case DW_TAG_union_type:
13905   case DW_TAG_class_type:
13906   case DW_TAG_friend:
13907   case DW_TAG_variant_part:
13908   case DW_TAG_enumeration_type:
13909   case DW_TAG_subroutine_type:
13910   case DW_TAG_string_type:
13911   case DW_TAG_set_type:
13912   case DW_TAG_subrange_type:
13913   case DW_TAG_ptr_to_member_type:
13914   case DW_TAG_file_type:
13915     /* It's a type node --- don't mark it.  */
13916     return;
13917
13918   default:
13919     /* Mark everything else.  */
13920     break;
13921   }
13922
13923   die->die_mark = 1;
13924
13925   /* Now, mark any dies referenced from here.  */
13926   prune_unused_types_walk_attribs (die);
13927
13928   /* Mark children.  */
13929   for (c = die->die_child; c; c = c->die_sib)
13930     prune_unused_types_walk (c);
13931 }
13932
13933
13934 /* Remove from the tree DIE any dies that aren't marked.  */
13935
13936 static void
13937 prune_unused_types_prune (dw_die_ref die)
13938 {
13939   dw_die_ref c, p, n;
13940
13941   gcc_assert (die->die_mark);
13942
13943   p = NULL;
13944   for (c = die->die_child; c; c = n)
13945     {
13946       n = c->die_sib;
13947       if (c->die_mark)
13948         {
13949           prune_unused_types_prune (c);
13950           p = c;
13951         }
13952       else
13953         {
13954           if (p)
13955             p->die_sib = n;
13956           else
13957             die->die_child = n;
13958           free_die (c);
13959         }
13960     }
13961 }
13962
13963
13964 /* Remove dies representing declarations that we never use.  */
13965
13966 static void
13967 prune_unused_types (void)
13968 {
13969   unsigned int i;
13970   limbo_die_node *node;
13971
13972   /* Clear all the marks.  */
13973   prune_unmark_dies (comp_unit_die);
13974   for (node = limbo_die_list; node; node = node->next)
13975     prune_unmark_dies (node->die);
13976
13977   /* Set the mark on nodes that are actually used.  */
13978   prune_unused_types_walk (comp_unit_die);
13979   for (node = limbo_die_list; node; node = node->next)
13980     prune_unused_types_walk (node->die);
13981
13982   /* Also set the mark on nodes referenced from the
13983      pubname_table or arange_table.  */
13984   for (i = 0; i < pubname_table_in_use; i++)
13985     prune_unused_types_mark (pubname_table[i].die, 1);
13986   for (i = 0; i < arange_table_in_use; i++)
13987     prune_unused_types_mark (arange_table[i], 1);
13988
13989   /* Get rid of nodes that aren't marked.  */
13990   prune_unused_types_prune (comp_unit_die);
13991   for (node = limbo_die_list; node; node = node->next)
13992     prune_unused_types_prune (node->die);
13993
13994   /* Leave the marks clear.  */
13995   prune_unmark_dies (comp_unit_die);
13996   for (node = limbo_die_list; node; node = node->next)
13997     prune_unmark_dies (node->die);
13998 }
13999
14000 /* Output stuff that dwarf requires at the end of every file,
14001    and generate the DWARF-2 debugging info.  */
14002
14003 static void
14004 dwarf2out_finish (const char *filename)
14005 {
14006   limbo_die_node *node, *next_node;
14007   dw_die_ref die = 0;
14008
14009   /* Add the name for the main input file now.  We delayed this from
14010      dwarf2out_init to avoid complications with PCH.  */
14011   add_name_attribute (comp_unit_die, filename);
14012   if (filename[0] != DIR_SEPARATOR)
14013     add_comp_dir_attribute (comp_unit_die);
14014   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14015     {
14016       size_t i;
14017       for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
14018         if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR
14019             /* Don't add cwd for <built-in>.  */
14020             && VARRAY_CHAR_PTR (file_table, i)[0] != '<')
14021           {
14022             add_comp_dir_attribute (comp_unit_die);
14023             break;
14024           }
14025     }
14026
14027   /* Traverse the limbo die list, and add parent/child links.  The only
14028      dies without parents that should be here are concrete instances of
14029      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
14030      For concrete instances, we can get the parent die from the abstract
14031      instance.  */
14032   for (node = limbo_die_list; node; node = next_node)
14033     {
14034       next_node = node->next;
14035       die = node->die;
14036
14037       if (die->die_parent == NULL)
14038         {
14039           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14040
14041           if (origin)
14042             add_child_die (origin->die_parent, die);
14043           else if (die == comp_unit_die)
14044             ;
14045           else if (errorcount > 0 || sorrycount > 0)
14046             /* It's OK to be confused by errors in the input.  */
14047             add_child_die (comp_unit_die, die);
14048           else
14049             {
14050               /* In certain situations, the lexical block containing a
14051                  nested function can be optimized away, which results
14052                  in the nested function die being orphaned.  Likewise
14053                  with the return type of that nested function.  Force
14054                  this to be a child of the containing function.
14055
14056                  It may happen that even the containing function got fully
14057                  inlined and optimized out.  In that case we are lost and
14058                  assign the empty child.  This should not be big issue as
14059                  the function is likely unreachable too.  */
14060               tree context = NULL_TREE;
14061
14062               gcc_assert (node->created_for);
14063
14064               if (DECL_P (node->created_for))
14065                 context = DECL_CONTEXT (node->created_for);
14066               else if (TYPE_P (node->created_for))
14067                 context = TYPE_CONTEXT (node->created_for);
14068
14069               gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
14070
14071               origin = lookup_decl_die (context);
14072               if (origin)
14073                 add_child_die (origin, die);
14074               else
14075                 add_child_die (comp_unit_die, die);
14076             }
14077         }
14078     }
14079
14080   limbo_die_list = NULL;
14081
14082   /* Walk through the list of incomplete types again, trying once more to
14083      emit full debugging info for them.  */
14084   retry_incomplete_types ();
14085
14086   /* We need to reverse all the dies before break_out_includes, or
14087      we'll see the end of an include file before the beginning.  */
14088   reverse_all_dies (comp_unit_die);
14089
14090   if (flag_eliminate_unused_debug_types)
14091     prune_unused_types ();
14092
14093   /* Generate separate CUs for each of the include files we've seen.
14094      They will go into limbo_die_list.  */
14095   if (flag_eliminate_dwarf2_dups)
14096     break_out_includes (comp_unit_die);
14097
14098   /* Traverse the DIE's and add add sibling attributes to those DIE's
14099      that have children.  */
14100   add_sibling_attributes (comp_unit_die);
14101   for (node = limbo_die_list; node; node = node->next)
14102     add_sibling_attributes (node->die);
14103
14104   /* Output a terminator label for the .text section.  */
14105   switch_to_section (text_section);
14106   targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14107   if (flag_reorder_blocks_and_partition)
14108     {
14109       switch_to_section (unlikely_text_section ());
14110       targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14111     }
14112
14113   /* Output the source line correspondence table.  We must do this
14114      even if there is no line information.  Otherwise, on an empty
14115      translation unit, we will generate a present, but empty,
14116      .debug_info section.  IRIX 6.5 `nm' will then complain when
14117      examining the file.  */
14118   if (! DWARF2_ASM_LINE_DEBUG_INFO)
14119     {
14120       switch_to_section (debug_line_section);
14121       output_line_info ();
14122     }
14123
14124   /* We can only use the low/high_pc attributes if all of the code was
14125      in .text.  */
14126   if (!have_multiple_function_sections)
14127     {
14128       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14129       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14130     }
14131
14132   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14133      "base address".  Use zero so that these addresses become absolute.  */
14134   else if (have_location_lists || ranges_table_in_use)
14135     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14136
14137   /* Output location list section if necessary.  */
14138   if (have_location_lists)
14139     {
14140       /* Output the location lists info.  */
14141       switch_to_section (debug_loc_section);
14142       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14143                                    DEBUG_LOC_SECTION_LABEL, 0);
14144       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14145       output_location_lists (die);
14146     }
14147
14148   if (debug_info_level >= DINFO_LEVEL_NORMAL)
14149     add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
14150                        debug_line_section_label);
14151
14152   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14153     add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14154
14155   /* Output all of the compilation units.  We put the main one last so that
14156      the offsets are available to output_pubnames.  */
14157   for (node = limbo_die_list; node; node = node->next)
14158     output_comp_unit (node->die, 0);
14159
14160   output_comp_unit (comp_unit_die, 0);
14161
14162   /* Output the abbreviation table.  */
14163   switch_to_section (debug_abbrev_section);
14164   output_abbrev_section ();
14165
14166   /* Output public names table if necessary.  */
14167   if (pubname_table_in_use)
14168     {
14169       switch_to_section (debug_pubnames_section);
14170       output_pubnames ();
14171     }
14172
14173   /* Output the address range information.  We only put functions in the arange
14174      table, so don't write it out if we don't have any.  */
14175   if (fde_table_in_use)
14176     {
14177       switch_to_section (debug_aranges_section);
14178       output_aranges ();
14179     }
14180
14181   /* Output ranges section if necessary.  */
14182   if (ranges_table_in_use)
14183     {
14184       switch_to_section (debug_ranges_section);
14185       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14186       output_ranges ();
14187     }
14188
14189   /* Have to end the macro section.  */
14190   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14191     {
14192       switch_to_section (debug_macinfo_section);
14193       dw2_asm_output_data (1, 0, "End compilation unit");
14194     }
14195
14196   /* If we emitted any DW_FORM_strp form attribute, output the string
14197      table too.  */
14198   if (debug_str_hash)
14199     htab_traverse (debug_str_hash, output_indirect_string, NULL);
14200 }
14201 #else
14202
14203 /* This should never be used, but its address is needed for comparisons.  */
14204 const struct gcc_debug_hooks dwarf2_debug_hooks;
14205
14206 #endif /* DWARF2_DEBUGGING_INFO */
14207
14208 #include "gt-dwarf2out.h"