Subversion Repositories openrisc

/* Output Dwarf2 format symbol table information from GCC.

   Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,

   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012

   Free Software Foundation, Inc.

   Contributed by Gary Funck (gary@intrepid.com).

   Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).

   Extensively modified by Jason Merrill (jason@cygnus.com).

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

/* TODO: Emit .debug_line header even when there are no functions, since

           the file numbers are used by .debug_info.  Alternately, leave

           out locations for types and decls.

         Avoid talking about ctors and op= for PODs.

         Factor out common prologue sequences into multiple CIEs.  */

/* The first part of this file deals with the DWARF 2 frame unwind

   information, which is also used by the GCC efficient exception handling

   mechanism.  The second part, controlled only by an #ifdef

   DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging

   information.  */

/* DWARF2 Abbreviation Glossary:

   CFA = Canonical Frame Address

           a fixed address on the stack which identifies a call frame.

           We define it to be the value of SP just before the call insn.

           The CFA register and offset, which may change during the course

           of the function, are used to calculate its value at runtime.

   CFI = Call Frame Instruction

           an instruction for the DWARF2 abstract machine

   CIE = Common Information Entry

           information describing information common to one or more FDEs

   DIE = Debugging Information Entry

   FDE = Frame Description Entry

           information describing the stack call frame, in particular,

           how to restore registers

   DW_CFA_... = DWARF2 CFA call frame instruction

   DW_TAG_... = DWARF2 DIE tag */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "version.h"

#include "flags.h"

#include "rtl.h"

#include "hard-reg-set.h"

#include "regs.h"

#include "insn-config.h"

#include "reload.h"

#include "function.h"

#include "output.h"

#include "expr.h"

#include "libfuncs.h"

#include "except.h"

#include "dwarf2.h"

#include "dwarf2out.h"

#include "dwarf2asm.h"

#include "toplev.h"

#include "ggc.h"

#include "md5.h"

#include "tm_p.h"

#include "diagnostic.h"

#include "tree-pretty-print.h"

#include "debug.h"

#include "target.h"

#include "common/common-target.h"

#include "langhooks.h"

#include "hashtab.h"

#include "cgraph.h"

#include "input.h"

#include "gimple.h"

#include "tree-pass.h"

#include "tree-flow.h"

#include "cfglayout.h"

#include "opts.h"

static void dwarf2out_source_line (unsigned int, const char *, int, bool);

static rtx last_var_location_insn;

static rtx cached_next_real_insn;

#ifdef VMS_DEBUGGING_INFO

int vms_file_stats_name (const char *, long long *, long *, char *, int *);

/* Define this macro to be a nonzero value if the directory specifications

    which are output in the debug info should end with a separator.  */

#define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1

/* Define this macro to evaluate to a nonzero value if GCC should refrain

   from generating indirect strings in DWARF2 debug information, for instance

   if your target is stuck with an old version of GDB that is unable to

   process them properly or uses VMS Debug.  */

#define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1

#else

#define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0

#define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0

#endif

/* ??? Poison these here until it can be done generically.  They've been

   totally replaced in this file; make sure it stays that way.  */

#undef DWARF2_UNWIND_INFO

#undef DWARF2_FRAME_INFO

#if (GCC_VERSION >= 3000)

 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO

#endif

/* The size of the target's pointer type.  */

#ifndef PTR_SIZE

#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)

#endif

/* Array of RTXes referenced by the debugging information, which therefore

   must be kept around forever.  */

static GTY(()) VEC(rtx,gc) *used_rtx_array;

/* A pointer to the base of a list of incomplete types which might be

   completed at some later time.  incomplete_types_list needs to be a

   VEC(tree,gc) because we want to tell the garbage collector about

   it.  */

static GTY(()) VEC(tree,gc) *incomplete_types;

/* A pointer to the base of a table of references to declaration

   scopes.  This table is a display which tracks the nesting

   of declaration scopes at the current scope and containing

   scopes.  This table is used to find the proper place to

   define type declaration DIE's.  */

static GTY(()) VEC(tree,gc) *decl_scope_table;

