Subversion Repositories openrisc_me

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

#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"

#ifdef DWARF2_DEBUGGING_INFO

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

#endif

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

#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

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

#ifdef DWARF2_UNWIND_INFO

          || (DWARF2_UNWIND_INFO

              && (flag_unwind_tables

                  || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))

#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_str_section;

static GTY(()) section *debug_ranges_section;

static GTY(()) section *debug_frame_section;

/* 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 dw_cfi_oprnd_struct GTY(())

{

  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 dw_cfi_struct GTY(())

{

  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 cfa_loc GTY(())

{

  HOST_WIDE_INT offset;

  HOST_WIDE_INT base_offset;

  unsigned int reg;

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

} 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 dw_fde_struct GTY(())

{

  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;

  bool dw_fde_switched_sections;

  dw_cfi_ref dw_fde_cfi;

  unsigned funcdef_number;

  unsigned all_throwers_are_sibcalls : 1;

  unsigned nothrow : 1;

  unsigned uses_eh_lsda : 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

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

#define DWARF_VERSION 2

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

/* 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 indirect_string_node GTY(())

{

  const char *str;

  unsigned int refcount;

  unsigned int form;

  char *label;

};

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

static GTY(()) int dw2_string_counter;

static GTY(()) unsigned long dwarf2out_cfi_label_num;

#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 *);

static void lookup_cfa (dw_cfa_location *);

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

static void initial_return_save (rtx);

static HOST_WIDE_INT stack_adjust_offset (rtx);

static void output_cfi (dw_cfi_ref, dw_fde_ref, int);

static void output_call_frame_info (int);

static void dwarf2out_stack_adjust (rtx, bool);

static void flush_queued_reg_saves (void);

static bool clobbers_queued_reg_save (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 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 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;

}

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

        }

    }

#ifdef DWARF_ALT_FRAME_RETURN_COLUMN

  gcc_assert (wrote_return_column);

  i = DWARF_ALT_FRAME_RETURN_COLUMN;

  wrote_return_column = false;

#else

  i = DWARF_FRAME_RETURN_COLUMN;

#endif

  if (! wrote_return_column)

    {

      enum machine_mode save_mode = Pmode;

      HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);

      HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);

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

    }

}

/* 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_alloc (sizeof (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;

  return cfi;

}

/* Add a Call Frame Instruction to list of instructions.  */

static inline void

add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)

{

  dw_cfi_ref *p;

  /* Find the end of the chain.  */

  for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)

    ;

  *p = cfi;

}

/* Generate a new label for the CFI info to refer to.  */

char *

dwarf2out_cfi_label (void)

{

  static char label[20];

  ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);

  ASM_OUTPUT_LABEL (asm_out_file, label);

  return label;

}

/* Add CFI to the current fde at the PC value indicated by LABEL if specified,

   or to the CIE if LABEL is NULL.  */

static void

add_fde_cfi (const char *label, dw_cfi_ref cfi)

{

  if (label)

    {

      dw_fde_ref fde = &fde_table[fde_table_in_use - 1];

      if (*label == 0)

        label = dwarf2out_cfi_label ();

      if (fde->dw_fde_current_label == NULL

          || strcmp (label, fde->dw_fde_current_label) != 0)

        {

          dw_cfi_ref xcfi;

          label = xstrdup (label);

          /* Set the location counter to the new label.  */

          xcfi = new_cfi ();

          /* If we have a current label, advance from there, otherwise

             set the location directly using set_loc.  */

          xcfi->dw_cfi_opc = fde->dw_fde_current_label

                             ? DW_CFA_advance_loc4

                             : DW_CFA_set_loc;

          xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;

          add_cfi (&fde->dw_fde_cfi, xcfi);

          fde->dw_fde_current_label = label;

        }

      add_cfi (&fde->dw_fde_cfi, cfi);

    }

  else

    add_cfi (&cie_cfi_head, cfi);

}

/* Subroutine of lookup_cfa.  */

static void

lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)

{

  switch (cfi->dw_cfi_opc)

    {

    case DW_CFA_def_cfa_offset:

      loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;

      break;

    case DW_CFA_def_cfa_offset_sf:

      loc->offset

        = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;

      break;

    case DW_CFA_def_cfa_register:

      loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;

      break;

    case DW_CFA_def_cfa:

      loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;

      loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;

      break;

    case DW_CFA_def_cfa_sf:

      loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;

      loc->offset

        = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;

      break;

    case DW_CFA_def_cfa_expression:

      get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);

      break;

    default:

      break;

    }

}

/* Find the previous value for the CFA.  */

static void

lookup_cfa (dw_cfa_location *loc)

{

  dw_cfi_ref cfi;

  loc->reg = INVALID_REGNUM;

  loc->offset = 0;

  loc->indirect = 0;

  loc->base_offset = 0;

  for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)

    lookup_cfa_1 (cfi, loc);

  if (fde_table_in_use)

    {

      dw_fde_ref fde = &fde_table[fde_table_in_use - 1];

      for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)

        lookup_cfa_1 (cfi, loc);

    }

}

/* The current rule for calculating the DWARF2 canonical frame address.  */

static dw_cfa_location cfa;

/* The register used for saving registers to the stack, and its offset

   from the CFA.  */

static dw_cfa_location cfa_store;

/* The running total of the size of arguments pushed onto the stack.  */

static HOST_WIDE_INT args_size;

/* The last args_size we actually output.  */

static HOST_WIDE_INT old_args_size;

/* Entry point to update the canonical frame address (CFA).

   LABEL is passed to add_fde_cfi.  The value of CFA is now to be

   calculated from REG+OFFSET.  */

void

dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)

{

  dw_cfa_location loc;

  loc.indirect = 0;

  loc.base_offset = 0;