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, 2007, 2008, 2009, 2010, 2011, 2012
   4    Free Software Foundation, Inc.
   5    Contributed by Gary Funck (gary@intrepid.com).
   6    Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
   7    Extensively modified by Jason Merrill (jason@cygnus.com).
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify it under
  12 the terms of the GNU General Public License as published by the Free
  13 Software Foundation; either version 3, or (at your option) any later
  14 version.
  15
  16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19 for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  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 /* DWARF2 Abbreviation Glossary:
  38
  39    CFA = Canonical Frame Address
  40            a fixed address on the stack which identifies a call frame.
  41            We define it to be the value of SP just before the call insn.
  42            The CFA register and offset, which may change during the course
  43            of the function, are used to calculate its value at runtime.
  44
  45    CFI = Call Frame Instruction
  46            an instruction for the DWARF2 abstract machine
  47
  48    CIE = Common Information Entry
  49            information describing information common to one or more FDEs
  50
  51    DIE = Debugging Information Entry
  52
  53    FDE = Frame Description Entry
  54            information describing the stack call frame, in particular,
  55            how to restore registers
  56
  57    DW_CFA_... = DWARF2 CFA call frame instruction
  58    DW_TAG_... = DWARF2 DIE tag */
  59
  60 #include "config.h"
  61 #include "system.h"
  62 #include "coretypes.h"
  63 #include "tm.h"
  64 #include "tree.h"
  65 #include "version.h"
  66 #include "flags.h"
  67 #include "rtl.h"
  68 #include "hard-reg-set.h"
  69 #include "regs.h"
  70 #include "insn-config.h"
  71 #include "reload.h"
  72 #include "function.h"
  73 #include "output.h"
  74 #include "expr.h"
  75 #include "libfuncs.h"
  76 #include "except.h"
  77 #include "dwarf2.h"
  78 #include "dwarf2out.h"
  79 #include "dwarf2asm.h"
  80 #include "toplev.h"
  81 #include "ggc.h"
  82 #include "md5.h"
  83 #include "tm_p.h"
  84 #include "diagnostic.h"
  85 #include "tree-pretty-print.h"
  86 #include "debug.h"
  87 #include "target.h"
  88 #include "common/common-target.h"
  89 #include "langhooks.h"
  90 #include "hashtab.h"
  91 #include "cgraph.h"
  92 #include "input.h"
  93 #include "gimple.h"
  94 #include "tree-pass.h"
  95 #include "tree-flow.h"
  96 #include "cfglayout.h"
  97 #include "opts.h"
  98
  99 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
 100 static rtx last_var_location_insn;
 101 static rtx cached_next_real_insn;
 102
 103 #ifdef VMS_DEBUGGING_INFO
 104 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
 105
 106 /* Define this macro to be a nonzero value if the directory specifications
 107     which are output in the debug info should end with a separator.  */
 108 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
 109 /* Define this macro to evaluate to a nonzero value if GCC should refrain
 110    from generating indirect strings in DWARF2 debug information, for instance
 111    if your target is stuck with an old version of GDB that is unable to
 112    process them properly or uses VMS Debug.  */
 113 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
 114 #else
 115 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
 116 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
 117 #endif
 118
 119 /* ??? Poison these here until it can be done generically.  They've been
 120    totally replaced in this file; make sure it stays that way.  */
 121 #undef DWARF2_UNWIND_INFO
 122 #undef DWARF2_FRAME_INFO
 123 #if (GCC_VERSION >= 3000)
 124  #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
 125 #endif
 126
 127 /* The size of the target's pointer type.  */
 128 #ifndef PTR_SIZE
 129 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 130 #endif
 131
 132 /* Array of RTXes referenced by the debugging information, which therefore
 133    must be kept around forever.  */
 134 static GTY(()) VEC(rtx,gc) *used_rtx_array;
 135
 136 /* A pointer to the base of a list of incomplete types which might be
 137    completed at some later time.  incomplete_types_list needs to be a
 138    VEC(tree,gc) because we want to tell the garbage collector about
 139    it.  */
 140 static GTY(()) VEC(tree,gc) *incomplete_types;
 141
 142 /* A pointer to the base of a table of references to declaration
 143    scopes.  This table is a display which tracks the nesting
 144    of declaration scopes at the current scope and containing
 145    scopes.  This table is used to find the proper place to
 146    define type declaration DIE's.  */
 147 static GTY(()) VEC(tree,gc) *decl_scope_table;
 148
 149 /* Pointers to various DWARF2 sections.  */
 150 static GTY(()) section *debug_info_section;
 151 static GTY(()) section *debug_abbrev_section;
 152 static GTY(()) section *debug_aranges_section;
 153 static GTY(()) section *debug_macinfo_section;
 154 static GTY(()) section *debug_line_section;
 155 static GTY(()) section *debug_loc_section;
 156 static GTY(()) section *debug_pubnames_section;
 157 static GTY(()) section *debug_pubtypes_section;
 158 static GTY(()) section *debug_str_section;
 159 static GTY(()) section *debug_ranges_section;
 160 static GTY(()) section *debug_frame_section;
 161
 162 /* Maximum size (in bytes) of an artificially generated label.  */
 163 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 164
 165 /* According to the (draft) DWARF 3 specification, the initial length
 166    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
 167    bytes are 0xffffffff, followed by the length stored in the next 8
 168    bytes.
 169
 170    However, the SGI/MIPS ABI uses an initial length which is equal to
 171    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
 172
 173 #ifndef DWARF_INITIAL_LENGTH_SIZE
 174 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
 175 #endif
 176
 177 /* Round SIZE up to the nearest BOUNDARY.  */
 178 #define DWARF_ROUND(SIZE,BOUNDARY) \
 179   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 180
 181 /* CIE identifier.  */
 182 #if HOST_BITS_PER_WIDE_INT >= 64
 183 #define DWARF_CIE_ID \
 184   (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
 185 #else
 186 #define DWARF_CIE_ID DW_CIE_ID
 187 #endif
 188
 189 DEF_VEC_P (dw_fde_ref);
 190 DEF_VEC_ALLOC_P (dw_fde_ref, gc);
 191
 192 /* A vector for a table that contains frame description
 193    information for each routine.  */
 194 static GTY(()) VEC(dw_fde_ref, gc) *fde_vec;
 195
 196 struct GTY(()) indirect_string_node {
 197   const char *str;
 198   unsigned int refcount;
 199   enum dwarf_form form;
 200   char *label;
 201 };
 202
 203 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 204
 205 static GTY(()) int dw2_string_counter;
 206
 207 /* True if the compilation unit places functions in more than one section.  */
 208 static GTY(()) bool have_multiple_function_sections = false;
 209
 210 /* Whether the default text and cold text sections have been used at all.  */
 211
 212 static GTY(()) bool text_section_used = false;
 213 static GTY(()) bool cold_text_section_used = false;
 214
 215 /* The default cold text section.  */
 216 static GTY(()) section *cold_text_section;
 217
 218 /* Forward declarations for functions defined in this file.  */
 219
 220 static char *stripattributes (const char *);
 221 static void output_call_frame_info (int);
 222 static void dwarf2out_note_section_used (void);
 223
 224 /* Personality decl of current unit.  Used only when assembler does not support
 225    personality CFI.  */
 226 static GTY(()) rtx current_unit_personality;
 227
 228 /* Data and reference forms for relocatable data.  */
 229 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 230 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 231
 232 #ifndef DEBUG_FRAME_SECTION
 233 #define DEBUG_FRAME_SECTION     ".debug_frame"
 234 #endif
 235
 236 #ifndef FUNC_BEGIN_LABEL
 237 #define FUNC_BEGIN_LABEL        "LFB"
 238 #endif
 239
 240 #ifndef FUNC_END_LABEL
 241 #define FUNC_END_LABEL          "LFE"
 242 #endif
 243
 244 #ifndef PROLOGUE_END_LABEL
 245 #define PROLOGUE_END_LABEL      "LPE"
 246 #endif
 247
 248 #ifndef EPILOGUE_BEGIN_LABEL
 249 #define EPILOGUE_BEGIN_LABEL    "LEB"
 250 #endif
 251
 252 #ifndef FRAME_BEGIN_LABEL
 253 #define FRAME_BEGIN_LABEL       "Lframe"
 254 #endif
 255 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 256 #define CIE_END_LABEL           "LECIE"
 257 #define FDE_LABEL               "LSFDE"
 258 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 259 #define FDE_END_LABEL           "LEFDE"
 260 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 261 #define LINE_NUMBER_END_LABEL   "LELT"
 262 #define LN_PROLOG_AS_LABEL      "LASLTP"
 263 #define LN_PROLOG_END_LABEL     "LELTP"
 264 #define DIE_LABEL_PREFIX        "DW"
 265 \f
 266 /* Match the base name of a file to the base name of a compilation unit. */
 267
 268 static int
 269 matches_main_base (const char *path)
 270 {
 271   /* Cache the last query. */
 272   static const char *last_path = NULL;
 273   static int last_match = 0;
 274   if (path != last_path)
 275     {
 276       const char *base;
 277       int length = base_of_path (path, &base);
 278       last_path = path;
 279       last_match = (length == main_input_baselength
 280                     && memcmp (base, main_input_basename, length) == 0);
 281     }
 282   return last_match;
 283 }
 284
 285 #ifdef DEBUG_DEBUG_STRUCT
 286
 287 static int
 288 dump_struct_debug (tree type, enum debug_info_usage usage,
 289                    enum debug_struct_file criterion, int generic,
 290                    int matches, int result)
 291 {
 292   /* Find the type name. */
 293   tree type_decl = TYPE_STUB_DECL (type);
 294   tree t = type_decl;
 295   const char *name = 0;
 296   if (TREE_CODE (t) == TYPE_DECL)
 297     t = DECL_NAME (t);
 298   if (t)
 299     name = IDENTIFIER_POINTER (t);
 300
 301   fprintf (stderr, "    struct %d %s %s %s %s %d %p %s\n",
 302            criterion,
 303            DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
 304            matches ? "bas" : "hdr",
 305            generic ? "gen" : "ord",
 306            usage == DINFO_USAGE_DFN ? ";" :
 307              usage == DINFO_USAGE_DIR_USE ? "." : "*",
 308            result,
 309            (void*) type_decl, name);
 310   return result;
 311 }
 312 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
 313   dump_struct_debug (type, usage, criterion, generic, matches, result)
 314
 315 #else
 316
 317 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
 318   (result)
 319
 320 #endif
 321
 322 static bool
 323 should_emit_struct_debug (tree type, enum debug_info_usage usage)
 324 {
 325   enum debug_struct_file criterion;
 326   tree type_decl;
 327   bool generic = lang_hooks.types.generic_p (type);
 328
 329   if (generic)
 330     criterion = debug_struct_generic[usage];
 331   else
 332     criterion = debug_struct_ordinary[usage];
 333
 334   if (criterion == DINFO_STRUCT_FILE_NONE)
 335     return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
 336   if (criterion == DINFO_STRUCT_FILE_ANY)
 337     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
 338
 339   type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
 340
 341   if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
 342     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
 343
 344   if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
 345     return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
 346   return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
 347 }
 348 \f
 349 /* Return a pointer to a copy of the section string name S with all
 350    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 351
 352 static inline char *
 353 stripattributes (const char *s)
 354 {
 355   char *stripped = XNEWVEC (char, strlen (s) + 2);
 356   char *p = stripped;
 357
 358   *p++ = '*';
 359
 360   while (*s && *s != ',')
 361     *p++ = *s++;
 362
 363   *p = '\0';
 364   return stripped;
 365 }
 366
 367 /* Switch [BACK] to eh_frame_section.  If we don't have an eh_frame_section,
 368    switch to the data section instead, and write out a synthetic start label
 369    for collect2 the first time around.  */
 370
 371 static void
 372 switch_to_eh_frame_section (bool back)
 373 {
 374   tree label;
 375
 376 #ifdef EH_FRAME_SECTION_NAME
 377   if (eh_frame_section == 0)
 378     {
 379       int flags;
 380
 381       if (EH_TABLES_CAN_BE_READ_ONLY)
 382         {
 383           int fde_encoding;
 384           int per_encoding;
 385           int lsda_encoding;
 386
 387           fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
 388                                                        /*global=*/0);
 389           per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
 390                                                        /*global=*/1);
 391           lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
 392                                                         /*global=*/0);
 393           flags = ((! flag_pic
 394                     || ((fde_encoding & 0x70) != DW_EH_PE_absptr
 395                         && (fde_encoding & 0x70) != DW_EH_PE_aligned
 396                         && (per_encoding & 0x70) != DW_EH_PE_absptr
 397                         && (per_encoding & 0x70) != DW_EH_PE_aligned
 398                         && (lsda_encoding & 0x70) != DW_EH_PE_absptr
 399                         && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
 400                    ? 0 : SECTION_WRITE);
 401         }
 402       else
 403         flags = SECTION_WRITE;
 404       eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
 405     }
 406 #endif /* EH_FRAME_SECTION_NAME */
 407
 408   if (eh_frame_section)
 409     switch_to_section (eh_frame_section);
 410   else
 411     {
 412       /* We have no special eh_frame section.  Put the information in
 413          the data section and emit special labels to guide collect2.  */
 414       switch_to_section (data_section);
 415
 416       if (!back)
 417         {
 418           label = get_file_function_name ("F");
 419           ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
 420           targetm.asm_out.globalize_label (asm_out_file,
 421                                            IDENTIFIER_POINTER (label));
 422           ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
 423         }
 424     }
 425 }
 426
 427 /* Switch [BACK] to the eh or debug frame table section, depending on
 428    FOR_EH.  */
 429
 430 static void
 431 switch_to_frame_table_section (int for_eh, bool back)
 432 {
 433   if (for_eh)
 434     switch_to_eh_frame_section (back);
 435   else
 436     {
 437       if (!debug_frame_section)
 438         debug_frame_section = get_section (DEBUG_FRAME_SECTION,
 439                                            SECTION_DEBUG, NULL);
 440       switch_to_section (debug_frame_section);
 441     }
 442 }
 443
 444 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
 445
 446 enum dw_cfi_oprnd_type
 447 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
 448 {
 449   switch (cfi)
 450     {
 451     case DW_CFA_nop:
 452     case DW_CFA_GNU_window_save:
 453     case DW_CFA_remember_state:
 454     case DW_CFA_restore_state:
 455       return dw_cfi_oprnd_unused;
 456
 457     case DW_CFA_set_loc:
 458     case DW_CFA_advance_loc1:
 459     case DW_CFA_advance_loc2:
 460     case DW_CFA_advance_loc4:
 461     case DW_CFA_MIPS_advance_loc8:
 462       return dw_cfi_oprnd_addr;
 463
 464     case DW_CFA_offset:
 465     case DW_CFA_offset_extended:
 466     case DW_CFA_def_cfa:
 467     case DW_CFA_offset_extended_sf:
 468     case DW_CFA_def_cfa_sf:
 469     case DW_CFA_restore:
 470     case DW_CFA_restore_extended:
 471     case DW_CFA_undefined:
 472     case DW_CFA_same_value:
 473     case DW_CFA_def_cfa_register:
 474     case DW_CFA_register:
 475     case DW_CFA_expression:
 476       return dw_cfi_oprnd_reg_num;
 477
 478     case DW_CFA_def_cfa_offset:
 479     case DW_CFA_GNU_args_size:
 480     case DW_CFA_def_cfa_offset_sf:
 481       return dw_cfi_oprnd_offset;
 482
 483     case DW_CFA_def_cfa_expression:
 484       return dw_cfi_oprnd_loc;
 485
 486     default:
 487       gcc_unreachable ();
 488     }
 489 }
 490
 491 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
 492
 493 enum dw_cfi_oprnd_type
 494 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
 495 {
 496   switch (cfi)
 497     {
 498     case DW_CFA_def_cfa:
 499     case DW_CFA_def_cfa_sf:
 500     case DW_CFA_offset:
 501     case DW_CFA_offset_extended_sf:
 502     case DW_CFA_offset_extended:
 503       return dw_cfi_oprnd_offset;
 504
 505     case DW_CFA_register:
 506       return dw_cfi_oprnd_reg_num;
 507
 508     case DW_CFA_expression:
 509       return dw_cfi_oprnd_loc;
 510
 511     default:
 512       return dw_cfi_oprnd_unused;
 513     }
 514 }
 515
 516 /* Output one FDE.  */
 517
 518 static void
 519 output_fde (dw_fde_ref fde, bool for_eh, bool second,
 520             char *section_start_label, int fde_encoding, char *augmentation,
 521             bool any_lsda_needed, int lsda_encoding)
 522 {
 523   const char *begin, *end;
 524   static unsigned int j;
 525   char l1[20], l2[20];
 526
 527   targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
 528                                      /* empty */ 0);
 529   targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
 530                                   for_eh + j);
 531   ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
 532   ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
 533   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
 534     dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
 535                          " indicating 64-bit DWARF extension");
 536   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
 537                         "FDE Length");
 538   ASM_OUTPUT_LABEL (asm_out_file, l1);
 539
 540   if (for_eh)
 541     dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
 542   else
 543     dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
 544                            debug_frame_section, "FDE CIE offset");
 545
 546   begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
 547   end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
 548
 549   if (for_eh)
 550     {
 551       rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
 552       SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
 553       dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
 554                                        "FDE initial location");
 555       dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
 556                             end, begin, "FDE address range");
 557     }
 558   else
 559     {
 560       dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
 561       dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
 562     }
 563
 564   if (augmentation[0])
 565     {
 566       if (any_lsda_needed)
 567         {
 568           int size = size_of_encoded_value (lsda_encoding);
 569
 570           if (lsda_encoding == DW_EH_PE_aligned)
 571             {
 572               int offset = (  4         /* Length */
 573                             + 4         /* CIE offset */
 574                             + 2 * size_of_encoded_value (fde_encoding)
 575                             + 1         /* Augmentation size */ );
 576               int pad = -offset & (PTR_SIZE - 1);
 577
 578               size += pad;
 579               gcc_assert (size_of_uleb128 (size) == 1);
 580             }
 581
 582           dw2_asm_output_data_uleb128 (size, "Augmentation size");
 583
 584           if (fde->uses_eh_lsda)
 585             {
 586               ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
 587                                            fde->funcdef_number);
 588               dw2_asm_output_encoded_addr_rtx (lsda_encoding,
 589                                                gen_rtx_SYMBOL_REF (Pmode, l1),
 590                                                false,
 591                                                "Language Specific Data Area");
 592             }
 593           else
 594             {
 595               if (lsda_encoding == DW_EH_PE_aligned)
 596                 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
 597               dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
 598                                    "Language Specific Data Area (none)");
 599             }
 600         }
 601       else
 602         dw2_asm_output_data_uleb128 (0, "Augmentation size");
 603     }
 604
 605   /* Loop through the Call Frame Instructions associated with this FDE.  */
 606   fde->dw_fde_current_label = begin;
 607   {
 608     size_t from, until, i;
 609
 610     from = 0;
 611     until = VEC_length (dw_cfi_ref, fde->dw_fde_cfi);
 612
 613     if (fde->dw_fde_second_begin == NULL)
 614       ;
 615     else if (!second)
 616       until = fde->dw_fde_switch_cfi_index;
 617     else
 618       from = fde->dw_fde_switch_cfi_index;
 619
 620     for (i = from; i < until; i++)
 621       output_cfi (VEC_index (dw_cfi_ref, fde->dw_fde_cfi, i), fde, for_eh);
 622   }
 623
 624   /* If we are to emit a ref/link from function bodies to their frame tables,
 625      do it now.  This is typically performed to make sure that tables
 626      associated with functions are dragged with them and not discarded in
 627      garbage collecting links. We need to do this on a per function basis to
 628      cope with -ffunction-sections.  */
 629
 630 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
 631   /* Switch to the function section, emit the ref to the tables, and
 632      switch *back* into the table section.  */
 633   switch_to_section (function_section (fde->decl));
 634   ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
 635   switch_to_frame_table_section (for_eh, true);
 636 #endif
 637
 638   /* Pad the FDE out to an address sized boundary.  */
 639   ASM_OUTPUT_ALIGN (asm_out_file,
 640                     floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
 641   ASM_OUTPUT_LABEL (asm_out_file, l2);
 642
 643   j += 2;
 644 }
 645
 646 /* Return true if frame description entry FDE is needed for EH.  */
 647
 648 static bool
 649 fde_needed_for_eh_p (dw_fde_ref fde)
 650 {
 651   if (flag_asynchronous_unwind_tables)
 652     return true;
 653
 654   if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
 655     return true;
 656
 657   if (fde->uses_eh_lsda)
 658     return true;
 659
 660   /* If exceptions are enabled, we have collected nothrow info.  */
 661   if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
 662     return false;
 663
 664   return true;
 665 }
 666
 667 /* Output the call frame information used to record information
 668    that relates to calculating the frame pointer, and records the
 669    location of saved registers.  */
 670
 671 static void
 672 output_call_frame_info (int for_eh)
 673 {
 674   unsigned int i;
 675   dw_fde_ref fde;
 676   dw_cfi_ref cfi;
 677   char l1[20], l2[20], section_start_label[20];
 678   bool any_lsda_needed = false;
 679   char augmentation[6];
 680   int augmentation_size;
 681   int fde_encoding = DW_EH_PE_absptr;
 682   int per_encoding = DW_EH_PE_absptr;
 683   int lsda_encoding = DW_EH_PE_absptr;
 684   int return_reg;
 685   rtx personality = NULL;
 686   int dw_cie_version;
 687
 688   /* Don't emit a CIE if there won't be any FDEs.  */
 689   if (fde_vec == NULL)
 690     return;
 691
 692   /* Nothing to do if the assembler's doing it all.  */
 693   if (dwarf2out_do_cfi_asm ())
 694     return;
 695
 696   /* If we don't have any functions we'll want to unwind out of, don't emit
 697      any EH unwind information.  If we make FDEs linkonce, we may have to
 698      emit an empty label for an FDE that wouldn't otherwise be emitted.  We
 699      want to avoid having an FDE kept around when the function it refers to
 700      is discarded.  Example where this matters: a primary function template
 701      in C++ requires EH information, an explicit specialization doesn't.  */
 702   if (for_eh)
 703     {
 704       bool any_eh_needed = false;
 705
 706       FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, i, fde)
 707         {
 708           if (fde->uses_eh_lsda)
 709             any_eh_needed = any_lsda_needed = true;
 710           else if (fde_needed_for_eh_p (fde))
 711             any_eh_needed = true;
 712           else if (TARGET_USES_WEAK_UNWIND_INFO)
 713             targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);
 714         }
 715
 716       if (!any_eh_needed)
 717         return;
 718     }
 719
 720   /* We're going to be generating comments, so turn on app.  */
 721   if (flag_debug_asm)
 722     app_enable ();
 723
 724   /* Switch to the proper frame section, first time.  */
 725   switch_to_frame_table_section (for_eh, false);
 726
 727   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
 728   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
 729
 730   /* Output the CIE.  */
 731   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
 732   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
 733   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
 734     dw2_asm_output_data (4, 0xffffffff,
 735       "Initial length escape value indicating 64-bit DWARF extension");
 736   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
 737                         "Length of Common Information Entry");
 738   ASM_OUTPUT_LABEL (asm_out_file, l1);
 739
 740   /* Now that the CIE pointer is PC-relative for EH,
 741      use 0 to identify the CIE.  */
 742   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
 743                        (for_eh ? 0 : DWARF_CIE_ID),
 744                        "CIE Identifier Tag");
 745
 746   /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
 747      use CIE version 1, unless that would produce incorrect results
 748      due to overflowing the return register column.  */
 749   return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
 750   dw_cie_version = 1;
 751   if (return_reg >= 256 || dwarf_version > 2)
 752     dw_cie_version = 3;
 753   dw2_asm_output_data (1, dw_cie_version, "CIE Version");
 754
 755   augmentation[0] = 0;
 756   augmentation_size = 0;
 757
 758   personality = current_unit_personality;
 759   if (for_eh)
 760     {
 761       char *p;
 762
 763       /* Augmentation:
 764          z      Indicates that a uleb128 is present to size the
 765                 augmentation section.
 766          L      Indicates the encoding (and thus presence) of
 767                 an LSDA pointer in the FDE augmentation.
 768          R      Indicates a non-default pointer encoding for
 769                 FDE code pointers.
 770          P      Indicates the presence of an encoding + language
 771                 personality routine in the CIE augmentation.  */
 772
 773       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
 774       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
 775       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
 776
 777       p = augmentation + 1;
 778       if (personality)
 779         {
 780           *p++ = 'P';
 781           augmentation_size += 1 + size_of_encoded_value (per_encoding);
 782           assemble_external_libcall (personality);
 783         }
 784       if (any_lsda_needed)
 785         {
 786           *p++ = 'L';
 787           augmentation_size += 1;
 788         }
 789       if (fde_encoding != DW_EH_PE_absptr)
 790         {
 791           *p++ = 'R';
 792           augmentation_size += 1;
 793         }
 794       if (p > augmentation + 1)
 795         {
 796           augmentation[0] = 'z';
 797           *p = '\0';
 798         }
 799
 800       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
 801       if (personality && per_encoding == DW_EH_PE_aligned)
 802         {
 803           int offset = (  4             /* Length */
 804                         + 4             /* CIE Id */
 805                         + 1             /* CIE version */
 806                         + strlen (augmentation) + 1     /* Augmentation */
 807                         + size_of_uleb128 (1)           /* Code alignment */
 808                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
 809                         + 1             /* RA column */
 810                         + 1             /* Augmentation size */
 811                         + 1             /* Personality encoding */ );
 812           int pad = -offset & (PTR_SIZE - 1);
 813
 814           augmentation_size += pad;
 815
 816           /* Augmentations should be small, so there's scarce need to
 817              iterate for a solution.  Die if we exceed one uleb128 byte.  */
 818           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
 819         }
 820     }
 821
 822   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
 823   if (dw_cie_version >= 4)
 824     {
 825       dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
 826       dw2_asm_output_data (1, 0, "CIE Segment Size");
 827     }
 828   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
 829   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
 830                                "CIE Data Alignment Factor");
 831
 832   if (dw_cie_version == 1)
 833     dw2_asm_output_data (1, return_reg, "CIE RA Column");
 834   else
 835     dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
 836
 837   if (augmentation[0])
 838     {
 839       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
 840       if (personality)
 841         {
 842           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
 843                                eh_data_format_name (per_encoding));
 844           dw2_asm_output_encoded_addr_rtx (per_encoding,
 845                                            personality,
 846                                            true, NULL);
 847         }
 848
 849       if (any_lsda_needed)
 850         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
 851                              eh_data_format_name (lsda_encoding));
 852
 853       if (fde_encoding != DW_EH_PE_absptr)
 854         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
 855                              eh_data_format_name (fde_encoding));
 856     }
 857
 858   FOR_EACH_VEC_ELT (dw_cfi_ref, cie_cfi_vec, i, cfi)
 859     output_cfi (cfi, NULL, for_eh);
 860
 861   /* Pad the CIE out to an address sized boundary.  */
 862   ASM_OUTPUT_ALIGN (asm_out_file,
 863                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
 864   ASM_OUTPUT_LABEL (asm_out_file, l2);
 865
 866   /* Loop through all of the FDE's.  */
 867   FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, i, fde)
 868     {
 869       unsigned int k;
 870
 871       /* Don't emit EH unwind info for leaf functions that don't need it.  */
 872       if (for_eh && !fde_needed_for_eh_p (fde))
 873         continue;
 874
 875       for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
 876         output_fde (fde, for_eh, k, section_start_label, fde_encoding,
 877                     augmentation, any_lsda_needed, lsda_encoding);
 878     }
 879
 880   if (for_eh && targetm.terminate_dw2_eh_frame_info)
 881     dw2_asm_output_data (4, 0, "End of Table");
 882 #ifdef MIPS_DEBUGGING_INFO
 883   /* Work around Irix 6 assembler bug whereby labels at the end of a section
 884      get a value of 0.  Putting .align 0 after the label fixes it.  */
 885   ASM_OUTPUT_ALIGN (asm_out_file, 0);
 886 #endif
 887
 888   /* Turn off app to make assembly quicker.  */
 889   if (flag_debug_asm)
 890     app_disable ();
 891 }
 892
 893 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed.  */
 894
 895 static void
 896 dwarf2out_do_cfi_startproc (bool second)
 897 {
 898   int enc;
 899   rtx ref;
 900   rtx personality = get_personality_function (current_function_decl);
 901
 902   fprintf (asm_out_file, "\t.cfi_startproc\n");
 903
 904   if (personality)
 905     {
 906       enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
 907       ref = personality;
 908
 909       /* ??? The GAS support isn't entirely consistent.  We have to
 910          handle indirect support ourselves, but PC-relative is done
 911          in the assembler.  Further, the assembler can't handle any
 912          of the weirder relocation types.  */
 913       if (enc & DW_EH_PE_indirect)
 914         ref = dw2_force_const_mem (ref, true);
 915
 916       fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
 917       output_addr_const (asm_out_file, ref);
 918       fputc ('\n', asm_out_file);
 919     }
 920
 921   if (crtl->uses_eh_lsda)
 922     {
 923       char lab[20];
 924
 925       enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
 926       ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
 927                                    current_function_funcdef_no);
 928       ref = gen_rtx_SYMBOL_REF (Pmode, lab);
 929       SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
 930
 931       if (enc & DW_EH_PE_indirect)
 932         ref = dw2_force_const_mem (ref, true);
 933
 934       fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
 935       output_addr_const (asm_out_file, ref);
 936       fputc ('\n', asm_out_file);
 937     }
 938 }
 939
 940 /* Allocate CURRENT_FDE.  Immediately initialize all we can, noting that
 941    this allocation may be done before pass_final.  */
 942
 943 dw_fde_ref
 944 dwarf2out_alloc_current_fde (void)
 945 {
 946   dw_fde_ref fde;
 947
 948   fde = ggc_alloc_cleared_dw_fde_node ();
 949   fde->decl = current_function_decl;
 950   fde->funcdef_number = current_function_funcdef_no;
 951   fde->fde_index = VEC_length (dw_fde_ref, fde_vec);
 952   fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
 953   fde->uses_eh_lsda = crtl->uses_eh_lsda;
 954   fde->nothrow = crtl->nothrow;
 955   fde->drap_reg = INVALID_REGNUM;
 956   fde->vdrap_reg = INVALID_REGNUM;
 957
 958   /* Record the FDE associated with this function.  */
 959   cfun->fde = fde;
 960   VEC_safe_push (dw_fde_ref, gc, fde_vec, fde);
 961
 962   return fde;
 963 }
 964
 965 /* Output a marker (i.e. a label) for the beginning of a function, before
 966    the prologue.  */
 967
 968 void
 969 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
 970                           const char *file ATTRIBUTE_UNUSED)
 971 {
 972   char label[MAX_ARTIFICIAL_LABEL_BYTES];
 973   char * dup_label;
 974   dw_fde_ref fde;
 975   section *fnsec;
 976   bool do_frame;
 977
 978   current_function_func_begin_label = NULL;
 979
 980   do_frame = dwarf2out_do_frame ();
 981
 982   /* ??? current_function_func_begin_label is also used by except.c for
 983      call-site information.  We must emit this label if it might be used.  */
 984   if (!do_frame
 985       && (!flag_exceptions
 986           || targetm_common.except_unwind_info (&global_options) != UI_TARGET))
 987     return;
 988
 989   fnsec = function_section (current_function_decl);
 990   switch_to_section (fnsec);
 991   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
 992                                current_function_funcdef_no);
 993   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
 994                           current_function_funcdef_no);
 995   dup_label = xstrdup (label);
 996   current_function_func_begin_label = dup_label;
 997
 998   /* We can elide the fde allocation if we're not emitting debug info.  */
 999   if (!do_frame)