/* Pointers to various DWARF2 sections.  */

static GTY(()) section *debug_info_section;

static GTY(()) section *debug_abbrev_section;

static GTY(()) section *debug_aranges_section;

static GTY(()) section *debug_macinfo_section;

static GTY(()) section *debug_line_section;

static GTY(()) section *debug_loc_section;

static GTY(()) section *debug_pubnames_section;

static GTY(()) section *debug_pubtypes_section;

static GTY(()) section *debug_str_section;

static GTY(()) section *debug_ranges_section;

static GTY(()) section *debug_frame_section;

/* Maximum size (in bytes) of an artificially generated label.  */

#define MAX_ARTIFICIAL_LABEL_BYTES      30

/* According to the (draft) DWARF 3 specification, the initial length

   should either be 4 or 12 bytes.  When it's 12 bytes, the first 4

   bytes are 0xffffffff, followed by the length stored in the next 8

   bytes.

   However, the SGI/MIPS ABI uses an initial length which is equal to

   DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */

#ifndef DWARF_INITIAL_LENGTH_SIZE

#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)

#endif

/* Round SIZE up to the nearest BOUNDARY.  */

#define DWARF_ROUND(SIZE,BOUNDARY) \

  ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))

/* CIE identifier.  */

#if HOST_BITS_PER_WIDE_INT >= 64

#define DWARF_CIE_ID \

  (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)

#else

#define DWARF_CIE_ID DW_CIE_ID

#endif

DEF_VEC_P (dw_fde_ref);

DEF_VEC_ALLOC_P (dw_fde_ref, gc);

/* A vector for a table that contains frame description

   information for each routine.  */

static GTY(()) VEC(dw_fde_ref, gc) *fde_vec;

struct GTY(()) indirect_string_node {

  const char *str;

  unsigned int refcount;

  enum dwarf_form form;

  char *label;

};

static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;

static GTY(()) int dw2_string_counter;

/* True if the compilation unit places functions in more than one section.  */

static GTY(()) bool have_multiple_function_sections = false;

/* Whether the default text and cold text sections have been used at all.  */

static GTY(()) bool text_section_used = false;

static GTY(()) bool cold_text_section_used = false;

/* The default cold text section.  */

static GTY(()) section *cold_text_section;

/* Forward declarations for functions defined in this file.  */

static char *stripattributes (const char *);

static void output_call_frame_info (int);

static void dwarf2out_note_section_used (void);

/* Personality decl of current unit.  Used only when assembler does not support

   personality CFI.  */

static GTY(()) rtx current_unit_personality;

/* Data and reference forms for relocatable data.  */

#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)

#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)

#ifndef DEBUG_FRAME_SECTION

#define DEBUG_FRAME_SECTION     ".debug_frame"

#endif

#ifndef FUNC_BEGIN_LABEL

#define FUNC_BEGIN_LABEL        "LFB"

#endif

#ifndef FUNC_END_LABEL

#define FUNC_END_LABEL          "LFE"

#endif

#ifndef PROLOGUE_END_LABEL

#define PROLOGUE_END_LABEL      "LPE"

#endif

#ifndef EPILOGUE_BEGIN_LABEL

#define EPILOGUE_BEGIN_LABEL    "LEB"

#endif

#ifndef FRAME_BEGIN_LABEL

#define FRAME_BEGIN_LABEL       "Lframe"

#endif

#define CIE_AFTER_SIZE_LABEL    "LSCIE"

#define CIE_END_LABEL           "LECIE"

#define FDE_LABEL               "LSFDE"

#define FDE_AFTER_SIZE_LABEL    "LASFDE"

#define FDE_END_LABEL           "LEFDE"

#define LINE_NUMBER_BEGIN_LABEL "LSLT"

#define LINE_NUMBER_END_LABEL   "LELT"

#define LN_PROLOG_AS_LABEL      "LASLTP"

#define LN_PROLOG_END_LABEL     "LELTP"

#define DIE_LABEL_PREFIX        "DW"

/* Match the base name of a file to the base name of a compilation unit. */

static int

matches_main_base (const char *path)

