Subversion Repositories openrisc_2011-10-31

/* 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

   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 "real.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 "varray.h"

#include "ggc.h"

#include "md5.h"

#include "tm_p.h"

#include "diagnostic.h"

#include "debug.h"

#include "target.h"

#include "langhooks.h"

#include "hashtab.h"

#include "cgraph.h"

#include "input.h"

#include "gimple.h"

#include "tree-pass.h"

#ifdef DWARF2_DEBUGGING_INFO

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

static rtx last_var_location_insn;

#endif

#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

#ifndef DWARF2_FRAME_INFO

# ifdef DWARF2_DEBUGGING_INFO

#  define DWARF2_FRAME_INFO \

  (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)

# else

#  define DWARF2_FRAME_INFO 0

# endif

#endif

/* Map register numbers held in the call frame info that gcc has

   collected using DWARF_FRAME_REGNUM to those that should be output in

   .debug_frame and .eh_frame.  */

#ifndef DWARF2_FRAME_REG_OUT

#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)

#endif

/* Save the result of dwarf2out_do_frame across PCH.  */

static GTY(()) bool saved_do_cfi_asm = 0;

/* Decide whether we want to emit frame unwind information for the current

   translation unit.  */

int

dwarf2out_do_frame (void)

{

  /* We want to emit correct CFA location expressions or lists, so we

     have to return true if we're going to output debug info, even if

     we're not going to output frame or unwind info.  */

  return (write_symbols == DWARF2_DEBUG

          || write_symbols == VMS_AND_DWARF2_DEBUG

          || DWARF2_FRAME_INFO || saved_do_cfi_asm

#ifdef DWARF2_UNWIND_INFO

          || (DWARF2_UNWIND_INFO

              && (flag_unwind_tables

                  || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))

#endif

          );

}

/* Decide whether to emit frame unwind via assembler directives.  */

int

dwarf2out_do_cfi_asm (void)

{

  int enc;

#ifdef MIPS_DEBUGGING_INFO

  return false;

#endif

  if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())

    return false;

  if (saved_do_cfi_asm)

    return true;

  if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)

    return false;

  /* Make sure the personality encoding is one the assembler can support.

     In particular, aligned addresses can't be handled.  */

  enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);

  if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)

    return false;

  enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);

  if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)

    return false;

  if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE)

    {

#ifdef TARGET_UNWIND_INFO

      return false;

#else

      if (USING_SJLJ_EXCEPTIONS || (!flag_unwind_tables && !flag_exceptions))

        return false;

#endif

    }

  saved_do_cfi_asm = true;

  return true;

}

/* 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_dcall_section;

static GTY(()) section *debug_vcall_section;

static GTY(()) section *debug_str_section;

static GTY(()) section *debug_ranges_section;

static GTY(()) section *debug_frame_section;

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

   personality CFI.  */

static GTY(()) rtx current_unit_personality;

/* How to start an assembler comment.  */

#ifndef ASM_COMMENT_START

#define ASM_COMMENT_START ";#"

#endif

typedef struct dw_cfi_struct *dw_cfi_ref;

typedef struct dw_fde_struct *dw_fde_ref;

typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;

/* Call frames are described using a sequence of Call Frame

   Information instructions.  The register number, offset

   and address fields are provided as possible operands;

   their use is selected by the opcode field.  */

enum dw_cfi_oprnd_type {

  dw_cfi_oprnd_unused,

  dw_cfi_oprnd_reg_num,

  dw_cfi_oprnd_offset,

  dw_cfi_oprnd_addr,

  dw_cfi_oprnd_loc

};

typedef union GTY(()) dw_cfi_oprnd_struct {

  unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;

  HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;

  const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;

  struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;

}

dw_cfi_oprnd;

typedef struct GTY(()) dw_cfi_struct {

  dw_cfi_ref dw_cfi_next;

  enum dwarf_call_frame_info dw_cfi_opc;

  dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))

    dw_cfi_oprnd1;

  dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))

    dw_cfi_oprnd2;

}