1000     return;
1001
1002   /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1003      emit insns as rtx but bypass the bulk of rest_of_compilation, which
1004      would include pass_dwarf2_frame.  If we've not created the FDE yet,
1005      do so now.  */
1006   fde = cfun->fde;
1007   if (fde == NULL)
1008     fde = dwarf2out_alloc_current_fde ();
1009
1010   /* Initialize the bits of CURRENT_FDE that were not available earlier.  */
1011   fde->dw_fde_begin = dup_label;
1012   fde->dw_fde_current_label = dup_label;
1013   fde->in_std_section = (fnsec == text_section
1014                          || (cold_text_section && fnsec == cold_text_section));
1015
1016   /* We only want to output line number information for the genuine dwarf2
1017      prologue case, not the eh frame case.  */
1018 #ifdef DWARF2_DEBUGGING_INFO
1019   if (file)
1020     dwarf2out_source_line (line, file, 0, true);
1021 #endif
1022
1023   if (dwarf2out_do_cfi_asm ())
1024     dwarf2out_do_cfi_startproc (false);
1025   else
1026     {
1027       rtx personality = get_personality_function (current_function_decl);
1028       if (!current_unit_personality)
1029         current_unit_personality = personality;
1030
1031       /* We cannot keep a current personality per function as without CFI
1032          asm, at the point where we emit the CFI data, there is no current
1033          function anymore.  */
1034       if (personality && current_unit_personality != personality)
1035         sorry ("multiple EH personalities are supported only with assemblers "
1036                "supporting .cfi_personality directive");
1037     }
1038 }
1039
1040 /* Output a marker (i.e. a label) for the end of the generated code
1041    for a function prologue.  This gets called *after* the prologue code has
1042    been generated.  */
1043
1044 void
1045 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
1046                         const char *file ATTRIBUTE_UNUSED)
1047 {
1048   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1049
1050   /* Output a label to mark the endpoint of the code generated for this
1051      function.  */
1052   ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
1053                                current_function_funcdef_no);
1054   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
1055                           current_function_funcdef_no);
1056   cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
1057 }
1058
1059 /* Output a marker (i.e. a label) for the beginning of the generated code
1060    for a function epilogue.  This gets called *before* the prologue code has
1061    been generated.  */
1062
1063 void
1064 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1065                           const char *file ATTRIBUTE_UNUSED)
1066 {
1067   dw_fde_ref fde = cfun->fde;
1068   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1069
1070   if (fde->dw_fde_vms_begin_epilogue)
1071     return;
1072
1073   /* Output a label to mark the endpoint of the code generated for this
1074      function.  */
1075   ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
1076                                current_function_funcdef_no);
1077   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
1078                           current_function_funcdef_no);
1079   fde->dw_fde_vms_begin_epilogue = xstrdup (label);
1080 }
1081
1082 /* Output a marker (i.e. a label) for the absolute end of the generated code
1083    for a function definition.  This gets called *after* the epilogue code has
1084    been generated.  */
1085
1086 void
1087 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1088                         const char *file ATTRIBUTE_UNUSED)
1089 {
1090   dw_fde_ref fde;
1091   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1092
1093   last_var_location_insn = NULL_RTX;
1094   cached_next_real_insn = NULL_RTX;
1095
1096   if (dwarf2out_do_cfi_asm ())
1097     fprintf (asm_out_file, "\t.cfi_endproc\n");
1098
1099   /* Output a label to mark the endpoint of the code generated for this
1100      function.  */
1101   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1102                                current_function_funcdef_no);
1103   ASM_OUTPUT_LABEL (asm_out_file, label);
1104   fde = cfun->fde;
1105   gcc_assert (fde != NULL);
1106   if (fde->dw_fde_second_begin == NULL)
1107     fde->dw_fde_end = xstrdup (label);
1108 }
1109
1110 void
1111 dwarf2out_frame_finish (void)
1112 {
1113   /* Output call frame information.  */
1114   if (targetm.debug_unwind_info () == UI_DWARF2)
1115     output_call_frame_info (0);
1116
1117   /* Output another copy for the unwinder.  */
1118   if ((flag_unwind_tables || flag_exceptions)
1119       && targetm_common.except_unwind_info (&global_options) == UI_DWARF2)
1120     output_call_frame_info (1);
1121 }
1122
1123 /* Note that the current function section is being used for code.  */
1124
1125 static void
1126 dwarf2out_note_section_used (void)
1127 {
1128   section *sec = current_function_section ();
1129   if (sec == text_section)
1130     text_section_used = true;
1131   else if (sec == cold_text_section)
1132     cold_text_section_used = true;
1133 }
1134
1135 static void var_location_switch_text_section (void);
1136 static void set_cur_line_info_table (section *);
1137
1138 void
1139 dwarf2out_switch_text_section (void)
1140 {
1141   section *sect;
1142   dw_fde_ref fde = cfun->fde;
1143
1144   gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
1145
1146   if (!in_cold_section_p)
1147     {
1148       fde->dw_fde_end = crtl->subsections.cold_section_end_label;
1149       fde->dw_fde_second_begin = crtl->subsections.hot_section_label;
1150       fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
1151     }
1152   else
1153     {
1154       fde->dw_fde_end = crtl->subsections.hot_section_end_label;
1155       fde->dw_fde_second_begin = crtl->subsections.cold_section_label;
1156       fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
1157     }
1158   have_multiple_function_sections = true;
1159
1160   /* There is no need to mark used sections when not debugging.  */
1161   if (cold_text_section != NULL)
1162     dwarf2out_note_section_used ();
1163
1164   if (dwarf2out_do_cfi_asm ())
1165     fprintf (asm_out_file, "\t.cfi_endproc\n");
1166
1167   /* Now do the real section switch.  */
1168   sect = current_function_section ();
1169   switch_to_section (sect);
1170
1171   fde->second_in_std_section
1172     = (sect == text_section
1173        || (cold_text_section && sect == cold_text_section));
1174
1175   if (dwarf2out_do_cfi_asm ())
1176     dwarf2out_do_cfi_startproc (true);
1177
1178   var_location_switch_text_section ();
1179
1180   if (cold_text_section != NULL)
1181     set_cur_line_info_table (sect);
1182 }
1183 \f
1184 /* And now, the subset of the debugging information support code necessary
1185    for emitting location expressions.  */
1186
1187 /* Data about a single source file.  */
1188 struct GTY(()) dwarf_file_data {
1189   const char * filename;
1190   int emitted_number;
1191 };
1192
1193 typedef struct GTY(()) deferred_locations_struct
1194 {
1195   tree variable;
1196   dw_die_ref die;
1197 } deferred_locations;
1198
1199 DEF_VEC_O(deferred_locations);
1200 DEF_VEC_ALLOC_O(deferred_locations,gc);
1201
1202 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
1203
1204 DEF_VEC_P(dw_die_ref);
1205 DEF_VEC_ALLOC_P(dw_die_ref,heap);
1206
1207 /* Location lists are ranges + location descriptions for that range,
1208    so you can track variables that are in different places over
1209    their entire life.  */
1210 typedef struct GTY(()) dw_loc_list_struct {
1211   dw_loc_list_ref dw_loc_next;
1212   const char *begin; /* Label for begin address of range */
1213   const char *end;  /* Label for end address of range */
1214   char *ll_symbol; /* Label for beginning of location list.
1215                       Only on head of list */
1216   const char *section; /* Section this loclist is relative to */
1217   dw_loc_descr_ref expr;
1218   hashval_t hash;
1219   /* True if all addresses in this and subsequent lists are known to be
1220      resolved.  */
1221   bool resolved_addr;
1222   /* True if this list has been replaced by dw_loc_next.  */
1223   bool replaced;
1224   bool emitted;
1225   /* True if the range should be emitted even if begin and end
1226      are the same.  */
1227   bool force;
1228 } dw_loc_list_node;
1229
1230 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
1231
1232 /* Convert a DWARF stack opcode into its string name.  */
1233
1234 static const char *
1235 dwarf_stack_op_name (unsigned int op)
1236 {
1237   switch (op)
1238     {
1239     case DW_OP_addr:
1240       return "DW_OP_addr";
1241     case DW_OP_deref:
1242       return "DW_OP_deref";
1243     case DW_OP_const1u:
1244       return "DW_OP_const1u";
1245     case DW_OP_const1s:
1246       return "DW_OP_const1s";
1247     case DW_OP_const2u:
1248       return "DW_OP_const2u";
1249     case DW_OP_const2s:
1250       return "DW_OP_const2s";
1251     case DW_OP_const4u:
1252       return "DW_OP_const4u";
1253     case DW_OP_const4s:
1254       return "DW_OP_const4s";
1255     case DW_OP_const8u:
1256       return "DW_OP_const8u";
1257     case DW_OP_const8s:
1258       return "DW_OP_const8s";
1259     case DW_OP_constu:
1260       return "DW_OP_constu";
1261     case DW_OP_consts:
1262       return "DW_OP_consts";
1263     case DW_OP_dup:
1264       return "DW_OP_dup";
1265     case DW_OP_drop:
1266       return "DW_OP_drop";
1267     case DW_OP_over:
1268       return "DW_OP_over";
1269     case DW_OP_pick:
1270       return "DW_OP_pick";
1271     case DW_OP_swap:
1272       return "DW_OP_swap";
1273     case DW_OP_rot:
1274       return "DW_OP_rot";
1275     case DW_OP_xderef:
1276       return "DW_OP_xderef";
1277     case DW_OP_abs:
1278       return "DW_OP_abs";
1279     case DW_OP_and:
1280       return "DW_OP_and";
1281     case DW_OP_div:
1282       return "DW_OP_div";
1283     case DW_OP_minus:
1284       return "DW_OP_minus";
1285     case DW_OP_mod:
1286       return "DW_OP_mod";
1287     case DW_OP_mul:
1288       return "DW_OP_mul";
1289     case DW_OP_neg:
1290       return "DW_OP_neg";
1291     case DW_OP_not:
1292       return "DW_OP_not";
1293     case DW_OP_or:
1294       return "DW_OP_or";
1295     case DW_OP_plus:
1296       return "DW_OP_plus";
1297     case DW_OP_plus_uconst:
1298       return "DW_OP_plus_uconst";
1299     case DW_OP_shl:
1300       return "DW_OP_shl";
1301     case DW_OP_shr:
1302       return "DW_OP_shr";
1303     case DW_OP_shra:
1304       return "DW_OP_shra";
1305     case DW_OP_xor:
1306       return "DW_OP_xor";
1307     case DW_OP_bra:
1308       return "DW_OP_bra";
1309     case DW_OP_eq:
1310       return "DW_OP_eq";
1311     case DW_OP_ge:
1312       return "DW_OP_ge";
1313     case DW_OP_gt:
1314       return "DW_OP_gt";
1315     case DW_OP_le:
1316       return "DW_OP_le";
1317     case DW_OP_lt:
1318       return "DW_OP_lt";
1319     case DW_OP_ne:
1320       return "DW_OP_ne";
1321     case DW_OP_skip:
1322       return "DW_OP_skip";
1323     case DW_OP_lit0:
1324       return "DW_OP_lit0";
1325     case DW_OP_lit1:
1326       return "DW_OP_lit1";
1327     case DW_OP_lit2:
1328       return "DW_OP_lit2";
1329     case DW_OP_lit3:
1330       return "DW_OP_lit3";
1331     case DW_OP_lit4:
1332       return "DW_OP_lit4";
1333     case DW_OP_lit5:
1334       return "DW_OP_lit5";
1335     case DW_OP_lit6:
1336       return "DW_OP_lit6";
1337     case DW_OP_lit7:
1338       return "DW_OP_lit7";
1339     case DW_OP_lit8:
1340       return "DW_OP_lit8";
1341     case DW_OP_lit9:
1342       return "DW_OP_lit9";
1343     case DW_OP_lit10:
1344       return "DW_OP_lit10";
1345     case DW_OP_lit11:
1346       return "DW_OP_lit11";
1347     case DW_OP_lit12:
1348       return "DW_OP_lit12";
1349     case DW_OP_lit13:
1350       return "DW_OP_lit13";
1351     case DW_OP_lit14:
1352       return "DW_OP_lit14";
1353     case DW_OP_lit15:
1354       return "DW_OP_lit15";
1355     case DW_OP_lit16:
1356       return "DW_OP_lit16";
1357     case DW_OP_lit17:
1358       return "DW_OP_lit17";
1359     case DW_OP_lit18:
1360       return "DW_OP_lit18";
1361     case DW_OP_lit19:
1362       return "DW_OP_lit19";
1363     case DW_OP_lit20:
1364       return "DW_OP_lit20";
1365     case DW_OP_lit21:
1366       return "DW_OP_lit21";
1367     case DW_OP_lit22:
1368       return "DW_OP_lit22";
1369     case DW_OP_lit23:
1370       return "DW_OP_lit23";
1371     case DW_OP_lit24:
1372       return "DW_OP_lit24";
1373     case DW_OP_lit25:
1374       return "DW_OP_lit25";
1375     case DW_OP_lit26:
1376       return "DW_OP_lit26";
1377     case DW_OP_lit27:
1378       return "DW_OP_lit27";
1379     case DW_OP_lit28:
1380       return "DW_OP_lit28";
1381     case DW_OP_lit29:
1382       return "DW_OP_lit29";
1383     case DW_OP_lit30:
1384       return "DW_OP_lit30";
1385     case DW_OP_lit31:
1386       return "DW_OP_lit31";
1387     case DW_OP_reg0:
1388       return "DW_OP_reg0";
1389     case DW_OP_reg1:
1390       return "DW_OP_reg1";
1391     case DW_OP_reg2:
1392       return "DW_OP_reg2";
1393     case DW_OP_reg3:
1394       return "DW_OP_reg3";
1395     case DW_OP_reg4:
1396       return "DW_OP_reg4";
1397     case DW_OP_reg5:
1398       return "DW_OP_reg5";
1399     case DW_OP_reg6:
1400       return "DW_OP_reg6";
1401     case DW_OP_reg7:
1402       return "DW_OP_reg7";
1403     case DW_OP_reg8:
1404       return "DW_OP_reg8";
1405     case DW_OP_reg9:
1406       return "DW_OP_reg9";
1407     case DW_OP_reg10:
1408       return "DW_OP_reg10";
1409     case DW_OP_reg11:
1410       return "DW_OP_reg11";
1411     case DW_OP_reg12:
1412       return "DW_OP_reg12";
1413     case DW_OP_reg13:
1414       return "DW_OP_reg13";
1415     case DW_OP_reg14:
1416       return "DW_OP_reg14";
1417     case DW_OP_reg15:
1418       return "DW_OP_reg15";
1419     case DW_OP_reg16:
1420       return "DW_OP_reg16";
1421     case DW_OP_reg17:
1422       return "DW_OP_reg17";
1423     case DW_OP_reg18:
1424       return "DW_OP_reg18";
1425     case DW_OP_reg19:
1426       return "DW_OP_reg19";
1427     case DW_OP_reg20:
1428       return "DW_OP_reg20";
1429     case DW_OP_reg21:
1430       return "DW_OP_reg21";
1431     case DW_OP_reg22:
1432       return "DW_OP_reg22";
1433     case DW_OP_reg23:
1434       return "DW_OP_reg23";
1435     case DW_OP_reg24:
1436       return "DW_OP_reg24";
1437     case DW_OP_reg25:
1438       return "DW_OP_reg25";
1439     case DW_OP_reg26:
1440       return "DW_OP_reg26";
1441     case DW_OP_reg27:
1442       return "DW_OP_reg27";
1443     case DW_OP_reg28:
1444       return "DW_OP_reg28";
1445     case DW_OP_reg29:
1446       return "DW_OP_reg29";
1447     case DW_OP_reg30:
1448       return "DW_OP_reg30";
1449     case DW_OP_reg31:
1450       return "DW_OP_reg31";
1451     case DW_OP_breg0:
1452       return "DW_OP_breg0";
1453     case DW_OP_breg1:
1454       return "DW_OP_breg1";
1455     case DW_OP_breg2:
1456       return "DW_OP_breg2";
1457     case DW_OP_breg3:
1458       return "DW_OP_breg3";
1459     case DW_OP_breg4:
1460       return "DW_OP_breg4";
1461     case DW_OP_breg5:
1462       return "DW_OP_breg5";
1463     case DW_OP_breg6:
1464       return "DW_OP_breg6";
1465     case DW_OP_breg7:
1466       return "DW_OP_breg7";
1467     case DW_OP_breg8:
1468       return "DW_OP_breg8";
1469     case DW_OP_breg9:
1470       return "DW_OP_breg9";
1471     case DW_OP_breg10:
1472       return "DW_OP_breg10";
1473     case DW_OP_breg11:
1474       return "DW_OP_breg11";
1475     case DW_OP_breg12:
1476       return "DW_OP_breg12";
1477     case DW_OP_breg13:
1478       return "DW_OP_breg13";
1479     case DW_OP_breg14:
1480       return "DW_OP_breg14";
1481     case DW_OP_breg15:
1482       return "DW_OP_breg15";
1483     case DW_OP_breg16:
1484       return "DW_OP_breg16";
1485     case DW_OP_breg17:
1486       return "DW_OP_breg17";
1487     case DW_OP_breg18:
1488       return "DW_OP_breg18";
1489     case DW_OP_breg19:
1490       return "DW_OP_breg19";
1491     case DW_OP_breg20:
1492       return "DW_OP_breg20";
1493     case DW_OP_breg21:
1494       return "DW_OP_breg21";
1495     case DW_OP_breg22:
1496       return "DW_OP_breg22";
1497     case DW_OP_breg23:
1498       return "DW_OP_breg23";
1499     case DW_OP_breg24:
1500       return "DW_OP_breg24";
1501     case DW_OP_breg25:
1502       return "DW_OP_breg25";
1503     case DW_OP_breg26:
1504       return "DW_OP_breg26";
1505     case DW_OP_breg27:
1506       return "DW_OP_breg27";
1507     case DW_OP_breg28:
1508       return "DW_OP_breg28";
1509     case DW_OP_breg29:
1510       return "DW_OP_breg29";
1511     case DW_OP_breg30:
1512       return "DW_OP_breg30";
1513     case DW_OP_breg31:
1514       return "DW_OP_breg31";
1515     case DW_OP_regx:
1516       return "DW_OP_regx";
1517     case DW_OP_fbreg:
1518       return "DW_OP_fbreg";
1519     case DW_OP_bregx:
1520       return "DW_OP_bregx";
1521     case DW_OP_piece:
1522       return "DW_OP_piece";
1523     case DW_OP_deref_size:
1524       return "DW_OP_deref_size";
1525     case DW_OP_xderef_size:
1526       return "DW_OP_xderef_size";
1527     case DW_OP_nop:
1528       return "DW_OP_nop";
1529
1530     case DW_OP_push_object_address:
1531       return "DW_OP_push_object_address";
1532     case DW_OP_call2:
1533       return "DW_OP_call2";
1534     case DW_OP_call4:
1535       return "DW_OP_call4";
1536     case DW_OP_call_ref:
1537       return "DW_OP_call_ref";
1538     case DW_OP_implicit_value:
1539       return "DW_OP_implicit_value";
1540     case DW_OP_stack_value:
1541       return "DW_OP_stack_value";
1542     case DW_OP_form_tls_address:
1543       return "DW_OP_form_tls_address";
1544     case DW_OP_call_frame_cfa:
1545       return "DW_OP_call_frame_cfa";
1546     case DW_OP_bit_piece:
1547       return "DW_OP_bit_piece";
1548
1549     case DW_OP_GNU_push_tls_address:
1550       return "DW_OP_GNU_push_tls_address";
1551     case DW_OP_GNU_uninit:
1552       return "DW_OP_GNU_uninit";
1553     case DW_OP_GNU_encoded_addr:
1554       return "DW_OP_GNU_encoded_addr";
1555     case DW_OP_GNU_implicit_pointer:
1556       return "DW_OP_GNU_implicit_pointer";
1557     case DW_OP_GNU_entry_value:
1558       return "DW_OP_GNU_entry_value";
1559     case DW_OP_GNU_const_type:
1560       return "DW_OP_GNU_const_type";
1561     case DW_OP_GNU_regval_type:
1562       return "DW_OP_GNU_regval_type";
1563     case DW_OP_GNU_deref_type:
1564       return "DW_OP_GNU_deref_type";
1565     case DW_OP_GNU_convert:
1566       return "DW_OP_GNU_convert";
1567     case DW_OP_GNU_reinterpret:
1568       return "DW_OP_GNU_reinterpret";
1569     case DW_OP_GNU_parameter_ref:
1570       return "DW_OP_GNU_parameter_ref";
1571
1572     default:
1573       return "OP_<unknown>";
1574     }
1575 }
1576
1577 /* Return a pointer to a newly allocated location description.  Location
1578    descriptions are simple expression terms that can be strung
1579    together to form more complicated location (address) descriptions.  */
1580
1581 static inline dw_loc_descr_ref
1582 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
1583                unsigned HOST_WIDE_INT oprnd2)
1584 {
1585   dw_loc_descr_ref descr = ggc_alloc_cleared_dw_loc_descr_node ();
1586
1587   descr->dw_loc_opc = op;
1588   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
1589   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
1590   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
1591   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
1592
1593   return descr;
1594 }
1595
1596 /* Return a pointer to a newly allocated location description for
1597    REG and OFFSET.  */
1598
1599 static inline dw_loc_descr_ref
1600 new_reg_loc_descr (unsigned int reg,  unsigned HOST_WIDE_INT offset)
1601 {
1602   if (reg <= 31)
1603     return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
1604                           offset, 0);
1605   else
1606     return new_loc_descr (DW_OP_bregx, reg, offset);
1607 }
1608
1609 /* Add a location description term to a location description expression.  */
1610
1611 static inline void
1612 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
1613 {
1614   dw_loc_descr_ref *d;
1615
1616   /* Find the end of the chain.  */
1617   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
1618     ;
1619
1620   *d = descr;
1621 }
1622
1623 /* Compare two location operands for exact equality.  */
1624
1625 static bool
1626 dw_val_equal_p (dw_val_node *a, dw_val_node *b)
1627 {
1628   if (a->val_class != b->val_class)
1629     return false;
1630   switch (a->val_class)
1631     {
1632     case dw_val_class_none:
1633       return true;
1634     case dw_val_class_addr:
1635       return rtx_equal_p (a->v.val_addr, b->v.val_addr);
1636
1637     case dw_val_class_offset:
1638     case dw_val_class_unsigned_const:
1639     case dw_val_class_const:
1640     case dw_val_class_range_list:
1641     case dw_val_class_lineptr:
1642     case dw_val_class_macptr:
1643       /* These are all HOST_WIDE_INT, signed or unsigned.  */
1644       return a->v.val_unsigned == b->v.val_unsigned;
1645
1646     case dw_val_class_loc:
1647       return a->v.val_loc == b->v.val_loc;
1648     case dw_val_class_loc_list:
1649       return a->v.val_loc_list == b->v.val_loc_list;
1650     case dw_val_class_die_ref:
1651       return a->v.val_die_ref.die == b->v.val_die_ref.die;
1652     case dw_val_class_fde_ref:
1653       return a->v.val_fde_index == b->v.val_fde_index;
1654     case dw_val_class_lbl_id:
1655       return strcmp (a->v.val_lbl_id, b->v.val_lbl_id) == 0;
1656     case dw_val_class_str:
1657       return a->v.val_str == b->v.val_str;
1658     case dw_val_class_flag:
1659       return a->v.val_flag == b->v.val_flag;
1660     case dw_val_class_file:
1661       return a->v.val_file == b->v.val_file;
1662     case dw_val_class_decl_ref:
1663       return a->v.val_decl_ref == b->v.val_decl_ref;
1664
1665     case dw_val_class_const_double:
1666       return (a->v.val_double.high == b->v.val_double.high
1667               && a->v.val_double.low == b->v.val_double.low);
1668
1669     case dw_val_class_vec:
1670       {
1671         size_t a_len = a->v.val_vec.elt_size * a->v.val_vec.length;
1672         size_t b_len = b->v.val_vec.elt_size * b->v.val_vec.length;
1673
1674         return (a_len == b_len
1675                 && !memcmp (a->v.val_vec.array, b->v.val_vec.array, a_len));
1676       }
1677
1678     case dw_val_class_data8:
1679       return memcmp (a->v.val_data8, b->v.val_data8, 8) == 0;
1680
1681     case dw_val_class_vms_delta:
1682       return (!strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1)
1683               && !strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1));
1684     }
1685   gcc_unreachable ();
1686 }
1687
1688 /* Compare two location atoms for exact equality.  */
1689
1690 static bool
1691 loc_descr_equal_p_1 (dw_loc_descr_ref a, dw_loc_descr_ref b)
1692 {
1693   if (a->dw_loc_opc != b->dw_loc_opc)
1694     return false;
1695
1696   /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1697      address size, but since we always allocate cleared storage it
1698      should be zero for other types of locations.  */
1699   if (a->dtprel != b->dtprel)
1700     return false;
1701
1702   return (dw_val_equal_p (&a->dw_loc_oprnd1, &b->dw_loc_oprnd1)
1703           && dw_val_equal_p (&a->dw_loc_oprnd2, &b->dw_loc_oprnd2));
1704 }
1705
1706 /* Compare two complete location expressions for exact equality.  */
1707
1708 bool
1709 loc_descr_equal_p (dw_loc_descr_ref a, dw_loc_descr_ref b)
1710 {
1711   while (1)
1712     {
1713       if (a == b)
1714         return true;
1715       if (a == NULL || b == NULL)
1716         return false;
1717       if (!loc_descr_equal_p_1 (a, b))
1718         return false;
1719
1720       a = a->dw_loc_next;
1721       b = b->dw_loc_next;
1722     }
1723 }
1724
1725
1726 /* Add a constant OFFSET to a location expression.  */
1727
1728 static void
1729 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
1730 {
1731   dw_loc_descr_ref loc;
1732   HOST_WIDE_INT *p;
1733
1734   gcc_assert (*list_head != NULL);
1735
1736   if (!offset)
1737     return;
1738
1739   /* Find the end of the chain.  */
1740   for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
1741     ;
1742
1743   p = NULL;
1744   if (loc->dw_loc_opc == DW_OP_fbreg
1745       || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
1746     p = &loc->dw_loc_oprnd1.v.val_int;
1747   else if (loc->dw_loc_opc == DW_OP_bregx)
1748     p = &loc->dw_loc_oprnd2.v.val_int;
1749
1750   /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1751      offset.  Don't optimize if an signed integer overflow would happen.  */
1752   if (p != NULL
1753       && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
1754           || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
1755     *p += offset;
1756
1757   else if (offset > 0)
1758     loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
1759
1760   else
1761     {
1762       loc->dw_loc_next = int_loc_descriptor (-offset);
1763       add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
1764     }
1765 }
1766
1767 /* Add a constant OFFSET to a location list.  */
1768
1769 static void
1770 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
1771 {
1772   dw_loc_list_ref d;
1773   for (d = list_head; d != NULL; d = d->dw_loc_next)
1774     loc_descr_plus_const (&d->expr, offset);
1775 }
1776
1777 #define DWARF_REF_SIZE  \
1778   (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1779
1780 static unsigned long int get_base_type_offset (dw_die_ref);
1781
1782 /* Return the size of a location descriptor.  */
1783
1784 static unsigned long
1785 size_of_loc_descr (dw_loc_descr_ref loc)
1786 {
1787   unsigned long size = 1;
1788
1789   switch (loc->dw_loc_opc)
1790     {
1791     case DW_OP_addr:
1792       size += DWARF2_ADDR_SIZE;
1793       break;
1794     case DW_OP_const1u:
1795     case DW_OP_const1s:
1796       size += 1;
1797       break;
1798     case DW_OP_const2u:
1799     case DW_OP_const2s:
1800       size += 2;
1801       break;
1802     case DW_OP_const4u:
1803     case DW_OP_const4s:
1804       size += 4;
1805       break;
1806     case DW_OP_const8u:
1807     case DW_OP_const8s:
1808       size += 8;
1809       break;
1810     case DW_OP_constu:
1811       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1812       break;
1813     case DW_OP_consts:
1814       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1815       break;
1816     case DW_OP_pick:
1817       size += 1;
1818       break;
1819     case DW_OP_plus_uconst:
1820       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1821       break;
1822     case DW_OP_skip:
1823     case DW_OP_bra:
1824       size += 2;
1825       break;
1826     case DW_OP_breg0:
1827     case DW_OP_breg1:
1828     case DW_OP_breg2:
1829     case DW_OP_breg3:
1830     case DW_OP_breg4:
1831     case DW_OP_breg5:
1832     case DW_OP_breg6:
1833     case DW_OP_breg7:
1834     case DW_OP_breg8:
1835     case DW_OP_breg9:
1836     case DW_OP_breg10:
1837     case DW_OP_breg11:
1838     case DW_OP_breg12:
1839     case DW_OP_breg13:
1840     case DW_OP_breg14:
1841     case DW_OP_breg15:
1842     case DW_OP_breg16:
1843     case DW_OP_breg17:
1844     case DW_OP_breg18:
1845     case DW_OP_breg19:
1846     case DW_OP_breg20:
1847     case DW_OP_breg21:
1848     case DW_OP_breg22:
1849     case DW_OP_breg23:
1850     case DW_OP_breg24:
1851     case DW_OP_breg25:
1852     case DW_OP_breg26:
1853     case DW_OP_breg27:
1854     case DW_OP_breg28:
1855     case DW_OP_breg29:
1856     case DW_OP_breg30:
1857     case DW_OP_breg31:
1858       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1859       break;
1860     case DW_OP_regx:
1861       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1862       break;
1863     case DW_OP_fbreg:
1864       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1865       break;
1866     case DW_OP_bregx:
1867       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1868       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1869       break;
1870     case DW_OP_piece:
1871       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1872       break;
1873     case DW_OP_bit_piece:
1874       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1875       size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
1876       break;
1877     case DW_OP_deref_size:
1878     case DW_OP_xderef_size:
1879       size += 1;
1880       break;
1881     case DW_OP_call2:
1882       size += 2;
1883       break;
1884     case DW_OP_call4:
1885       size += 4;
1886       break;
1887     case DW_OP_call_ref:
1888       size += DWARF_REF_SIZE;
1889       break;
1890     case DW_OP_implicit_value:
1891       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1892               + loc->dw_loc_oprnd1.v.val_unsigned;
1893       break;
1894     case DW_OP_GNU_implicit_pointer:
1895       size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1896       break;
1897     case DW_OP_GNU_entry_value:
1898       {
1899         unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
1900         size += size_of_uleb128 (op_size) + op_size;
1901         break;
1902       }
1903     case DW_OP_GNU_const_type:
1904       {
1905         unsigned long o
1906           = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1907         size += size_of_uleb128 (o) + 1;
1908         switch (loc->dw_loc_oprnd2.val_class)
1909           {
1910           case dw_val_class_vec:
1911             size += loc->dw_loc_oprnd2.v.val_vec.length
1912                     * loc->dw_loc_oprnd2.v.val_vec.elt_size;
1913             break;
1914           case dw_val_class_const:
1915             size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1916             break;
1917           case dw_val_class_const_double:
1918             size += 2 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1919             break;
1920           default:
1921             gcc_unreachable ();
1922           }
1923         break;
1924       }
1925     case DW_OP_GNU_regval_type:
1926       {
1927         unsigned long o
1928           = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1929         size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1930                 + size_of_uleb128 (o);
1931       }
1932       break;
1933     case DW_OP_GNU_deref_type:
1934       {
1935         unsigned long o
1936           = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1937         size += 1 + size_of_uleb128 (o);
1938       }
1939       break;
1940     case DW_OP_GNU_convert:
1941     case DW_OP_GNU_reinterpret:
1942       if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
1943         size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1944       else
1945         {
1946           unsigned long o
1947             = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1948           size += size_of_uleb128 (o);
1949         }
1950       break;
1951     case DW_OP_GNU_parameter_ref:
1952       size += 4;
1953       break;
1954     default:
1955       break;
1956     }
1957
1958   return size;
1959 }
1960
1961 /* Return the size of a series of location descriptors.  */
1962
1963 unsigned long
1964 size_of_locs (dw_loc_descr_ref loc)
1965 {
1966   dw_loc_descr_ref l;
1967   unsigned long size;
1968
1969   /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1970      field, to avoid writing to a PCH file.  */
1971   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1972     {
1973       if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
1974         break;
1975       size += size_of_loc_descr (l);
1976     }
1977   if (! l)
1978     return size;
1979
1980   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1981     {
1982       l->dw_loc_addr = size;
1983       size += size_of_loc_descr (l);
1984     }
1985
1986   return size;
1987 }
1988
1989 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
1990 static void get_ref_die_offset_label (char *, dw_die_ref);
1991 static unsigned long int get_ref_die_offset (dw_die_ref);
1992
1993 /* Output location description stack opcode's operands (if any).
1994    The for_eh_or_skip parameter controls whether register numbers are
1995    converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1996    hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1997    info).  This should be suppressed for the cases that have not been converted
1998    (i.e. symbolic debug info), by setting the parameter < 0.  See PR47324.  */
1999
2000 static void
2001 output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
2002 {
2003   dw_val_ref val1 = &loc->dw_loc_oprnd1;
2004   dw_val_ref val2 = &loc->dw_loc_oprnd2;
2005
2006   switch (loc->dw_loc_opc)
2007     {
2008 #ifdef DWARF2_DEBUGGING_INFO
2009     case DW_OP_const2u:
2010     case DW_OP_const2s:
2011       dw2_asm_output_data (2, val1->v.val_int, NULL);
2012       break;
2013     case DW_OP_const4u:
2014       if (loc->dtprel)
2015         {
2016           gcc_assert (targetm.asm_out.output_dwarf_dtprel);
2017           targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
2018                                                val1->v.val_addr);
2019           fputc ('\n', asm_out_file);
2020           break;
2021         }
2022       /* FALLTHRU */
2023     case DW_OP_const4s:
2024       dw2_asm_output_data (4, val1->v.val_int, NULL);
2025       break;
2026     case DW_OP_const8u:
2027       if (loc->dtprel)
2028         {
2029           gcc_assert (targetm.asm_out.output_dwarf_dtprel);
2030           targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
2031                                                val1->v.val_addr);
2032           fputc ('\n', asm_out_file);
2033           break;
2034         }
2035       /* FALLTHRU */
2036     case DW_OP_const8s:
2037       gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2038       dw2_asm_output_data (8, val1->v.val_int, NULL);
2039       break;
2040     case DW_OP_skip:
2041     case DW_OP_bra:
2042       {
2043         int offset;
2044
2045         gcc_assert (val1->val_class == dw_val_class_loc);
2046         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2047
2048         dw2_asm_output_data (2, offset, NULL);
2049       }
2050       break;
2051     case DW_OP_implicit_value:
2052       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2053       switch (val2->val_class)
2054         {
2055         case dw_val_class_const:
2056           dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
2057           break;
2058         case dw_val_class_vec:
2059           {
2060             unsigned int elt_size = val2->v.val_vec.elt_size;
2061             unsigned int len = val2->v.val_vec.length;
2062             unsigned int i;
2063             unsigned char *p;
2064
2065             if (elt_size > sizeof (HOST_WIDE_INT))
2066               {
2067                 elt_size /= 2;
2068                 len *= 2;
2069               }
2070             for (i = 0, p = val2->v.val_vec.array;
2071                  i < len;
2072                  i++, p += elt_size)
2073               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2074                                    "fp or vector constant word %u", i);
2075           }
2076           break;
2077         case dw_val_class_const_double:
2078           {
2079             unsigned HOST_WIDE_INT first, second;
2080
2081             if (WORDS_BIG_ENDIAN)
2082               {
2083                 first = val2->v.val_double.high;
2084                 second = val2->v.val_double.low;
2085               }
2086             else
2087               {
2088                 first = val2->v.val_double.low;
2089                 second = val2->v.val_double.high;
2090               }
2091             dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2092                                  first, NULL);
2093             dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2094                                  second, NULL);
2095           }
2096           break;
2097         case dw_val_class_addr:
2098           gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
2099           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
2100           break;
2101         default:
2102           gcc_unreachable ();
2103         }
2104       break;
2105 #else
2106     case DW_OP_const2u:
2107     case DW_OP_const2s:
2108     case DW_OP_const4u:
2109     case DW_OP_const4s:
2110     case DW_OP_const8u:
2111     case DW_OP_const8s:
2112     case DW_OP_skip:
2113     case DW_OP_bra:
2114     case DW_OP_implicit_value:
2115       /* We currently don't make any attempt to make sure these are
2116          aligned properly like we do for the main unwind info, so
2117          don't support emitting things larger than a byte if we're
2118          only doing unwinding.  */
2119       gcc_unreachable ();
2120 #endif
2121     case DW_OP_const1u:
2122     case DW_OP_const1s:
2123       dw2_asm_output_data (1, val1->v.val_int, NULL);
2124       break;
2125     case DW_OP_constu:
2126       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2127       break;
2128     case DW_OP_consts:
2129       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2130       break;
2131     case DW_OP_pick:
2132       dw2_asm_output_data (1, val1->v.val_int, NULL);
2133       break;
2134     case DW_OP_plus_uconst:
2135       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2136       break;
2137     case DW_OP_breg0:
2138     case DW_OP_breg1:
2139     case DW_OP_breg2:
2140     case DW_OP_breg3:
2141     case DW_OP_breg4:
2142     case DW_OP_breg5:
2143     case DW_OP_breg6:
2144     case DW_OP_breg7:
2145     case DW_OP_breg8:
2146     case DW_OP_breg9:
2147     case DW_OP_breg10:
2148     case DW_OP_breg11:
2149     case DW_OP_breg12:
2150     case DW_OP_breg13:
2151     case DW_OP_breg14:
2152     case DW_OP_breg15:
2153     case DW_OP_breg16:
2154     case DW_OP_breg17:
2155     case DW_OP_breg18:
2156     case DW_OP_breg19:
2157     case DW_OP_breg20:
2158     case DW_OP_breg21:
2159     case DW_OP_breg22:
2160     case DW_OP_breg23:
2161     case DW_OP_breg24:
2162     case DW_OP_breg25:
2163     case DW_OP_breg26:
2164     case DW_OP_breg27:
2165     case DW_OP_breg28:
2166     case DW_OP_breg29:
2167     case DW_OP_breg30:
2168     case DW_OP_breg31:
2169       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2170       break;
2171     case DW_OP_regx:
2172       {
2173         unsigned r = val1->v.val_unsigned;
2174         if (for_eh_or_skip >= 0)
2175           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2176         gcc_assert (size_of_uleb128 (r)
2177                     == size_of_uleb128 (val1->v.val_unsigned));
2178         dw2_asm_output_data_uleb128 (r, NULL);
2179       }
2180       break;
2181     case DW_OP_fbreg:
2182       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2183       break;
2184     case DW_OP_bregx:
2185       {
2186         unsigned r = val1->v.val_unsigned;
2187         if (for_eh_or_skip >= 0)
2188           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2189         gcc_assert (size_of_uleb128 (r)
2190                     == size_of_uleb128 (val1->v.val_unsigned));
2191         dw2_asm_output_data_uleb128 (r, NULL);
2192         dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2193       }
2194       break;
2195     case DW_OP_piece:
2196       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2197       break;
2198     case DW_OP_bit_piece:
2199       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2200       dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
2201       break;
2202     case DW_OP_deref_size:
2203     case DW_OP_xderef_size:
2204       dw2_asm_output_data (1, val1->v.val_int, NULL);
2205       break;
2206
2207     case DW_OP_addr:
2208       if (loc->dtprel)
2209         {
2210           if (targetm.asm_out.output_dwarf_dtprel)
2211             {
2212               targetm.asm_out.output_dwarf_dtprel (asm_out_file,
2213                                                    DWARF2_ADDR_SIZE,
2214                                                    val1->v.val_addr);
2215               fputc ('\n', asm_out_file);
2216             }
2217           else
2218             gcc_unreachable ();
2219         }
2220       else
2221         {
2222 #ifdef DWARF2_DEBUGGING_INFO
2223           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2224 #else
2225           gcc_unreachable ();
2226 #endif
2227         }
2228       break;
2229
2230     case DW_OP_GNU_implicit_pointer:
2231       {
2232         char label[MAX_ARTIFICIAL_LABEL_BYTES
2233                    + HOST_BITS_PER_WIDE_INT / 2 + 2];
2234         gcc_assert (val1->val_class == dw_val_class_die_ref);
2235         get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2236         dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2237         dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2238       }
2239       break;
2240
2241     case DW_OP_GNU_entry_value:
2242       dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
2243       output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
2244       break;
2245
2246     case DW_OP_GNU_const_type:
2247       {
2248         unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
2249         gcc_assert (o);
2250         dw2_asm_output_data_uleb128 (o, NULL);
2251         switch (val2->val_class)
2252           {
2253           case dw_val_class_const:
2254             l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2255             dw2_asm_output_data (1, l, NULL);
2256             dw2_asm_output_data (l, val2->v.val_int, NULL);
2257             break;
2258           case dw_val_class_vec:
2259             {
2260               unsigned int elt_size = val2->v.val_vec.elt_size;
2261               unsigned int len = val2->v.val_vec.length;
2262               unsigned int i;
2263               unsigned char *p;
2264
2265               l = len * elt_size;
2266               dw2_asm_output_data (1, l, NULL);
2267               if (elt_size > sizeof (HOST_WIDE_INT))
2268                 {
2269                   elt_size /= 2;
2270                   len *= 2;
2271                 }
2272               for (i = 0, p = val2->v.val_vec.array;
2273                    i < len;
2274                    i++, p += elt_size)
2275                 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2276                                      "fp or vector constant word %u", i);
2277             }
2278             break;
2279           case dw_val_class_const_double:
2280             {
2281               unsigned HOST_WIDE_INT first, second;
2282               l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2283
2284               dw2_asm_output_data (1, 2 * l, NULL);
2285               if (WORDS_BIG_ENDIAN)
2286                 {
2287                   first = val2->v.val_double.high;
2288                   second = val2->v.val_double.low;
2289                 }
2290               else
2291                 {
2292                   first = val2->v.val_double.low;
2293                   second = val2->v.val_double.high;
2294                 }
2295               dw2_asm_output_data (l, first, NULL);
2296               dw2_asm_output_data (l, second, NULL);
2297             }
2298             break;
2299           default:
2300             gcc_unreachable ();
2301           }
2302       }
2303       break;
2304     case DW_OP_GNU_regval_type:
2305       {
2306         unsigned r = val1->v.val_unsigned;
2307         unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2308         gcc_assert (o);
2309         if (for_eh_or_skip >= 0)
2310           {
2311             r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2312             gcc_assert (size_of_uleb128 (r)
2313                         == size_of_uleb128 (val1->v.val_unsigned));
2314           }
2315         dw2_asm_output_data_uleb128 (r, NULL);
2316         dw2_asm_output_data_uleb128 (o, NULL);
2317       }
2318       break;
2319     case DW_OP_GNU_deref_type:
2320       {
2321         unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2322         gcc_assert (o);
2323         dw2_asm_output_data (1, val1->v.val_int, NULL);
2324         dw2_asm_output_data_uleb128 (o, NULL);
2325       }
2326       break;
2327     case DW_OP_GNU_convert:
2328     case DW_OP_GNU_reinterpret:
2329       if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
2330         dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2331       else
2332         {
2333           unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
2334           gcc_assert (o);
2335           dw2_asm_output_data_uleb128 (o, NULL);
2336         }
2337       break;
2338
2339     case DW_OP_GNU_parameter_ref:
2340       {
2341         unsigned long o;
2342         gcc_assert (val1->val_class == dw_val_class_die_ref);
2343         o = get_ref_die_offset (val1->v.val_die_ref.die);
2344         dw2_asm_output_data (4, o, NULL);
2345       }
2346       break;
2347
2348     default:
2349       /* Other codes have no operands.  */
2350       break;
2351     }
2352 }
2353
2354 /* Output a sequence of location operations.
2355    The for_eh_or_skip parameter controls whether register numbers are
2356    converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2357    hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2358    info).  This should be suppressed for the cases that have not been converted
2359    (i.e. symbolic debug info), by setting the parameter < 0.  See PR47324.  */
2360
2361 void
2362 output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
2363 {
2364   for (; loc != NULL; loc = loc->dw_loc_next)
2365     {
2366       enum dwarf_location_atom opc = loc->dw_loc_opc;
2367       /* Output the opcode.  */
2368       if (for_eh_or_skip >= 0
2369           && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2370         {
2371           unsigned r = (opc - DW_OP_breg0);
2372           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2373           gcc_assert (r <= 31);
2374           opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2375         }
2376       else if (for_eh_or_skip >= 0
2377                && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2378         {
2379           unsigned r = (opc - DW_OP_reg0);
2380           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2381           gcc_assert (r <= 31);
2382           opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2383         }
2384
2385       dw2_asm_output_data (1, opc,
2386                              "%s", dwarf_stack_op_name (opc));
2387
2388       /* Output the operand(s) (if any).  */
2389       output_loc_operands (loc, for_eh_or_skip);
2390     }
2391 }
2392
2393 /* Output location description stack opcode's operands (if any).
2394    The output is single bytes on a line, suitable for .cfi_escape.  */
2395
2396 static void
2397 output_loc_operands_raw (dw_loc_descr_ref loc)
2398 {
2399   dw_val_ref val1 = &loc->dw_loc_oprnd1;
2400   dw_val_ref val2 = &loc->dw_loc_oprnd2;
2401
2402   switch (loc->dw_loc_opc)
2403     {
2404     case DW_OP_addr:
2405     case DW_OP_implicit_value:
2406       /* We cannot output addresses in .cfi_escape, only bytes.  */
2407       gcc_unreachable ();
2408
2409     case DW_OP_const1u:
2410     case DW_OP_const1s:
2411     case DW_OP_pick:
2412     case DW_OP_deref_size:
2413     case DW_OP_xderef_size:
2414       fputc (',', asm_out_file);
2415       dw2_asm_output_data_raw (1, val1->v.val_int);
2416       break;
2417
2418     case DW_OP_const2u:
2419     case DW_OP_const2s:
2420       fputc (',', asm_out_file);
2421       dw2_asm_output_data_raw (2, val1->v.val_int);
2422       break;
2423
2424     case DW_OP_const4u:
2425     case DW_OP_const4s:
2426       fputc (',', asm_out_file);
2427       dw2_asm_output_data_raw (4, val1->v.val_int);
2428       break;
2429
2430     case DW_OP_const8u:
2431     case DW_OP_const8s:
2432       gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2433       fputc (',', asm_out_file);
2434       dw2_asm_output_data_raw (8, val1->v.val_int);
2435       break;
2436
2437     case DW_OP_skip:
2438     case DW_OP_bra:
2439       {
2440         int offset;
2441
2442         gcc_assert (val1->val_class == dw_val_class_loc);
2443         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2444
2445         fputc (',', asm_out_file);
2446         dw2_asm_output_data_raw (2, offset);
2447       }
2448       break;
2449
2450     case DW_OP_regx:
2451       {
2452         unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2453         gcc_assert (size_of_uleb128 (r)
2454                     == size_of_uleb128 (val1->v.val_unsigned));
2455         fputc (',', asm_out_file);
2456         dw2_asm_output_data_uleb128_raw (r);
2457       }
2458       break;
2459
2460     case DW_OP_constu:
2461     case DW_OP_plus_uconst:
2462     case DW_OP_piece:
2463       fputc (',', asm_out_file);
2464       dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2465       break;
2466
2467     case DW_OP_bit_piece:
2468       fputc (',', asm_out_file);
2469       dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2470       dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
2471       break;
2472
2473     case DW_OP_consts:
2474     case DW_OP_breg0:
2475     case DW_OP_breg1:
2476     case DW_OP_breg2:
2477     case DW_OP_breg3:
2478     case DW_OP_breg4:
2479     case DW_OP_breg5:
2480     case DW_OP_breg6:
2481     case DW_OP_breg7:
2482     case DW_OP_breg8:
2483     case DW_OP_breg9:
2484     case DW_OP_breg10:
2485     case DW_OP_breg11:
2486     case DW_OP_breg12:
2487     case DW_OP_breg13:
2488     case DW_OP_breg14:
2489     case DW_OP_breg15:
2490     case DW_OP_breg16:
2491     case DW_OP_breg17:
2492     case DW_OP_breg18:
2493     case DW_OP_breg19:
2494     case DW_OP_breg20:
2495     case DW_OP_breg21:
2496     case DW_OP_breg22:
2497     case DW_OP_breg23:
2498     case DW_OP_breg24:
2499     case DW_OP_breg25:
2500     case DW_OP_breg26:
2501     case DW_OP_breg27:
2502     case DW_OP_breg28:
2503     case DW_OP_breg29:
2504     case DW_OP_breg30:
2505     case DW_OP_breg31:
2506     case DW_OP_fbreg:
2507       fputc (',', asm_out_file);
2508       dw2_asm_output_data_sleb128_raw (val1->v.val_int);
2509       break;
2510
2511     case DW_OP_bregx:
2512       {
2513         unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2514         gcc_assert (size_of_uleb128 (r)
2515                     == size_of_uleb128 (val1->v.val_unsigned));
2516         fputc (',', asm_out_file);
2517         dw2_asm_output_data_uleb128_raw (r);
2518         fputc (',', asm_out_file);
2519         dw2_asm_output_data_sleb128_raw (val2->v.val_int);
2520       }
2521       break;
2522
2523     case DW_OP_GNU_implicit_pointer:
2524     case DW_OP_GNU_entry_value:
2525     case DW_OP_GNU_const_type:
2526     case DW_OP_GNU_regval_type:
2527     case DW_OP_GNU_deref_type:
2528     case DW_OP_GNU_convert:
2529     case DW_OP_GNU_reinterpret:
2530     case DW_OP_GNU_parameter_ref:
2531       gcc_unreachable ();
2532       break;
2533
2534     default:
2535       /* Other codes have no operands.  */
2536       break;
2537     }
2538 }
2539
2540 void
2541 output_loc_sequence_raw (dw_loc_descr_ref loc)
2542 {
2543   while (1)
2544     {
2545       enum dwarf_location_atom opc = loc->dw_loc_opc;
2546       /* Output the opcode.  */
2547       if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2548         {
2549           unsigned r = (opc - DW_OP_breg0);
2550           r = DWARF2_FRAME_REG_OUT (r, 1);
2551           gcc_assert (r <= 31);
2552           opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2553         }
2554       else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2555         {
2556           unsigned r = (opc - DW_OP_reg0);
2557           r = DWARF2_FRAME_REG_OUT (r, 1);
2558           gcc_assert (r <= 31);
2559           opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2560         }
2561       /* Output the opcode.  */
2562       fprintf (asm_out_file, "%#x", opc);
2563       output_loc_operands_raw (loc);
2564
2565       if (!loc->dw_loc_next)
2566         break;
2567       loc = loc->dw_loc_next;
2568
2569       fputc (',', asm_out_file);
2570     }
2571 }
2572
2573 /* This function builds a dwarf location descriptor sequence from a
2574    dw_cfa_location, adding the given OFFSET to the result of the
2575    expression.  */
2576
2577 struct dw_loc_descr_struct *
2578 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
2579 {
2580   struct dw_loc_descr_struct *head, *tmp;
2581
2582   offset += cfa->offset;
2583
2584   if (cfa->indirect)
2585     {
2586       head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
2587       head->dw_loc_oprnd1.val_class = dw_val_class_const;
2588       tmp = new_loc_descr (DW_OP_deref, 0, 0);
2589       add_loc_descr (&head, tmp);
2590       if (offset != 0)
2591         {
2592           tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
2593           add_loc_descr (&head, tmp);
2594         }
2595     }
2596   else
2597     head = new_reg_loc_descr (cfa->reg, offset);
2598
2599   return head;
2600 }
2601
2602 /* This function builds a dwarf location descriptor sequence for
2603    the address at OFFSET from the CFA when stack is aligned to
2604    ALIGNMENT byte.  */
2605
2606 struct dw_loc_descr_struct *
2607 build_cfa_aligned_loc (dw_cfa_location *cfa,
2608                        HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
2609 {
2610   struct dw_loc_descr_struct *head;
2611   unsigned int dwarf_fp
2612     = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
2613
2614   /* When CFA is defined as FP+OFFSET, emulate stack alignment.  */
2615   if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0)
2616     {
2617       head = new_reg_loc_descr (dwarf_fp, 0);
2618       add_loc_descr (&head, int_loc_descriptor (alignment));
2619       add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
2620       loc_descr_plus_const (&head, offset);
2621     }
2622   else
2623     head = new_reg_loc_descr (dwarf_fp, offset);
2624   return head;
2625 }
2626 \f
2627 /* And now, the support for symbolic debugging information.  */
2628
2629 /* .debug_str support.  */
2630 static int output_indirect_string (void **, void *);
2631
2632 static void dwarf2out_init (const char *);
2633 static void dwarf2out_finish (const char *);
2634 static void dwarf2out_assembly_start (void);
2635 static void dwarf2out_define (unsigned int, const char *);
2636 static void dwarf2out_undef (unsigned int, const char *);
2637 static void dwarf2out_start_source_file (unsigned, const char *);
2638 static void dwarf2out_end_source_file (unsigned);
2639 static void dwarf2out_function_decl (tree);
2640 static void dwarf2out_begin_block (unsigned, unsigned);
2641 static void dwarf2out_end_block (unsigned, unsigned);
2642 static bool dwarf2out_ignore_block (const_tree);
2643 static void dwarf2out_global_decl (tree);
2644 static void dwarf2out_type_decl (tree, int);
2645 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
2646 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
2647                                                  dw_die_ref);
2648 static void dwarf2out_abstract_function (tree);
2649 static void dwarf2out_var_location (rtx);
2650 static void dwarf2out_begin_function (tree);
2651 static void dwarf2out_set_name (tree, tree);
2652
2653 /* The debug hooks structure.  */
2654
2655 const struct gcc_debug_hooks dwarf2_debug_hooks =
2656 {
2657   dwarf2out_init,
2658   dwarf2out_finish,
2659   dwarf2out_assembly_start,
2660   dwarf2out_define,
2661   dwarf2out_undef,
2662   dwarf2out_start_source_file,
2663   dwarf2out_end_source_file,
2664   dwarf2out_begin_block,
2665   dwarf2out_end_block,
2666   dwarf2out_ignore_block,
2667   dwarf2out_source_line,
2668   dwarf2out_begin_prologue,
2669 #if VMS_DEBUGGING_INFO
2670   dwarf2out_vms_end_prologue,
2671   dwarf2out_vms_begin_epilogue,
2672 #else
2673   debug_nothing_int_charstar,
2674   debug_nothing_int_charstar,
2675 #endif
2676   dwarf2out_end_epilogue,
2677   dwarf2out_begin_function,
2678   debug_nothing_int,            /* end_function */
2679   dwarf2out_function_decl,      /* function_decl */
2680   dwarf2out_global_decl,
2681   dwarf2out_type_decl,          /* type_decl */
2682   dwarf2out_imported_module_or_decl,
2683   debug_nothing_tree,           /* deferred_inline_function */
2684   /* The DWARF 2 backend tries to reduce debugging bloat by not
2685      emitting the abstract description of inline functions until
2686      something tries to reference them.  */
2687   dwarf2out_abstract_function,  /* outlining_inline_function */
2688   debug_nothing_rtx,            /* label */
2689   debug_nothing_int,            /* handle_pch */
2690   dwarf2out_var_location,
2691   dwarf2out_switch_text_section,
2692   dwarf2out_set_name,
2693   1,                            /* start_end_main_source_file */
2694   TYPE_SYMTAB_IS_DIE            /* tree_type_symtab_field */
2695 };
2696 \f
2697 /* NOTE: In the comments in this file, many references are made to
2698    "Debugging Information Entries".  This term is abbreviated as `DIE'
2699    throughout the remainder of this file.  */
2700
2701 /* An internal representation of the DWARF output is built, and then
2702    walked to generate the DWARF debugging info.  The walk of the internal
2703    representation is done after the entire program has been compiled.
2704    The types below are used to describe the internal representation.  */
2705
2706 /* Whether to put type DIEs into their own section .debug_types instead
2707    of making them part of the .debug_info section.  Only supported for
2708    Dwarf V4 or higher and the user didn't disable them through
2709    -fno-debug-types-section.  It is more efficient to put them in a
2710    separate comdat sections since the linker will then be able to
2711    remove duplicates.  But not all tools support .debug_types sections
2712    yet.  */
2713
2714 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2715
2716 /* Various DIE's use offsets relative to the beginning of the
2717    .debug_info section to refer to each other.  */
2718
2719 typedef long int dw_offset;
2720
2721 /* Define typedefs here to avoid circular dependencies.  */
2722
2723 typedef struct dw_attr_struct *dw_attr_ref;
2724 typedef struct dw_line_info_struct *dw_line_info_ref;
2725 typedef struct pubname_struct *pubname_ref;
2726 typedef struct dw_ranges_struct *dw_ranges_ref;
2727 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
2728 typedef struct comdat_type_struct *comdat_type_node_ref;
2729
2730 /* The entries in the line_info table more-or-less mirror the opcodes
2731    that are used in the real dwarf line table.  Arrays of these entries
2732    are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2733    supported.  */
2734
2735 enum dw_line_info_opcode {
2736   /* Emit DW_LNE_set_address; the operand is the label index.  */
2737   LI_set_address,
2738
2739   /* Emit a row to the matrix with the given line.  This may be done
2740      via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2741      special opcodes.  */
2742   LI_set_line,
2743
2744   /* Emit a DW_LNS_set_file.  */
2745   LI_set_file,
2746
2747   /* Emit a DW_LNS_set_column.  */
2748   LI_set_column,
2749
2750   /* Emit a DW_LNS_negate_stmt; the operand is ignored.  */
2751   LI_negate_stmt,
2752
2753   /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored.  */
2754   LI_set_prologue_end,
2755   LI_set_epilogue_begin,
2756
2757   /* Emit a DW_LNE_set_discriminator.  */
2758   LI_set_discriminator
2759 };
2760
2761 typedef struct GTY(()) dw_line_info_struct {
2762   enum dw_line_info_opcode opcode;
2763   unsigned int val;
2764 } dw_line_info_entry;
2765
2766 DEF_VEC_O(dw_line_info_entry);
2767 DEF_VEC_ALLOC_O(dw_line_info_entry, gc);
2768
2769 typedef struct GTY(()) dw_line_info_table_struct {
2770   /* The label that marks the end of this section.  */
2771   const char *end_label;
2772
2773   /* The values for the last row of the matrix, as collected in the table.
2774      These are used to minimize the changes to the next row.  */
2775   unsigned int file_num;
2776   unsigned int line_num;
2777   unsigned int column_num;
2778   int discrim_num;
2779   bool is_stmt;
2780   bool in_use;
2781
2782   VEC(dw_line_info_entry, gc) *entries;
2783 } dw_line_info_table;
2784
2785 typedef dw_line_info_table *dw_line_info_table_p;
2786
2787 DEF_VEC_P(dw_line_info_table_p);
2788 DEF_VEC_ALLOC_P(dw_line_info_table_p, gc);
2789
2790 /* Each DIE attribute has a field specifying the attribute kind,
2791    a link to the next attribute in the chain, and an attribute value.
2792    Attributes are typically linked below the DIE they modify.  */
2793
2794 typedef struct GTY(()) dw_attr_struct {
2795   enum dwarf_attribute dw_attr;
2796   dw_val_node dw_attr_val;
2797 }
2798 dw_attr_node;
2799
2800 DEF_VEC_O(dw_attr_node);
2801 DEF_VEC_ALLOC_O(dw_attr_node,gc);
2802
2803 /* The Debugging Information Entry (DIE) structure.  DIEs form a tree.
2804    The children of each node form a circular list linked by
2805    die_sib.  die_child points to the node *before* the "first" child node.  */
2806
2807 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
2808   union die_symbol_or_type_node
2809     {
2810       char * GTY ((tag ("0"))) die_symbol;
2811       comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
2812     }
2813   GTY ((desc ("use_debug_types"))) die_id;
2814   VEC(dw_attr_node,gc) * die_attr;
2815   dw_die_ref die_parent;
2816   dw_die_ref die_child;
2817   dw_die_ref die_sib;
2818   dw_die_ref die_definition; /* ref from a specification to its definition */
2819   dw_offset die_offset;
2820   unsigned long die_abbrev;
2821   int die_mark;
2822   /* Die is used and must not be pruned as unused.  */
2823   int die_perennial_p;
2824   unsigned int decl_id;
2825   enum dwarf_tag die_tag;
2826 }
2827 die_node;
2828
2829 /* Evaluate 'expr' while 'c' is set to each child of DIE in order.  */
2830 #define FOR_EACH_CHILD(die, c, expr) do {       \
2831   c = die->die_child;                           \
2832   if (c) do {                                   \
2833     c = c->die_sib;                             \
2834     expr;                                       \
2835   } while (c != die->die_child);                \
2836 } while (0)
2837
2838 /* The pubname structure */
2839
2840 typedef struct GTY(()) pubname_struct {
2841   dw_die_ref die;
2842   const char *name;
2843 }
2844 pubname_entry;
2845
2846 DEF_VEC_O(pubname_entry);
2847 DEF_VEC_ALLOC_O(pubname_entry, gc);
2848
2849 struct GTY(()) dw_ranges_struct {
2850   /* If this is positive, it's a block number, otherwise it's a
2851      bitwise-negated index into dw_ranges_by_label.  */
2852   int num;
2853 };
2854
2855 /* A structure to hold a macinfo entry.  */
2856
2857 typedef struct GTY(()) macinfo_struct {
2858   unsigned char code;
2859   unsigned HOST_WIDE_INT lineno;
2860   const char *info;
2861 }
2862 macinfo_entry;
2863
2864 DEF_VEC_O(macinfo_entry);
2865 DEF_VEC_ALLOC_O(macinfo_entry, gc);
2866
2867 struct GTY(()) dw_ranges_by_label_struct {
2868   const char *begin;
2869   const char *end;
2870 };
2871
2872 /* The comdat type node structure.  */
2873 typedef struct GTY(()) comdat_type_struct
2874 {
2875   dw_die_ref root_die;
2876   dw_die_ref type_die;
2877   char signature[DWARF_TYPE_SIGNATURE_SIZE];
2878   struct comdat_type_struct *next;
2879 }
2880 comdat_type_node;
2881
2882 /* The limbo die list structure.  */
2883 typedef struct GTY(()) limbo_die_struct {
2884   dw_die_ref die;
2885   tree created_for;
2886   struct limbo_die_struct *next;
2887 }
2888 limbo_die_node;
2889
2890 typedef struct skeleton_chain_struct
2891 {
2892   dw_die_ref old_die;
2893   dw_die_ref new_die;
2894   struct skeleton_chain_struct *parent;
2895 }
2896 skeleton_chain_node;
2897
2898 /* Define a macro which returns nonzero for a TYPE_DECL which was
2899    implicitly generated for a type.
2900
2901    Note that, unlike the C front-end (which generates a NULL named
2902    TYPE_DECL node for each complete tagged type, each array type,
2903    and each function type node created) the C++ front-end generates
2904    a _named_ TYPE_DECL node for each tagged type node created.
2905    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2906    generate a DW_TAG_typedef DIE for them.  Likewise with the Ada
2907    front-end, but for each type, tagged or not.  */
2908
2909 #define TYPE_DECL_IS_STUB(decl)                         \
2910   (DECL_NAME (decl) == NULL_TREE                        \
2911    || (DECL_ARTIFICIAL (decl)                           \
2912        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
2913            /* This is necessary for stub decls that     \
2914               appear in nested inline functions.  */    \
2915            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2916                && (decl_ultimate_origin (decl)          \
2917                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2918
2919 /* Information concerning the compilation unit's programming
2920    language, and compiler version.  */
2921
2922 /* Fixed size portion of the DWARF compilation unit header.  */
2923 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2924   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2925
2926 /* Fixed size portion of the DWARF comdat type unit header.  */
2927 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2928   (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2929    + DWARF_OFFSET_SIZE)
2930
2931 /* Fixed size portion of public names info.  */
2932 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2933
2934 /* Fixed size portion of the address range info.  */
2935 #define DWARF_ARANGES_HEADER_SIZE                                       \
2936   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
2937                 DWARF2_ADDR_SIZE * 2)                                   \
2938    - DWARF_INITIAL_LENGTH_SIZE)
2939
2940 /* Size of padding portion in the address range info.  It must be
2941    aligned to twice the pointer size.  */
2942 #define DWARF_ARANGES_PAD_SIZE \
2943   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2944                 DWARF2_ADDR_SIZE * 2)                              \
2945    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2946
2947 /* Use assembler line directives if available.  */
2948 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2949 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2950 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2951 #else
2952 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2953 #endif
2954 #endif
2955
2956 /* Minimum line offset in a special line info. opcode.
2957    This value was chosen to give a reasonable range of values.  */
2958 #define DWARF_LINE_BASE  -10
2959
2960 /* First special line opcode - leave room for the standard opcodes.  */
2961 #define DWARF_LINE_OPCODE_BASE  ((int)DW_LNS_set_isa + 1)
2962
2963 /* Range of line offsets in a special line info. opcode.  */
2964 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
2965
2966 /* Flag that indicates the initial value of the is_stmt_start flag.
2967    In the present implementation, we do not mark any lines as
2968    the beginning of a source statement, because that information
2969    is not made available by the GCC front-end.  */
2970 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2971
2972 /* Maximum number of operations per instruction bundle.  */
2973 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2974 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2975 #endif
2976
2977 /* This location is used by calc_die_sizes() to keep track
2978    the offset of each DIE within the .debug_info section.  */
2979 static unsigned long next_die_offset;
2980
2981 /* Record the root of the DIE's built for the current compilation unit.  */
2982 static GTY(()) dw_die_ref single_comp_unit_die;
2983
2984 /* A list of type DIEs that have been separated into comdat sections.  */
2985 static GTY(()) comdat_type_node *comdat_type_list;
2986
2987 /* A list of DIEs with a NULL parent waiting to be relocated.  */
2988 static GTY(()) limbo_die_node *limbo_die_list;
2989
2990 /* A list of DIEs for which we may have to generate
2991    DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set.  */
2992 static GTY(()) limbo_die_node *deferred_asm_name;
2993
2994 /* Filenames referenced by this compilation unit.  */
2995 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
2996
2997 /* A hash table of references to DIE's that describe declarations.
2998    The key is a DECL_UID() which is a unique number identifying each decl.  */
2999 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3000
3001 /* A hash table of references to DIE's that describe COMMON blocks.
3002    The key is DECL_UID() ^ die_parent.  */
3003 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
3004
3005 typedef struct GTY(()) die_arg_entry_struct {
3006     dw_die_ref die;
3007     tree arg;
3008 } die_arg_entry;
3009
3010 DEF_VEC_O(die_arg_entry);
3011 DEF_VEC_ALLOC_O(die_arg_entry,gc);
3012
3013 /* Node of the variable location list.  */
3014 struct GTY ((chain_next ("%h.next"))) var_loc_node {
3015   /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3016      EXPR_LIST chain.  For small bitsizes, bitsize is encoded
3017      in mode of the EXPR_LIST node and first EXPR_LIST operand
3018      is either NOTE_INSN_VAR_LOCATION for a piece with a known
3019      location or NULL for padding.  For larger bitsizes,
3020      mode is 0 and first operand is a CONCAT with bitsize
3021      as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3022      NULL as second operand.  */
3023   rtx GTY (()) loc;
3024   const char * GTY (()) label;
3025   struct var_loc_node * GTY (()) next;
3026 };
3027
3028 /* Variable location list.  */
3029 struct GTY (()) var_loc_list_def {
3030   struct var_loc_node * GTY (()) first;
3031
3032   /* Pointer to the last but one or last element of the
3033      chained list.  If the list is empty, both first and
3034      last are NULL, if the list contains just one node
3035      or the last node certainly is not redundant, it points
3036      to the last node, otherwise points to the last but one.
3037      Do not mark it for GC because it is marked through the chain.  */
3038   struct var_loc_node * GTY ((skip ("%h"))) last;
3039
3040   /* Pointer to the last element before section switch,
3041      if NULL, either sections weren't switched or first
3042      is after section switch.  */
3043   struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
3044
3045   /* DECL_UID of the variable decl.  */
3046   unsigned int decl_id;
3047 };
3048 typedef struct var_loc_list_def var_loc_list;
3049
3050 /* Call argument location list.  */
3051 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
3052   rtx GTY (()) call_arg_loc_note;
3053   const char * GTY (()) label;
3054   tree GTY (()) block;
3055   bool tail_call_p;
3056   rtx GTY (()) symbol_ref;
3057   struct call_arg_loc_node * GTY (()) next;
3058 };
3059
3060
3061 /* Table of decl location linked lists.  */
3062 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3063
3064 /* Head and tail of call_arg_loc chain.  */
3065 static GTY (()) struct call_arg_loc_node *call_arg_locations;
3066 static struct call_arg_loc_node *call_arg_loc_last;
3067
3068 /* Number of call sites in the current function.  */
3069 static int call_site_count = -1;
3070 /* Number of tail call sites in the current function.  */
3071 static int tail_call_site_count = -1;
3072
3073 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
3074    DIEs.  */
3075 static VEC (dw_die_ref, heap) *block_map;
3076
3077 /* A cached location list.  */
3078 struct GTY (()) cached_dw_loc_list_def {
3079   /* The DECL_UID of the decl that this entry describes.  */
3080   unsigned int decl_id;
3081
3082   /* The cached location list.  */
3083   dw_loc_list_ref loc_list;
3084 };
3085 typedef struct cached_dw_loc_list_def cached_dw_loc_list;
3086
3087 /* Table of cached location lists.  */
3088 static GTY ((param_is (cached_dw_loc_list))) htab_t cached_dw_loc_list_table;
3089
3090 /* A pointer to the base of a list of references to DIE's that
3091    are uniquely identified by their tag, presence/absence of
3092    children DIE's, and list of attribute/value pairs.  */
3093 static GTY((length ("abbrev_die_table_allocated")))
3094   dw_die_ref *abbrev_die_table;
3095
3096 /* Number of elements currently allocated for abbrev_die_table.  */
3097 static GTY(()) unsigned abbrev_die_table_allocated;
3098
3099 /* Number of elements in type_die_table currently in use.  */
3100 static GTY(()) unsigned abbrev_die_table_in_use;
3101
3102 /* Size (in elements) of increments by which we may expand the
3103    abbrev_die_table.  */
3104 #define ABBREV_DIE_TABLE_INCREMENT 256
3105
3106 /* A global counter for generating labels for line number data.  */
3107 static unsigned int line_info_label_num;
3108
3109 /* The current table to which we should emit line number information
3110    for the current function.  This will be set up at the beginning of
3111    assembly for the function.  */
3112 static dw_line_info_table *cur_line_info_table;
3113
3114 /* The two default tables of line number info.  */
3115 static GTY(()) dw_line_info_table *text_section_line_info;
3116 static GTY(()) dw_line_info_table *cold_text_section_line_info;
3117
3118 /* The set of all non-default tables of line number info.  */
3119 static GTY(()) VEC (dw_line_info_table_p, gc) *separate_line_info;
3120
3121 /* A flag to tell pubnames/types export if there is an info section to
3122    refer to.  */
3123 static bool info_section_emitted;
3124
3125 /* A pointer to the base of a table that contains a list of publicly
3126    accessible names.  */
3127 static GTY (()) VEC (pubname_entry, gc) *  pubname_table;
3128
3129 /* A pointer to the base of a table that contains a list of publicly
3130    accessible types.  */
3131 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
3132
3133 /* A pointer to the base of a table that contains a list of macro
3134    defines/undefines (and file start/end markers).  */
3135 static GTY (()) VEC (macinfo_entry, gc) * macinfo_table;
3136
3137 /* True if .debug_macinfo or .debug_macros section is going to be
3138    emitted.  */
3139 #define have_macinfo \
3140   (debug_info_level >= DINFO_LEVEL_VERBOSE \
3141    && !VEC_empty (macinfo_entry, macinfo_table))
3142
3143 /* Array of dies for which we should generate .debug_ranges info.  */
3144 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3145
3146 /* Number of elements currently allocated for ranges_table.  */
3147 static GTY(()) unsigned ranges_table_allocated;
3148
3149 /* Number of elements in ranges_table currently in use.  */
3150 static GTY(()) unsigned ranges_table_in_use;
3151
3152 /* Array of pairs of labels referenced in ranges_table.  */
3153 static GTY ((length ("ranges_by_label_allocated")))
3154      dw_ranges_by_label_ref ranges_by_label;
3155
3156 /* Number of elements currently allocated for ranges_by_label.  */
3157 static GTY(()) unsigned ranges_by_label_allocated;
3158
3159 /* Number of elements in ranges_by_label currently in use.  */
3160 static GTY(()) unsigned ranges_by_label_in_use;
3161
3162 /* Size (in elements) of increments by which we may expand the
3163    ranges_table.  */
3164 #define RANGES_TABLE_INCREMENT 64
3165
3166 /* Whether we have location lists that need outputting */
3167 static GTY(()) bool have_location_lists;
3168
3169 /* Unique label counter.  */
3170 static GTY(()) unsigned int loclabel_num;
3171
3172 /* Unique label counter for point-of-call tables.  */
3173 static GTY(()) unsigned int poc_label_num;
3174
3175 /* Record whether the function being analyzed contains inlined functions.  */
3176 static int current_function_has_inlines;
3177
3178 /* The last file entry emitted by maybe_emit_file().  */
3179 static GTY(()) struct dwarf_file_data * last_emitted_file;
3180
3181 /* Number of internal labels generated by gen_internal_sym().  */
3182 static GTY(()) int label_num;
3183
3184 /* Cached result of previous call to lookup_filename.  */
3185 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
3186
3187 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
3188
3189 /* Instances of generic types for which we need to generate debug
3190    info that describe their generic parameters and arguments. That
3191    generation needs to happen once all types are properly laid out so
3192    we do it at the end of compilation.  */
3193 static GTY(()) VEC(tree,gc) *generic_type_instances;
3194
3195 /* Offset from the "steady-state frame pointer" to the frame base,
3196    within the current function.  */
3197 static HOST_WIDE_INT frame_pointer_fb_offset;
3198 static bool frame_pointer_fb_offset_valid;
3199
3200 static VEC (dw_die_ref, heap) *base_types;
3201
3202 /* Forward declarations for functions defined in this file.  */
3203
3204 static int is_pseudo_reg (const_rtx);
3205 static tree type_main_variant (tree);
3206 static int is_tagged_type (const_tree);
3207 static const char *dwarf_tag_name (unsigned);
3208 static const char *dwarf_attr_name (unsigned);
3209 static const char *dwarf_form_name (unsigned);
3210 static tree decl_ultimate_origin (const_tree);
3211 static tree decl_class_context (tree);
3212 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3213 static inline enum dw_val_class AT_class (dw_attr_ref);
3214 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3215 static inline unsigned AT_flag (dw_attr_ref);
3216 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3217 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3218 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3219 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3220 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
3221                            HOST_WIDE_INT, unsigned HOST_WIDE_INT);
3222 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3223                                unsigned int, unsigned char *);
3224 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
3225 static hashval_t debug_str_do_hash (const void *);
3226 static int debug_str_eq (const void *, const void *);
3227 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3228 static inline const char *AT_string (dw_attr_ref);
3229 static enum dwarf_form AT_string_form (dw_attr_ref);
3230 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3231 static void add_AT_specification (dw_die_ref, dw_die_ref);
3232 static inline dw_die_ref AT_ref (dw_attr_ref);
3233 static inline int AT_ref_external (dw_attr_ref);
3234 static inline void set_AT_ref_external (dw_attr_ref, int);
3235 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3236 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3237 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3238 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3239                              dw_loc_list_ref);
3240 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3241 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3242 static inline rtx AT_addr (dw_attr_ref);
3243 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3244 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
3245 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
3246 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3247                            unsigned HOST_WIDE_INT);
3248 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3249                                unsigned long);
3250 static inline const char *AT_lbl (dw_attr_ref);
3251 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3252 static const char *get_AT_low_pc (dw_die_ref);
3253 static const char *get_AT_hi_pc (dw_die_ref);
3254 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3255 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3256 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3257 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3258 static bool is_cxx (void);
3259 static bool is_fortran (void);
3260 static bool is_ada (void);
3261 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3262 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3263 static void add_child_die (dw_die_ref, dw_die_ref);
3264 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3265 static dw_die_ref lookup_type_die (tree);
3266 static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
3267 static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
3268 static void equate_type_number_to_die (tree, dw_die_ref);
3269 static hashval_t decl_die_table_hash (const void *);
3270 static int decl_die_table_eq (const void *, const void *);
3271 static dw_die_ref lookup_decl_die (tree);
3272 static hashval_t common_block_die_table_hash (const void *);
3273 static int common_block_die_table_eq (const void *, const void *);
3274 static hashval_t decl_loc_table_hash (const void *);
3275 static int decl_loc_table_eq (const void *, const void *);
3276 static var_loc_list *lookup_decl_loc (const_tree);
3277 static void equate_decl_number_to_die (tree, dw_die_ref);
3278 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
3279 static void print_spaces (FILE *);
3280 static void print_die (dw_die_ref, FILE *);
3281 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3282 static dw_die_ref pop_compile_unit (dw_die_ref);
3283 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3284 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3285 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3286 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
3287 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
3288 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
3289 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
3290                                    struct md5_ctx *, int *);
3291 struct checksum_attributes;
3292 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
3293 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
3294 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
3295 static void generate_type_signature (dw_die_ref, comdat_type_node *);
3296 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3297 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
3298 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3299 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3300 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3301 static void compute_section_prefix (dw_die_ref);
3302 static int is_type_die (dw_die_ref);
3303 static int is_comdat_die (dw_die_ref);
3304 static int is_symbol_die (dw_die_ref);
3305 static void assign_symbol_names (dw_die_ref);
3306 static void break_out_includes (dw_die_ref);
3307 static int is_declaration_die (dw_die_ref);
3308 static int should_move_die_to_comdat (dw_die_ref);
3309 static dw_die_ref clone_as_declaration (dw_die_ref);
3310 static dw_die_ref clone_die (dw_die_ref);
3311 static dw_die_ref clone_tree (dw_die_ref);
3312 static dw_die_ref copy_declaration_context (dw_die_ref, dw_die_ref);
3313 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
3314 static void generate_skeleton_bottom_up (skeleton_chain_node *);
3315 static dw_die_ref generate_skeleton (dw_die_ref);
3316 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
3317                                                          dw_die_ref,
3318                                                          dw_die_ref);
3319 static void break_out_comdat_types (dw_die_ref);
3320 static dw_die_ref copy_ancestor_tree (dw_die_ref, dw_die_ref, htab_t);
3321 static void copy_decls_walk (dw_die_ref, dw_die_ref, htab_t);
3322 static void copy_decls_for_unworthy_types (dw_die_ref);
3323
3324 static hashval_t htab_cu_hash (const void *);
3325 static int htab_cu_eq (const void *, const void *);
3326 static void htab_cu_del (void *);
3327 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
3328 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
3329 static void add_sibling_attributes (dw_die_ref);
3330 static void build_abbrev_table (dw_die_ref);
3331 static void output_location_lists (dw_die_ref);
3332 static int constant_size (unsigned HOST_WIDE_INT);
3333 static unsigned long size_of_die (dw_die_ref);
3334 static void calc_die_sizes (dw_die_ref);
3335 static void calc_base_type_die_sizes (void);
3336 static void mark_dies (dw_die_ref);
3337 static void unmark_dies (dw_die_ref);
3338 static void unmark_all_dies (dw_die_ref);
3339 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
3340 static unsigned long size_of_aranges (void);
3341 static enum dwarf_form value_format (dw_attr_ref);
3342 static void output_value_format (dw_attr_ref);
3343 static void output_abbrev_section (void);
3344 static void output_die_symbol (dw_die_ref);
3345 static void output_die (dw_die_ref);
3346 static void output_compilation_unit_header (void);
3347 static void output_comp_unit (dw_die_ref, int);
3348 static void output_comdat_type_unit (comdat_type_node *);
3349 static const char *dwarf2_name (tree, int);
3350 static void add_pubname (tree, dw_die_ref);
3351 static void add_pubname_string (const char *, dw_die_ref);
3352 static void add_pubtype (tree, dw_die_ref);
3353 static void output_pubnames (VEC (pubname_entry,gc) *);
3354 static void output_aranges (unsigned long);
3355 static unsigned int add_ranges_num (int);
3356 static unsigned int add_ranges (const_tree);
3357 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
3358                                   bool *);
3359 static void output_ranges (void);
3360 static dw_line_info_table *new_line_info_table (void);
3361 static void output_line_info (void);
3362 static void output_file_names (void);
3363 static dw_die_ref base_type_die (tree);
3364 static int is_base_type (tree);
3365 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
3366 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
3367 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
3368 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
3369 static int type_is_enum (const_tree);
3370 static unsigned int dbx_reg_number (const_rtx);
3371 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
3372 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
3373 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
3374                                                 enum var_init_status);
3375 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
3376                                                      enum var_init_status);
3377 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
3378                                          enum var_init_status);
3379 static int is_based_loc (const_rtx);
3380 static int resolve_one_addr (rtx *, void *);
3381 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
3382                                                enum var_init_status);
3383 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
3384                                         enum var_init_status);
3385 static dw_loc_list_ref loc_list_from_tree (tree, int);
3386 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
3387 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3388 static tree field_type (const_tree);
3389 static unsigned int simple_type_align_in_bits (const_tree);
3390 static unsigned int simple_decl_align_in_bits (const_tree);
3391 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
3392 static HOST_WIDE_INT field_byte_offset (const_tree);
3393 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3394                                          dw_loc_list_ref);
3395 static void add_data_member_location_attribute (dw_die_ref, tree);
3396 static bool add_const_value_attribute (dw_die_ref, rtx);
3397 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
3398 static void insert_double (double_int, unsigned char *);
3399 static void insert_float (const_rtx, unsigned char *);
3400 static rtx rtl_for_decl_location (tree);
3401 static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool,
3402                                                    enum dwarf_attribute);
3403 static bool tree_add_const_value_attribute (dw_die_ref, tree);
3404 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
3405 static void add_name_attribute (dw_die_ref, const char *);
3406 static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
3407 static void add_comp_dir_attribute (dw_die_ref);
3408 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
3409 static void add_subscript_info (dw_die_ref, tree, bool);
3410 static void add_byte_size_attribute (dw_die_ref, tree);
3411 static void add_bit_offset_attribute (dw_die_ref, tree);
3412 static void add_bit_size_attribute (dw_die_ref, tree);
3413 static void add_prototyped_attribute (dw_die_ref, tree);
3414 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
3415 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3416 static void add_src_coords_attributes (dw_die_ref, tree);
3417 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
3418 static void push_decl_scope (tree);
3419 static void pop_decl_scope (void);
3420 static dw_die_ref scope_die_for (tree, dw_die_ref);
3421 static inline int local_scope_p (dw_die_ref);
3422 static inline int class_scope_p (dw_die_ref);
3423 static inline int class_or_namespace_scope_p (dw_die_ref);
3424 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
3425 static void add_calling_convention_attribute (dw_die_ref, tree);
3426 static const char *type_tag (const_tree);
3427 static tree member_declared_type (const_tree);
3428 #if 0
3429 static const char *decl_start_label (tree);
3430 #endif
3431 static void gen_array_type_die (tree, dw_die_ref);
3432 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
3433 #if 0
3434 static void gen_entry_point_die (tree, dw_die_ref);
3435 #endif
3436 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
3437 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
3438 static dw_die_ref gen_formal_parameter_pack_die  (tree, tree, dw_die_ref, tree*);
3439 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3440 static void gen_formal_types_die (tree, dw_die_ref);
3441 static void gen_subprogram_die (tree, dw_die_ref);
3442 static void gen_variable_die (tree, tree, dw_die_ref);
3443 static void gen_const_die (tree, dw_die_ref);
3444 static void gen_label_die (tree, dw_die_ref);
3445 static void gen_lexical_block_die (tree, dw_die_ref, int);
3446 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
3447 static void gen_field_die (tree, dw_die_ref);
3448 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3449 static dw_die_ref gen_compile_unit_die (const char *);
3450 static void gen_inheritance_die (tree, tree, dw_die_ref);
3451 static void gen_member_die (tree, dw_die_ref);
3452 static void gen_struct_or_union_type_die (tree, dw_die_ref,
3453                                                 enum debug_info_usage);
3454 static void gen_subroutine_type_die (tree, dw_die_ref);
3455 static void gen_typedef_die (tree, dw_die_ref);
3456 static void gen_type_die (tree, dw_die_ref);
3457 static void gen_block_die (tree, dw_die_ref, int);
3458 static void decls_for_scope (tree, dw_die_ref, int);
3459 static inline int is_redundant_typedef (const_tree);
3460 static bool is_naming_typedef_decl (const_tree);
3461 static inline dw_die_ref get_context_die (tree);
3462 static void gen_namespace_die (tree, dw_die_ref);
3463 static dw_die_ref gen_decl_die (tree, tree, dw_die_ref);
3464 static dw_die_ref force_decl_die (tree);
3465 static dw_die_ref force_type_die (tree);
3466 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
3467 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
3468 static struct dwarf_file_data * lookup_filename (const char *);
3469 static void retry_incomplete_types (void);
3470 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3471 static void gen_generic_params_dies (tree);
3472 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
3473 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
3474 static void splice_child_die (dw_die_ref, dw_die_ref);
3475 static int file_info_cmp (const void *, const void *);
3476 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
3477                                      const char *, const char *);
3478 static void output_loc_list (dw_loc_list_ref);
3479 static char *gen_internal_sym (const char *);
3480
3481 static void prune_unmark_dies (dw_die_ref);
3482 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
3483 static void prune_unused_types_mark (dw_die_ref, int);
3484 static void prune_unused_types_walk (dw_die_ref);
3485 static void prune_unused_types_walk_attribs (dw_die_ref);
3486 static void prune_unused_types_prune (dw_die_ref);
3487 static void prune_unused_types (void);
3488 static int maybe_emit_file (struct dwarf_file_data *fd);
3489 static inline const char *AT_vms_delta1 (dw_attr_ref);
3490 static inline const char *AT_vms_delta2 (dw_attr_ref);
3491 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
3492                                      const char *, const char *);
3493 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
3494 static void gen_remaining_tmpl_value_param_die_attribute (void);
3495 static bool generic_type_p (tree);
3496 static void schedule_generic_params_dies_gen (tree t);
3497 static void gen_scheduled_generic_parms_dies (void);
3498
3499 /* Section names used to hold DWARF debugging information.  */
3500 #ifndef DEBUG_INFO_SECTION
3501 #define DEBUG_INFO_SECTION      ".debug_info"
3502 #endif
3503 #ifndef DEBUG_ABBREV_SECTION
3504 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
3505 #endif
3506 #ifndef DEBUG_ARANGES_SECTION
3507 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
3508 #endif
3509 #ifndef DEBUG_MACINFO_SECTION
3510 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
3511 #endif
3512 #ifndef DEBUG_MACRO_SECTION
3513 #define DEBUG_MACRO_SECTION     ".debug_macro"
3514 #endif
3515 #ifndef DEBUG_LINE_SECTION
3516 #define DEBUG_LINE_SECTION      ".debug_line"
3517 #endif
3518 #ifndef DEBUG_LOC_SECTION
3519 #define DEBUG_LOC_SECTION       ".debug_loc"
3520 #endif
3521 #ifndef DEBUG_PUBNAMES_SECTION
3522 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
3523 #endif
3524 #ifndef DEBUG_PUBTYPES_SECTION
3525 #define DEBUG_PUBTYPES_SECTION  ".debug_pubtypes"
3526 #endif
3527 #ifndef DEBUG_STR_SECTION
3528 #define DEBUG_STR_SECTION       ".debug_str"
3529 #endif
3530 #ifndef DEBUG_RANGES_SECTION
3531 #define DEBUG_RANGES_SECTION    ".debug_ranges"
3532 #endif
3533
3534 /* Standard ELF section names for compiled code and data.  */
3535 #ifndef TEXT_SECTION_NAME
3536 #define TEXT_SECTION_NAME       ".text"
3537 #endif
3538
3539 /* Section flags for .debug_str section.  */
3540 #define DEBUG_STR_SECTION_FLAGS \
3541   (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings               \
3542    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
3543    : SECTION_DEBUG)
3544
3545 /* Labels we insert at beginning sections we can reference instead of
3546    the section names themselves.  */
3547
3548 #ifndef TEXT_SECTION_LABEL
3549 #define TEXT_SECTION_LABEL              "Ltext"
3550 #endif
3551 #ifndef COLD_TEXT_SECTION_LABEL
3552 #define COLD_TEXT_SECTION_LABEL         "Ltext_cold"
3553 #endif
3554 #ifndef DEBUG_LINE_SECTION_LABEL
3555 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
3556 #endif
3557 #ifndef DEBUG_INFO_SECTION_LABEL
3558 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
3559 #endif
3560 #ifndef DEBUG_ABBREV_SECTION_LABEL
3561 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
3562 #endif
3563 #ifndef DEBUG_LOC_SECTION_LABEL
3564 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
3565 #endif
3566 #ifndef DEBUG_RANGES_SECTION_LABEL
3567 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
3568 #endif
3569 #ifndef DEBUG_MACINFO_SECTION_LABEL
3570 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
3571 #endif
3572 #ifndef DEBUG_MACRO_SECTION_LABEL
3573 #define DEBUG_MACRO_SECTION_LABEL       "Ldebug_macro"
3574 #endif
3575
3576
3577 /* Definitions of defaults for formats and names of various special
3578    (artificial) labels which may be generated within this file (when the -g
3579    options is used and DWARF2_DEBUGGING_INFO is in effect.
3580    If necessary, these may be overridden from within the tm.h file, but
3581    typically, overriding these defaults is unnecessary.  */
3582
3583 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3584 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3585 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3586 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3587 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3588 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3589 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3590 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3591 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3592 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3593
3594 #ifndef TEXT_END_LABEL
3595 #define TEXT_END_LABEL          "Letext"
3596 #endif
3597 #ifndef COLD_END_LABEL
3598 #define COLD_END_LABEL          "Letext_cold"
3599 #endif
3600 #ifndef BLOCK_BEGIN_LABEL
3601 #define BLOCK_BEGIN_LABEL       "LBB"
3602 #endif
3603 #ifndef BLOCK_END_LABEL
3604 #define BLOCK_END_LABEL         "LBE"
3605 #endif
3606 #ifndef LINE_CODE_LABEL
3607 #define LINE_CODE_LABEL         "LM"
3608 #endif
3609
3610 \f
3611 /* Return the root of the DIE's built for the current compilation unit.  */
3612 static dw_die_ref
3613 comp_unit_die (void)
3614 {
3615   if (!single_comp_unit_die)
3616     single_comp_unit_die = gen_compile_unit_die (NULL);
3617   return single_comp_unit_die;
3618 }
3619
3620 /* We allow a language front-end to designate a function that is to be
3621    called to "demangle" any name before it is put into a DIE.  */
3622
3623 static const char *(*demangle_name_func) (const char *);