{

  /* Cache the last query. */

  static const char *last_path = NULL;

  static int last_match = 0;

  if (path != last_path)

    {

      const char *base;

      int length = base_of_path (path, &base);

      last_path = path;

      last_match = (length == main_input_baselength

                    && memcmp (base, main_input_basename, length) == 0);

    }

  return last_match;

}

#ifdef DEBUG_DEBUG_STRUCT

static int

dump_struct_debug (tree type, enum debug_info_usage usage,

                   enum debug_struct_file criterion, int generic,

                   int matches, int result)

{

  /* Find the type name. */

  tree type_decl = TYPE_STUB_DECL (type);

  tree t = type_decl;

  const char *name = 0;

  if (TREE_CODE (t) == TYPE_DECL)

    t = DECL_NAME (t);

  if (t)

    name = IDENTIFIER_POINTER (t);

  fprintf (stderr, "    struct %d %s %s %s %s %d %p %s\n",

           criterion,

           DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",

           matches ? "bas" : "hdr",

           generic ? "gen" : "ord",

           usage == DINFO_USAGE_DFN ? ";" :

             usage == DINFO_USAGE_DIR_USE ? "." : "*",

           result,

           (void*) type_decl, name);

  return result;

}

#define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \

  dump_struct_debug (type, usage, criterion, generic, matches, result)

#else

#define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \

  (result)

#endif

static bool

should_emit_struct_debug (tree type, enum debug_info_usage usage)

{

  enum debug_struct_file criterion;

  tree type_decl;

  bool generic = lang_hooks.types.generic_p (type);

  if (generic)

    criterion = debug_struct_generic[usage];

  else

    criterion = debug_struct_ordinary[usage];

  if (criterion == DINFO_STRUCT_FILE_NONE)

    return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);

  if (criterion == DINFO_STRUCT_FILE_ANY)

    return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);

  type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));

  if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))

    return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);

  if (matches_main_base (DECL_SOURCE_FILE (type_decl)))

    return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);

  return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);

}

/* Return a pointer to a copy of the section string name S with all

   attributes stripped off, and an asterisk prepended (for assemble_name).  */

static inline char *

stripattributes (const char *s)

{

  char *stripped = XNEWVEC (char, strlen (s) + 2);

  char *p = stripped;

  *p++ = '*';

  while (*s && *s != ',')

    *p++ = *s++;

  *p = '\0';

  return stripped;

}

/* Switch [BACK] to eh_frame_section.  If we don't have an eh_frame_section,

   switch to the data section instead, and write out a synthetic start label

   for collect2 the first time around.  */

static void

switch_to_eh_frame_section (bool back)

{

  tree label;

#ifdef EH_FRAME_SECTION_NAME

  if (eh_frame_section == 0)

    {

      int flags;

      if (EH_TABLES_CAN_BE_READ_ONLY)

        {

          int fde_encoding;

          int per_encoding;

          int lsda_encoding;

          fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,

                                                       /*global=*/0);

          per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,

                                                       /*global=*/1);

          lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,

                                                        /*global=*/0);

          flags = ((! flag_pic

                    || ((fde_encoding & 0x70) != DW_EH_PE_absptr

                        && (fde_encoding & 0x70) != DW_EH_PE_aligned

                        && (per_encoding & 0x70) != DW_EH_PE_absptr

                        && (per_encoding & 0x70) != DW_EH_PE_aligned

                        && (lsda_encoding & 0x70) != DW_EH_PE_absptr

                        && (lsda_encoding & 0x70) != DW_EH_PE_aligned))

                   ? 0 : SECTION_WRITE);

        }

      else

        flags = SECTION_WRITE;

      eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);

    }

#endif /* EH_FRAME_SECTION_NAME */

  if (eh_frame_section)

    switch_to_section (eh_frame_section);

  else

    {

      /* We have no special eh_frame section.  Put the information in

         the data section and emit special labels to guide collect2.  */

      switch_to_section (data_section);

      if (!back)

        {

          label = get_file_function_name ("F");

          ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));

          targetm.asm_out.globalize_label (asm_out_file,

                                           IDENTIFIER_POINTER (label));

          ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));

        }

    }

}