dw_cfi_node;

/* This is how we define the location of the CFA. We use to handle it

   as REG + OFFSET all the time,  but now it can be more complex.

   It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.

   Instead of passing around REG and OFFSET, we pass a copy

   of this structure.  */

typedef struct GTY(()) cfa_loc {

  HOST_WIDE_INT offset;

  HOST_WIDE_INT base_offset;

  unsigned int reg;

  BOOL_BITFIELD indirect : 1;  /* 1 if CFA is accessed via a dereference.  */

  BOOL_BITFIELD in_use : 1;    /* 1 if a saved cfa is stored here.  */

} dw_cfa_location;

/* All call frame descriptions (FDE's) in the GCC generated DWARF

   refer to a single Common Information Entry (CIE), defined at

   the beginning of the .debug_frame section.  This use of a single

   CIE obviates the need to keep track of multiple CIE's

   in the DWARF generation routines below.  */

typedef struct GTY(()) dw_fde_struct {

  tree decl;

  const char *dw_fde_begin;

  const char *dw_fde_current_label;

  const char *dw_fde_end;

  const char *dw_fde_hot_section_label;

  const char *dw_fde_hot_section_end_label;

  const char *dw_fde_unlikely_section_label;

  const char *dw_fde_unlikely_section_end_label;

  dw_cfi_ref dw_fde_cfi;

  dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections.  */

  unsigned funcdef_number;

  HOST_WIDE_INT stack_realignment;

  /* Dynamic realign argument pointer register.  */

  unsigned int drap_reg;

  /* Virtual dynamic realign argument pointer register.  */

  unsigned int vdrap_reg;

  unsigned all_throwers_are_sibcalls : 1;

  unsigned nothrow : 1;

  unsigned uses_eh_lsda : 1;

  /* Whether we did stack realign in this call frame.  */

  unsigned stack_realign : 1;

  /* Whether dynamic realign argument pointer register has been saved.  */

  unsigned drap_reg_saved: 1;

  /* True iff dw_fde_begin label is in text_section or cold_text_section.  */

  unsigned in_std_section : 1;

  /* True iff dw_fde_unlikely_section_label is in text_section or

     cold_text_section.  */

  unsigned cold_in_std_section : 1;

  /* True iff switched sections.  */

  unsigned dw_fde_switched_sections : 1;

  /* True iff switching from cold to hot section.  */

  unsigned dw_fde_switched_cold_to_hot : 1;

}

dw_fde_node;

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

#define MAX_ARTIFICIAL_LABEL_BYTES      30

/* The size of addresses as they appear in the Dwarf 2 data.

   Some architectures use word addresses to refer to code locations,

   but Dwarf 2 info always uses byte addresses.  On such machines,

   Dwarf 2 addresses need to be larger than the architecture's

   pointers.  */

#ifndef DWARF2_ADDR_SIZE

#define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)

#endif

/* The size in bytes of a DWARF field indicating an offset or length

   relative to a debug info section, specified to be 4 bytes in the

   DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same

   as PTR_SIZE.  */

#ifndef DWARF_OFFSET_SIZE

#define DWARF_OFFSET_SIZE 4

#endif

/* The size in bytes of a DWARF 4 type signature.  */

#ifndef DWARF_TYPE_SIGNATURE_SIZE

#define DWARF_TYPE_SIGNATURE_SIZE 8

#endif

/* 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))

/* Offsets recorded in opcodes are a multiple of this alignment factor.  */

#ifndef DWARF_CIE_DATA_ALIGNMENT

#ifdef STACK_GROWS_DOWNWARD

#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))

#else

#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)

#endif

#endif

/* 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

/* A pointer to the base of a table that contains frame description

   information for each routine.  */

static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;

/* Number of elements currently allocated for fde_table.  */

static GTY(()) unsigned fde_table_allocated;

