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