/* Switch [BACK] to the eh or debug frame table section, depending on

   FOR_EH.  */

static void

switch_to_frame_table_section (int for_eh, bool back)

{

  if (for_eh)

    switch_to_eh_frame_section (back);

  else

    {

      if (!debug_frame_section)

        debug_frame_section = get_section (DEBUG_FRAME_SECTION,

                                           SECTION_DEBUG, NULL);

      switch_to_section (debug_frame_section);

    }

}

/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */

enum dw_cfi_oprnd_type

dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)

{

  switch (cfi)

    {

    case DW_CFA_nop:

    case DW_CFA_GNU_window_save:

    case DW_CFA_remember_state:

    case DW_CFA_restore_state:

      return dw_cfi_oprnd_unused;

    case DW_CFA_set_loc:

    case DW_CFA_advance_loc1:

    case DW_CFA_advance_loc2:

    case DW_CFA_advance_loc4:

    case DW_CFA_MIPS_advance_loc8:

      return dw_cfi_oprnd_addr;

    case DW_CFA_offset:

    case DW_CFA_offset_extended:

    case DW_CFA_def_cfa:

    case DW_CFA_offset_extended_sf:

    case DW_CFA_def_cfa_sf:

    case DW_CFA_restore:

    case DW_CFA_restore_extended:

    case DW_CFA_undefined:

    case DW_CFA_same_value:

    case DW_CFA_def_cfa_register:

    case DW_CFA_register:

    case DW_CFA_expression:

      return dw_cfi_oprnd_reg_num;

    case DW_CFA_def_cfa_offset:

    case DW_CFA_GNU_args_size:

    case DW_CFA_def_cfa_offset_sf:

      return dw_cfi_oprnd_offset;

    case DW_CFA_def_cfa_expression:

      return dw_cfi_oprnd_loc;

    default:

      gcc_unreachable ();

    }

}

/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */

enum dw_cfi_oprnd_type

dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)

{

  switch (cfi)

    {

    case DW_CFA_def_cfa:

    case DW_CFA_def_cfa_sf:

    case DW_CFA_offset:

    case DW_CFA_offset_extended_sf:

    case DW_CFA_offset_extended:

      return dw_cfi_oprnd_offset;

    case DW_CFA_register:

      return dw_cfi_oprnd_reg_num;

    case DW_CFA_expression:

      return dw_cfi_oprnd_loc;

    default:

      return dw_cfi_oprnd_unused;

    }

}

/* Output one FDE.  */

static void

output_fde (dw_fde_ref fde, bool for_eh, bool second,

            char *section_start_label, int fde_encoding, char *augmentation,

            bool any_lsda_needed, int lsda_encoding)