/* Number of elements in fde_table currently in use.  */

static GTY(()) unsigned fde_table_in_use;

/* Size (in elements) of increments by which we may expand the

   fde_table.  */

#define FDE_TABLE_INCREMENT 256

/* Get the current fde_table entry we should use.  */

static inline dw_fde_ref

current_fde (void)

{

  return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;

}

/* A list of call frame insns for the CIE.  */

static GTY(()) dw_cfi_ref cie_cfi_head;

#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)

/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram

   attribute that accelerates the lookup of the FDE associated

   with the subprogram.  This variable holds the table index of the FDE

   associated with the current function (body) definition.  */

static unsigned current_funcdef_fde;

#endif

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;

/* True if the compilation unit has location entries that reference

   debug strings.  */

static GTY(()) bool debug_str_hash_forced = false;

static GTY(()) int dw2_string_counter;

static GTY(()) unsigned long dwarf2out_cfi_label_num;

/* 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;

#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)

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

static char *stripattributes (const char *);

static const char *dwarf_cfi_name (unsigned);

static dw_cfi_ref new_cfi (void);

static void add_cfi (dw_cfi_ref *, dw_cfi_ref);

static void add_fde_cfi (const char *, dw_cfi_ref);

static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);

static void lookup_cfa (dw_cfa_location *);

static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);

#ifdef DWARF2_UNWIND_INFO

static void initial_return_save (rtx);

#endif

static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,

                                          HOST_WIDE_INT);

static void output_cfi (dw_cfi_ref, dw_fde_ref, int);

static void output_cfi_directive (dw_cfi_ref);

static void output_call_frame_info (int);

static void dwarf2out_note_section_used (void);

static void flush_queued_reg_saves (void);

static bool clobbers_queued_reg_save (const_rtx);

static void dwarf2out_frame_debug_expr (rtx, const char *);

/* Support for complex CFA locations.  */

static void output_cfa_loc (dw_cfi_ref);

static void output_cfa_loc_raw (dw_cfi_ref);

static void get_cfa_from_loc_descr (dw_cfa_location *,

                                    struct dw_loc_descr_struct *);

static struct dw_loc_descr_struct *build_cfa_loc

  (dw_cfa_location *, HOST_WIDE_INT);

static struct dw_loc_descr_struct *build_cfa_aligned_loc

  (HOST_WIDE_INT, HOST_WIDE_INT);

static void def_cfa_1 (const char *, dw_cfa_location *);

/* How to start an assembler comment.  */

#ifndef ASM_COMMENT_START

#define ASM_COMMENT_START ";#"

#endif

/* 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 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"

/* The DWARF 2 CFA column which tracks the return address.  Normally this

   is the column for PC, or the first column after all of the hard

   registers.  */

#ifndef DWARF_FRAME_RETURN_COLUMN

#ifdef PC_REGNUM

#define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)

#else

#define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS

#endif

#endif

/* The mapping from gcc register number to DWARF 2 CFA column number.  By

   default, we just provide columns for all registers.  */

#ifndef DWARF_FRAME_REGNUM

#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)

#endif

/* Hook used by __throw.  */

rtx

expand_builtin_dwarf_sp_column (void)

{

  unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);

  return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));

}

/* 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;

}

/* MEM is a memory reference for the register size table, each element of

   which has mode MODE.  Initialize column C as a return address column.  */

static void

init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)

{

  HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);

  HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);

  emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));

}

/* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder.  */

static inline HOST_WIDE_INT

div_data_align (HOST_WIDE_INT off)

{

  HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;

  gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);

  return r;

}

/* Return true if we need a signed version of a given opcode

   (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended).  */

static inline bool

need_data_align_sf_opcode (HOST_WIDE_INT off)

{

  return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;

}

/* Generate code to initialize the register size table.  */

void

expand_builtin_init_dwarf_reg_sizes (tree address)