{

  const char *begin, *end;

  static unsigned int j;

  char l1[20], l2[20];

  targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,

                                     /* empty */ 0);

  targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,

                                  for_eh + j);

  ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);

  ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);

  if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)

    dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"

                         " indicating 64-bit DWARF extension");

  dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,

                        "FDE Length");

  ASM_OUTPUT_LABEL (asm_out_file, l1);

  if (for_eh)

    dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");

  else

    dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,

                           debug_frame_section, "FDE CIE offset");

  begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;

  end = second ? fde->dw_fde_second_end : fde->dw_fde_end;

  if (for_eh)

    {

      rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);

      SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;

      dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,

                                       "FDE initial location");

      dw2_asm_output_delta (size_of_encoded_value (fde_encoding),

                            end, begin, "FDE address range");

    }

  else

    {

      dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");

      dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");

    }

  if (augmentation[0])

    {

      if (any_lsda_needed)

        {

          int size = size_of_encoded_value (lsda_encoding);

          if (lsda_encoding == DW_EH_PE_aligned)

            {

              int offset = (  4         /* Length */

                            + 4         /* CIE offset */

                            + 2 * size_of_encoded_value (fde_encoding)

                            + 1         /* Augmentation size */ );

              int pad = -offset & (PTR_SIZE - 1);

              size += pad;

              gcc_assert (size_of_uleb128 (size) == 1);

            }

          dw2_asm_output_data_uleb128 (size, "Augmentation size");

          if (fde->uses_eh_lsda)

            {

              ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",

                                           fde->funcdef_number);

              dw2_asm_output_encoded_addr_rtx (lsda_encoding,

                                               gen_rtx_SYMBOL_REF (Pmode, l1),

                                               false,

                                               "Language Specific Data Area");

            }

          else

            {

              if (lsda_encoding == DW_EH_PE_aligned)

                ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));

              dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,

                                   "Language Specific Data Area (none)");

            }

        }

      else

        dw2_asm_output_data_uleb128 (0, "Augmentation size");

    }

  /* Loop through the Call Frame Instructions associated with this FDE.  */

  fde->dw_fde_current_label = begin;

  {

    size_t from, until, i;

    from = 0;

    until = VEC_length (dw_cfi_ref, fde->dw_fde_cfi);

    if (fde->dw_fde_second_begin == NULL)

      ;

    else if (!second)

      until = fde->dw_fde_switch_cfi_index;

    else

      from = fde->dw_fde_switch_cfi_index;

    for (i = from; i < until; i++)

      output_cfi (VEC_index (dw_cfi_ref, fde->dw_fde_cfi, i), fde, for_eh);

  }

  /* If we are to emit a ref/link from function bodies to their frame tables,

     do it now.  This is typically performed to make sure that tables

     associated with functions are dragged with them and not discarded in

     garbage collecting links. We need to do this on a per function basis to

     cope with -ffunction-sections.  */

#ifdef ASM_OUTPUT_DWARF_TABLE_REF

  /* Switch to the function section, emit the ref to the tables, and

     switch *back* into the table section.  */

  switch_to_section (function_section (fde->decl));

  ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);

  switch_to_frame_table_section (for_eh, true);

#endif

  /* Pad the FDE out to an address sized boundary.  */

  ASM_OUTPUT_ALIGN (asm_out_file,

                    floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));

  ASM_OUTPUT_LABEL (asm_out_file, l2);

  j += 2;

}

/* Return true if frame description entry FDE is needed for EH.  */

static bool

fde_needed_for_eh_p (dw_fde_ref fde)

{

  if (flag_asynchronous_unwind_tables)

    return true;

  if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))

    return true;

  if (fde->uses_eh_lsda)

    return true;

  /* If exceptions are enabled, we have collected nothrow info.  */

  if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))

    return false;

  return true;

}

/* Output the call frame information used to record information

   that relates to calculating the frame pointer, and records the

   location of saved registers.  */

static void

output_call_frame_info (int for_eh)

{

  unsigned int i;

  dw_fde_ref fde;

  dw_cfi_ref cfi;

  char l1[20], l2[20], section_start_label[20];

  bool any_lsda_needed = false;

  char augmentation[6];

  int augmentation_size;

  int fde_encoding = DW_EH_PE_absptr;

  int per_encoding = DW_EH_PE_absptr;

  int lsda_encoding = DW_EH_PE_absptr;

  int return_reg;

  rtx personality = NULL;

  int dw_cie_version;

  /* Don't emit a CIE if there won't be any FDEs.  */

  if (fde_vec == NULL)

    return;

  /* Nothing to do if the assembler's doing it all.  */

  if (dwarf2out_do_cfi_asm ())

    return;

  /* If we don't have any functions we'll want to unwind out of, don't emit

     any EH unwind information.  If we make FDEs linkonce, we may have to

     emit an empty label for an FDE that wouldn't otherwise be emitted.  We

     want to avoid having an FDE kept around when the function it refers to

     is discarded.  Example where this matters: a primary function template

     in C++ requires EH information, an explicit specialization doesn't.  */

  if (for_eh)

    {

      bool any_eh_needed = false;

      FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, i, fde)

        {

          if (fde->uses_eh_lsda)

            any_eh_needed = any_lsda_needed = true;

          else if (fde_needed_for_eh_p (fde))

            any_eh_needed = true;

          else if (TARGET_USES_WEAK_UNWIND_INFO)

            targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);

        }