{

  unsigned int i;

  enum machine_mode mode = TYPE_MODE (char_type_node);

  rtx addr = expand_normal (address);

  rtx mem = gen_rtx_MEM (BLKmode, addr);

  bool wrote_return_column = false;

  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)

    {

      int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);

      if (rnum < DWARF_FRAME_REGISTERS)

        {

          HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);

          enum machine_mode save_mode = reg_raw_mode[i];

          HOST_WIDE_INT size;

          if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))

            save_mode = choose_hard_reg_mode (i, 1, true);

          if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)

            {

              if (save_mode == VOIDmode)

                continue;

              wrote_return_column = true;

            }

          size = GET_MODE_SIZE (save_mode);

          if (offset < 0)

            continue;

          emit_move_insn (adjust_address (mem, mode, offset),

                          gen_int_mode (size, mode));

        }

    }

  if (!wrote_return_column)

    init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);

#ifdef DWARF_ALT_FRAME_RETURN_COLUMN

  init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);

#endif

  targetm.init_dwarf_reg_sizes_extra (address);

}

/* Convert a DWARF call frame info. operation to its string name */

static const char *

dwarf_cfi_name (unsigned int cfi_opc)

{

  switch (cfi_opc)

    {

    case DW_CFA_advance_loc:

      return "DW_CFA_advance_loc";

    case DW_CFA_offset:

      return "DW_CFA_offset";

    case DW_CFA_restore:

      return "DW_CFA_restore";

    case DW_CFA_nop:

      return "DW_CFA_nop";

    case DW_CFA_set_loc:

      return "DW_CFA_set_loc";

    case DW_CFA_advance_loc1:

      return "DW_CFA_advance_loc1";

    case DW_CFA_advance_loc2:

      return "DW_CFA_advance_loc2";

    case DW_CFA_advance_loc4:

      return "DW_CFA_advance_loc4";

    case DW_CFA_offset_extended:

      return "DW_CFA_offset_extended";

    case DW_CFA_restore_extended:

      return "DW_CFA_restore_extended";

    case DW_CFA_undefined:

      return "DW_CFA_undefined";

    case DW_CFA_same_value:

      return "DW_CFA_same_value";

    case DW_CFA_register:

      return "DW_CFA_register";

    case DW_CFA_remember_state:

      return "DW_CFA_remember_state";

    case DW_CFA_restore_state:

      return "DW_CFA_restore_state";

    case DW_CFA_def_cfa:

      return "DW_CFA_def_cfa";

    case DW_CFA_def_cfa_register:

      return "DW_CFA_def_cfa_register";

    case DW_CFA_def_cfa_offset:

      return "DW_CFA_def_cfa_offset";

    /* DWARF 3 */

    case DW_CFA_def_cfa_expression:

      return "DW_CFA_def_cfa_expression";

    case DW_CFA_expression:

      return "DW_CFA_expression";

    case DW_CFA_offset_extended_sf:

      return "DW_CFA_offset_extended_sf";

    case DW_CFA_def_cfa_sf:

      return "DW_CFA_def_cfa_sf";

    case DW_CFA_def_cfa_offset_sf:

      return "DW_CFA_def_cfa_offset_sf";

    /* SGI/MIPS specific */

    case DW_CFA_MIPS_advance_loc8:

      return "DW_CFA_MIPS_advance_loc8";

    /* GNU extensions */

    case DW_CFA_GNU_window_save:

      return "DW_CFA_GNU_window_save";

    case DW_CFA_GNU_args_size:

      return "DW_CFA_GNU_args_size";

    case DW_CFA_GNU_negative_offset_extended:

      return "DW_CFA_GNU_negative_offset_extended";

    default:

      return "DW_CFA_<unknown>";

    }

}

/* Return a pointer to a newly allocated Call Frame Instruction.  */

static inline dw_cfi_ref

new_cfi (void)

{

  dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);

  cfi->dw_cfi_next = NULL;

  cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;

  cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;