Back to index

glibc  2.9
Classes | Defines | Typedefs | Functions | Variables
unwind-dw2.c File Reference
#include "tconfig.h"
#include "tsystem.h"
#include "dwarf2.h"
#include "unwind.h"
#include "unwind-pe.h"
#include "unwind-dw2-fde.h"
#include "gthr.h"
#include "unwind.inc"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _Unwind_Context
struct  _Unwind_FrameState
struct  _Unwind_FrameState::frame_state_reg_info
union  unaligned
struct  frame_state
struct  _Unwind_FrameState::frame_state_reg_info.reg
union  _Unwind_FrameState::frame_state_reg_info.reg.loc

Defines

#define STACK_GROWS_DOWNWARD   0
#define DWARF_FRAME_REGISTERS   FIRST_PSEUDO_REGISTER
#define PRE_GCC3_DWARF_FRAME_REGISTERS   DWARF_FRAME_REGISTERS
#define STATIC
#define uw_init_context(CONTEXT)
#define uw_install_context(CURRENT, TARGET)

Typedefs

typedef struct frame_state frame_state

Functions

union unaligned __attribute__ ((packed))
unsigned u2 __attribute__ ((mode(HI)))
unsigned u4 __attribute__ ((mode(SI)))
unsigned u8 __attribute__ ((mode(DI)))
static void * read_pointer (const void *p)
static int read_1u (const void *p)
static int read_1s (const void *p)
static int read_2u (const void *p)
static int read_2s (const void *p)
static unsigned int read_4u (const void *p)
static int read_4s (const void *p)
static unsigned long read_8u (const void *p)
static unsigned long read_8s (const void *p)
_Unwind_Word _Unwind_GetGR (struct _Unwind_Context *context, int index)
_Unwind_Word _Unwind_GetCFA (struct _Unwind_Context *context)
void _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
_Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *context)
void _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
void * _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
_Unwind_Ptr _Unwind_GetRegionStart (struct _Unwind_Context *context)
void * _Unwind_FindEnclosingFunction (void *pc)
_Unwind_Ptr _Unwind_GetDataRelBase (struct _Unwind_Context *context)
_Unwind_Ptr _Unwind_GetTextRelBase (struct _Unwind_Context *context)
static const unsigned char * extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context, _Unwind_FrameState *fs)
static _Unwind_Word execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end, struct _Unwind_Context *context, _Unwind_Word initial)
static void execute_cfa_program (const unsigned char *insn_ptr, const unsigned char *insn_end, struct _Unwind_Context *context, _Unwind_FrameState *fs)
static _Unwind_Reason_Code uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
STATIC struct frame_state__frame_state_for (void *, struct frame_state *)
static void uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
static void uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
static void uw_init_context_1 (struct _Unwind_Context *context, void *outer_cfa, void *outer_ra)
static void init_dwarf_reg_size_table (void)
static long uw_install_context_1 (struct _Unwind_Context *current, struct _Unwind_Context *target)
static _Unwind_Ptr uw_identify_context (struct _Unwind_Context *context)

Variables

static unsigned char dwarf_reg_size_table [DWARF_FRAME_REGISTERS]
void * p

Class Documentation

struct _Unwind_Context

Definition at line 65 of file unwind-dw2.c.

Class Members
_Unwind_Word args_size
void * cfa
void * lsda
void * ra
void * reg
struct _Unwind_FrameState::frame_state_reg_info

Definition at line 88 of file unwind-dw2.c.

Collaboration diagram for _Unwind_FrameState::frame_state_reg_info:
Class Members
struct frame_state_reg_info * prev
struct frame_state_reg_info reg
struct frame_state

Definition at line 1015 of file unwind-dw2.c.

Class Members
long args_size
void * cfa
long cfa_offset
unsigned short cfa_reg
void * eh_ptr
long reg_or_offset
unsigned short retaddr_column
char saved
struct _Unwind_FrameState::frame_state_reg_info.reg

Definition at line 90 of file unwind-dw2.c.

Class Members
enum frame_state_reg_info how
reg loc
union _Unwind_FrameState::frame_state_reg_info.reg.loc

Definition at line 91 of file unwind-dw2.c.

Class Members
const unsigned char * exp
_Unwind_Sword offset
_Unwind_Word reg

Define Documentation

Definition at line 54 of file unwind-dw2.c.

Definition at line 59 of file unwind-dw2.c.

#define STACK_GROWS_DOWNWARD   0

Definition at line 45 of file unwind-dw2.c.

#define STATIC

Definition at line 1028 of file unwind-dw2.c.

#define uw_init_context (   CONTEXT)
Value:
do                                                                \
    {                                                             \
      /* Do any necessary initialization to access arbitrary stack frames. \
        On the SPARC, this means flushing the register windows.  */      \
      __builtin_unwind_init ();                                          \
      uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (),                \
                      __builtin_return_address (0));                     \
    }                                                             \
  while (0)

Definition at line 1191 of file unwind-dw2.c.

#define uw_install_context (   CURRENT,
  TARGET 
)
Value:
do                                                              \
    {                                                           \
      long offset = uw_install_context_1 ((CURRENT), (TARGET));               \
      void *handler = __builtin_frob_return_addr ((TARGET)->ra);       \
      __builtin_eh_return (offset, handler);                           \
    }                                                           \
  while (0)

Definition at line 1235 of file unwind-dw2.c.


Typedef Documentation

typedef struct frame_state frame_state

Function Documentation

union unaligned __attribute__ ( (packed)  )
unsigned u2 __attribute__::__attribute__ ( (mode(HI))  )
unsigned u8 __attribute__::__attribute__ ( (mode(DI))  )
STATIC struct frame_state* __frame_state_for ( void *  pc_target,
struct frame_state state_in 
) [read]
void* _Unwind_FindEnclosingFunction ( void *  pc)

Definition at line 227 of file unwind-dw2.c.

{
  struct dwarf_eh_bases bases;
  struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases);
  if (fde)
    return bases.func;
  else
    return NULL;
}
_Unwind_Word _Unwind_GetCFA ( struct _Unwind_Context context)

Definition at line 185 of file unwind-dw2.c.

{
  return (_Unwind_Ptr) context->cfa;
}

Here is the call graph for this function:

_Unwind_Ptr _Unwind_GetDataRelBase ( struct _Unwind_Context context)

Definition at line 239 of file unwind-dw2.c.

{
  return (_Unwind_Ptr) context->bases.dbase;
}
_Unwind_Word _Unwind_GetGR ( struct _Unwind_Context context,
int  index 
) [inline]

Definition at line 176 of file unwind-dw2.c.

{
  /* This will segfault if the register hasn't been saved.  */
  return * (_Unwind_Word *) context->reg[index];
}
_Unwind_Ptr _Unwind_GetIP ( struct _Unwind_Context context) [inline]

Definition at line 201 of file unwind-dw2.c.

{
  return (_Unwind_Ptr) context->ra;
}
void* _Unwind_GetLanguageSpecificData ( struct _Unwind_Context context)

Definition at line 215 of file unwind-dw2.c.

{
  return context->lsda;
}
_Unwind_Ptr _Unwind_GetRegionStart ( struct _Unwind_Context context)

Definition at line 221 of file unwind-dw2.c.

{
  return (_Unwind_Ptr) context->bases.func;
}
_Unwind_Ptr _Unwind_GetTextRelBase ( struct _Unwind_Context context)

Definition at line 245 of file unwind-dw2.c.

{
  return (_Unwind_Ptr) context->bases.tbase;
}
void _Unwind_SetGR ( struct _Unwind_Context context,
int  index,
_Unwind_Word  val 
) [inline]

Definition at line 193 of file unwind-dw2.c.

{
  * (_Unwind_Word *) context->reg[index] = val;
}
void _Unwind_SetIP ( struct _Unwind_Context context,
_Unwind_Ptr  val 
) [inline]

Definition at line 209 of file unwind-dw2.c.

{
  context->ra = (void *) val;
}
static void execute_cfa_program ( const unsigned char *  insn_ptr,
const unsigned char *  insn_end,
struct _Unwind_Context context,
_Unwind_FrameState fs 
) [static]

Definition at line 734 of file unwind-dw2.c.

{
  struct frame_state_reg_info *unused_rs = NULL;

  /* Don't allow remember/restore between CIE and FDE programs.  */
  fs->regs.prev = NULL;

  /* The comparison with the return address uses < rather than <= because
     we are only interested in the effects of code before the call; for a
     noreturn function, the return address may point to unrelated code with
     a different stack configuration that we are not interested in.  We
     assume that the call itself is unwind info-neutral; if not, or if
     there are delay instructions that adjust the stack, these must be
     reflected at the point immediately before the call insn.  */
  while (insn_ptr < insn_end && fs->pc < context->ra)
    {
      unsigned char insn = *insn_ptr++;
      _Unwind_Word reg, utmp;
      _Unwind_Sword offset, stmp;

      if ((insn & 0xc0) == DW_CFA_advance_loc)
       fs->pc += (insn & 0x3f) * fs->code_align;
      else if ((insn & 0xc0) == DW_CFA_offset)
       {
         reg = insn & 0x3f;
         insn_ptr = read_uleb128 (insn_ptr, &utmp);
         offset = (_Unwind_Sword) utmp * fs->data_align;
         fs->regs.reg[reg].how = REG_SAVED_OFFSET;
         fs->regs.reg[reg].loc.offset = offset;
       }
      else if ((insn & 0xc0) == DW_CFA_restore)
       {
         reg = insn & 0x3f;
         fs->regs.reg[reg].how = REG_UNSAVED;
       }
      else switch (insn)
       {
       case DW_CFA_set_loc:
         {
           _Unwind_Ptr pc;
           insn_ptr = read_encoded_value (context, fs->fde_encoding,
                                      insn_ptr, &pc);
           fs->pc = (void *) pc;
         }
         break;

       case DW_CFA_advance_loc1:
         fs->pc += read_1u (insn_ptr) * fs->code_align;
         insn_ptr += 1;
         break;
       case DW_CFA_advance_loc2:
         fs->pc += read_2u (insn_ptr) * fs->code_align;
         insn_ptr += 2;
         break;
       case DW_CFA_advance_loc4:
         fs->pc += read_4u (insn_ptr) * fs->code_align;
         insn_ptr += 4;
         break;

       case DW_CFA_offset_extended:
         insn_ptr = read_uleb128 (insn_ptr, &reg);
         insn_ptr = read_uleb128 (insn_ptr, &utmp);
         offset = (_Unwind_Sword) utmp * fs->data_align;
         fs->regs.reg[reg].how = REG_SAVED_OFFSET;
         fs->regs.reg[reg].loc.offset = offset;
         break;

       case DW_CFA_restore_extended:
         insn_ptr = read_uleb128 (insn_ptr, &reg);
         fs->regs.reg[reg].how = REG_UNSAVED;
         break;

       case DW_CFA_undefined:
       case DW_CFA_same_value:
         insn_ptr = read_uleb128 (insn_ptr, &reg);
         break;

       case DW_CFA_nop:
         break;

       case DW_CFA_register:
         {
           _Unwind_Word reg2;
           insn_ptr = read_uleb128 (insn_ptr, &reg);
           insn_ptr = read_uleb128 (insn_ptr, &reg2);
           fs->regs.reg[reg].how = REG_SAVED_REG;
           fs->regs.reg[reg].loc.reg = reg2;
         }
         break;

       case DW_CFA_remember_state:
         {
           struct frame_state_reg_info *new_rs;
           if (unused_rs)
             {
              new_rs = unused_rs;
              unused_rs = unused_rs->prev;
             }
           else
             new_rs = __builtin_alloca (sizeof (struct frame_state_reg_info));

           *new_rs = fs->regs;
           fs->regs.prev = new_rs;
         }
         break;

       case DW_CFA_restore_state:
         {
           struct frame_state_reg_info *old_rs = fs->regs.prev;
#ifdef _LIBC
           if (old_rs == NULL)
             __libc_fatal ("invalid DWARF unwind data");
           else
#endif
             {
              fs->regs = *old_rs;
              old_rs->prev = unused_rs;
              unused_rs = old_rs;
             }
         }
         break;

       case DW_CFA_def_cfa:
         insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
         insn_ptr = read_uleb128 (insn_ptr, &utmp);
         fs->cfa_offset = utmp;
         fs->cfa_how = CFA_REG_OFFSET;
         break;

       case DW_CFA_def_cfa_register:
         insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
         fs->cfa_how = CFA_REG_OFFSET;
         break;

       case DW_CFA_def_cfa_offset:
         insn_ptr = read_uleb128 (insn_ptr, &utmp);
         fs->cfa_offset = utmp;
         /* cfa_how deliberately not set.  */
         break;

       case DW_CFA_def_cfa_expression:
         fs->cfa_exp = insn_ptr;
         fs->cfa_how = CFA_EXP;
         insn_ptr = read_uleb128 (insn_ptr, &utmp);
         insn_ptr += utmp;
         break;

       case DW_CFA_expression:
         insn_ptr = read_uleb128 (insn_ptr, &reg);
         fs->regs.reg[reg].how = REG_SAVED_EXP;
         fs->regs.reg[reg].loc.exp = insn_ptr;
         insn_ptr = read_uleb128 (insn_ptr, &utmp);
         insn_ptr += utmp;
         break;

         /* From the 2.1 draft.  */
       case DW_CFA_offset_extended_sf:
         insn_ptr = read_uleb128 (insn_ptr, &reg);
         insn_ptr = read_sleb128 (insn_ptr, &stmp);
         offset = stmp * fs->data_align;
         fs->regs.reg[reg].how = REG_SAVED_OFFSET;
         fs->regs.reg[reg].loc.offset = offset;
         break;

       case DW_CFA_def_cfa_sf:
         insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
         insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
         fs->cfa_how = CFA_REG_OFFSET;
         break;

       case DW_CFA_def_cfa_offset_sf:
         insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
         /* cfa_how deliberately not set.  */
         break;

       case DW_CFA_GNU_window_save:
         /* ??? Hardcoded for SPARC register window configuration.
            At least do not do anything for archs which explicitly
            define a lower register number.  */
#if DWARF_FRAME_REGISTERS >= 32
         for (reg = 16; reg < 32; ++reg)
           {
             fs->regs.reg[reg].how = REG_SAVED_OFFSET;
             fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *);
           }
#endif
         break;

       case DW_CFA_GNU_args_size:
         insn_ptr = read_uleb128 (insn_ptr, &context->args_size);
         break;

       case DW_CFA_GNU_negative_offset_extended:
         /* Obsoleted by DW_CFA_offset_extended_sf, but used by
            older PowerPC code.  */
         insn_ptr = read_uleb128 (insn_ptr, &reg);
         insn_ptr = read_uleb128 (insn_ptr, &utmp);
         offset = (_Unwind_Word) utmp * fs->data_align;
         fs->regs.reg[reg].how = REG_SAVED_OFFSET;
         fs->regs.reg[reg].loc.offset = -offset;
         break;

       default:
         abort ();
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static _Unwind_Word execute_stack_op ( const unsigned char *  op_ptr,
const unsigned char *  op_end,
struct _Unwind_Context context,
_Unwind_Word  initial 
) [static]

Definition at line 332 of file unwind-dw2.c.

{
  _Unwind_Word stack[64];   /* ??? Assume this is enough.  */
  int stack_elt;

  stack[0] = initial;
  stack_elt = 1;

  while (op_ptr < op_end)
    {
      enum dwarf_location_atom op = *op_ptr++;
      _Unwind_Word result, reg, utmp;
      _Unwind_Sword offset, stmp;

      switch (op)
       {
       case DW_OP_lit0:
       case DW_OP_lit1:
       case DW_OP_lit2:
       case DW_OP_lit3:
       case DW_OP_lit4:
       case DW_OP_lit5:
       case DW_OP_lit6:
       case DW_OP_lit7:
       case DW_OP_lit8:
       case DW_OP_lit9:
       case DW_OP_lit10:
       case DW_OP_lit11:
       case DW_OP_lit12:
       case DW_OP_lit13:
       case DW_OP_lit14:
       case DW_OP_lit15:
       case DW_OP_lit16:
       case DW_OP_lit17:
       case DW_OP_lit18:
       case DW_OP_lit19:
       case DW_OP_lit20:
       case DW_OP_lit21:
       case DW_OP_lit22:
       case DW_OP_lit23:
       case DW_OP_lit24:
       case DW_OP_lit25:
       case DW_OP_lit26:
       case DW_OP_lit27:
       case DW_OP_lit28:
       case DW_OP_lit29:
       case DW_OP_lit30:
       case DW_OP_lit31:
         result = op - DW_OP_lit0;
         break;

       case DW_OP_addr:
         result = (_Unwind_Word) (_Unwind_Ptr) read_pointer (op_ptr);
         op_ptr += sizeof (void *);
         break;

       case DW_OP_const1u:
         result = read_1u (op_ptr);
         op_ptr += 1;
         break;
       case DW_OP_const1s:
         result = read_1s (op_ptr);
         op_ptr += 1;
         break;
       case DW_OP_const2u:
         result = read_2u (op_ptr);
         op_ptr += 2;
         break;
       case DW_OP_const2s:
         result = read_2s (op_ptr);
         op_ptr += 2;
         break;
       case DW_OP_const4u:
         result = read_4u (op_ptr);
         op_ptr += 4;
         break;
       case DW_OP_const4s:
         result = read_4s (op_ptr);
         op_ptr += 4;
         break;
       case DW_OP_const8u:
         result = read_8u (op_ptr);
         op_ptr += 8;
         break;
       case DW_OP_const8s:
         result = read_8s (op_ptr);
         op_ptr += 8;
         break;
       case DW_OP_constu:
         op_ptr = read_uleb128 (op_ptr, &result);
         break;
       case DW_OP_consts:
         op_ptr = read_sleb128 (op_ptr, &stmp);
         result = stmp;
         break;

       case DW_OP_reg0:
       case DW_OP_reg1:
       case DW_OP_reg2:
       case DW_OP_reg3:
       case DW_OP_reg4:
       case DW_OP_reg5:
       case DW_OP_reg6:
       case DW_OP_reg7:
       case DW_OP_reg8:
       case DW_OP_reg9:
       case DW_OP_reg10:
       case DW_OP_reg11:
       case DW_OP_reg12:
       case DW_OP_reg13:
       case DW_OP_reg14:
       case DW_OP_reg15:
       case DW_OP_reg16:
       case DW_OP_reg17:
       case DW_OP_reg18:
       case DW_OP_reg19:
       case DW_OP_reg20:
       case DW_OP_reg21:
       case DW_OP_reg22:
       case DW_OP_reg23:
       case DW_OP_reg24:
       case DW_OP_reg25:
       case DW_OP_reg26:
       case DW_OP_reg27:
       case DW_OP_reg28:
       case DW_OP_reg29:
       case DW_OP_reg30:
       case DW_OP_reg31:
         result = _Unwind_GetGR (context, op - DW_OP_reg0);
         break;
       case DW_OP_regx:
         op_ptr = read_uleb128 (op_ptr, &reg);
         result = _Unwind_GetGR (context, reg);
         break;

       case DW_OP_breg0:
       case DW_OP_breg1:
       case DW_OP_breg2:
       case DW_OP_breg3:
       case DW_OP_breg4:
       case DW_OP_breg5:
       case DW_OP_breg6:
       case DW_OP_breg7:
       case DW_OP_breg8:
       case DW_OP_breg9:
       case DW_OP_breg10:
       case DW_OP_breg11:
       case DW_OP_breg12:
       case DW_OP_breg13:
       case DW_OP_breg14:
       case DW_OP_breg15:
       case DW_OP_breg16:
       case DW_OP_breg17:
       case DW_OP_breg18:
       case DW_OP_breg19:
       case DW_OP_breg20:
       case DW_OP_breg21:
       case DW_OP_breg22:
       case DW_OP_breg23:
       case DW_OP_breg24:
       case DW_OP_breg25:
       case DW_OP_breg26:
       case DW_OP_breg27:
       case DW_OP_breg28:
       case DW_OP_breg29:
       case DW_OP_breg30:
       case DW_OP_breg31:
         op_ptr = read_sleb128 (op_ptr, &offset);
         result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset;
         break;
       case DW_OP_bregx:
         op_ptr = read_uleb128 (op_ptr, &reg);
         op_ptr = read_sleb128 (op_ptr, &offset);
         result = _Unwind_GetGR (context, reg) + offset;
         break;

       case DW_OP_dup:
         if (stack_elt < 1)
           abort ();
         result = stack[stack_elt - 1];
         break;

       case DW_OP_drop:
         if (--stack_elt < 0)
           abort ();
         goto no_push;

       case DW_OP_pick:
         offset = *op_ptr++;
         if (offset >= stack_elt - 1)
           abort ();
         result = stack[stack_elt - 1 - offset];
         break;

       case DW_OP_over:
         if (stack_elt < 2)
           abort ();
         result = stack[stack_elt - 2];
         break;

       case DW_OP_rot:
         {
           _Unwind_Word t1, t2, t3;

           if (stack_elt < 3)
             abort ();
           t1 = stack[stack_elt - 1];
           t2 = stack[stack_elt - 2];
           t3 = stack[stack_elt - 3];
           stack[stack_elt - 1] = t2;
           stack[stack_elt - 2] = t3;
           stack[stack_elt - 3] = t1;
           goto no_push;
         }

       case DW_OP_deref:
       case DW_OP_deref_size:
       case DW_OP_abs:
       case DW_OP_neg:
       case DW_OP_not:
       case DW_OP_plus_uconst:
         /* Unary operations.  */
         if (--stack_elt < 0)
           abort ();
         result = stack[stack_elt];

         switch (op)
           {
           case DW_OP_deref:
             {
              void *ptr = (void *) (_Unwind_Ptr) result;
              result = (_Unwind_Ptr) read_pointer (ptr);
             }
             break;

           case DW_OP_deref_size:
             {
              void *ptr = (void *) (_Unwind_Ptr) result;
              switch (*op_ptr++)
                {
                case 1:
                  result = read_1u (ptr);
                  break;
                case 2:
                  result = read_2u (ptr);
                  break;
                case 4:
                  result = read_4u (ptr);
                  break;
                case 8:
                  result = read_8u (ptr);
                  break;
                default:
                  abort ();
                }
             }
             break;

           case DW_OP_abs:
             if ((_Unwind_Sword) result < 0)
              result = -result;
             break;
           case DW_OP_neg:
             result = -result;
             break;
           case DW_OP_not:
             result = ~result;
             break;
           case DW_OP_plus_uconst:
             op_ptr = read_uleb128 (op_ptr, &utmp);
             result += utmp;
             break;

           default:
             abort ();
           }
         break;

       case DW_OP_and:
       case DW_OP_div:
       case DW_OP_minus:
       case DW_OP_mod:
       case DW_OP_mul:
       case DW_OP_or:
       case DW_OP_plus:
       case DW_OP_le:
       case DW_OP_ge:
       case DW_OP_eq:
       case DW_OP_lt:
       case DW_OP_gt:
       case DW_OP_ne:
         {
           /* Binary operations.  */
           _Unwind_Word first, second;
           if ((stack_elt -= 2) < 0)
             abort ();
           second = stack[stack_elt];
           first = stack[stack_elt + 1];

           switch (op)
             {
             case DW_OP_and:
              result = second & first;
              break;
             case DW_OP_div:
              result = (_Unwind_Sword) second / (_Unwind_Sword) first;
              break;
             case DW_OP_minus:
              result = second - first;
              break;
             case DW_OP_mod:
              result = (_Unwind_Sword) second % (_Unwind_Sword) first;
              break;
             case DW_OP_mul:
              result = second * first;
              break;
             case DW_OP_or:
              result = second | first;
              break;
             case DW_OP_plus:
              result = second + first;
              break;
             case DW_OP_shl:
              result = second << first;
              break;
             case DW_OP_shr:
              result = second >> first;
              break;
             case DW_OP_shra:
              result = (_Unwind_Sword) second >> first;
              break;
             case DW_OP_xor:
              result = second ^ first;
              break;
             case DW_OP_le:
              result = (_Unwind_Sword) first <= (_Unwind_Sword) second;
              break;
             case DW_OP_ge:
              result = (_Unwind_Sword) first >= (_Unwind_Sword) second;
              break;
             case DW_OP_eq:
              result = (_Unwind_Sword) first == (_Unwind_Sword) second;
              break;
             case DW_OP_lt:
              result = (_Unwind_Sword) first < (_Unwind_Sword) second;
              break;
             case DW_OP_gt:
              result = (_Unwind_Sword) first > (_Unwind_Sword) second;
              break;
             case DW_OP_ne:
              result = (_Unwind_Sword) first != (_Unwind_Sword) second;
              break;

             default:
              abort ();
             }
         }
         break;

       case DW_OP_skip:
         offset = read_2s (op_ptr);
         op_ptr += 2;
         op_ptr += offset;
         goto no_push;

       case DW_OP_bra:
         if (--stack_elt < 0)
           abort ();
         offset = read_2s (op_ptr);
         op_ptr += 2;
         if (stack[stack_elt] != 0)
           op_ptr += offset;
         goto no_push;

       case DW_OP_nop:
         goto no_push;

       default:
         abort ();
       }

      /* Most things push a result value.  */
      if ((size_t) stack_elt >= sizeof(stack)/sizeof(*stack))
       abort ();
      stack[stack_elt++] = result;
    no_push:;
    }

  /* We were executing this program to get a value.  It should be
     at top of stack.  */
  if (--stack_elt < 0)
    abort ();
  return stack[stack_elt];
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const unsigned char* extract_cie_info ( struct dwarf_cie cie,
struct _Unwind_Context context,
_Unwind_FrameState fs 
) [static]

Definition at line 256 of file unwind-dw2.c.

{
  const unsigned char *aug = cie->augmentation;
  const unsigned char *p = aug + strlen ((const char *) aug) + 1;
  const unsigned char *ret = NULL;
  _Unwind_Word utmp;

  /* g++ v2 "eh" has pointer immediately following augmentation string,
     so it must be handled first.  */
  if (aug[0] == 'e' && aug[1] == 'h')
    {
      fs->eh_ptr = read_pointer (p);
      p += sizeof (void *);
      aug += 2;
    }

  /* Immediately following the augmentation are the code and
     data alignment and return address column.  */
  p = read_uleb128 (p, &fs->code_align);
  p = read_sleb128 (p, &fs->data_align);
  fs->retaddr_column = *p++;
  fs->lsda_encoding = DW_EH_PE_omit;

  /* If the augmentation starts with 'z', then a uleb128 immediately
     follows containing the length of the augmentation field following
     the size.  */
  if (*aug == 'z')
    {
      p = read_uleb128 (p, &utmp);
      ret = p + utmp;

      fs->saw_z = 1;
      ++aug;
    }

  /* Iterate over recognized augmentation subsequences.  */
  while (*aug != '\0')
    {
      /* "L" indicates a byte showing how the LSDA pointer is encoded.  */
      if (aug[0] == 'L')
       {
         fs->lsda_encoding = *p++;
         aug += 1;
       }

      /* "R" indicates a byte indicating how FDE addresses are encoded.  */
      else if (aug[0] == 'R')
       {
         fs->fde_encoding = *p++;
         aug += 1;
       }

      /* "P" indicates a personality routine in the CIE augmentation.  */
      else if (aug[0] == 'P')
       {
         _Unwind_Ptr personality;
         p = read_encoded_value (context, *p, p + 1, &personality);
         fs->personality = (_Unwind_Personality_Fn) personality;
         aug += 1;
       }

      /* Otherwise we have an unknown augmentation string.
        Bail unless we saw a 'z' prefix.  */
      else
       return ret;
    }

  return ret ? ret : p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void init_dwarf_reg_size_table ( void  ) [inline, static]

Definition at line 1245 of file unwind-dw2.c.

{
  __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table);

Here is the caller graph for this function:

static int read_1s ( const void *  p) [inline, static]

Definition at line 153 of file unwind-dw2.c.

{ return *(const signed char *) p; }

Here is the caller graph for this function:

static int read_1u ( const void *  p) [inline, static]

Definition at line 150 of file unwind-dw2.c.

{ return *(const unsigned char *) p; }

Here is the caller graph for this function:

static int read_2s ( const void *  p) [inline, static]

Definition at line 159 of file unwind-dw2.c.

{ const union unaligned *up = p; return up->s2; }

Here is the caller graph for this function:

static int read_2u ( const void *  p) [inline, static]

Definition at line 156 of file unwind-dw2.c.

{ const union unaligned *up = p; return up->u2; }

Here is the caller graph for this function:

static int read_4s ( const void *  p) [inline, static]

Definition at line 165 of file unwind-dw2.c.

{ const union unaligned *up = p; return up->s4; }

Here is the caller graph for this function:

static unsigned int read_4u ( const void *  p) [inline, static]

Definition at line 162 of file unwind-dw2.c.

{ const union unaligned *up = p; return up->u4; }

Here is the caller graph for this function:

static unsigned long read_8s ( const void *  p) [inline, static]

Definition at line 171 of file unwind-dw2.c.

{ const union unaligned *up = p; return up->s8; }

Here is the caller graph for this function:

static unsigned long read_8u ( const void *  p) [inline, static]

Definition at line 168 of file unwind-dw2.c.

{ const union unaligned *up = p; return up->u8; }

Here is the caller graph for this function:

static void* read_pointer ( const void *  p) [inline, static]

Definition at line 147 of file unwind-dw2.c.

{ const union unaligned *up = p; return up->p; }

Here is the caller graph for this function:

static _Unwind_Reason_Code uw_frame_state_for ( struct _Unwind_Context context,
_Unwind_FrameState fs 
) [static]

Definition at line 951 of file unwind-dw2.c.

{
  struct dwarf_fde *fde;
  struct dwarf_cie *cie;
  const unsigned char *aug, *insn, *end;

  memset (fs, 0, sizeof (*fs));
  context->args_size = 0;
  context->lsda = 0;

  fde = _Unwind_Find_FDE (context->ra - 1, &context->bases);
  if (fde == NULL)
    {
      /* Couldn't find frame unwind info for this function.  Try a
        target-specific fallback mechanism.  This will necessarily
        not provide a personality routine or LSDA.  */
#ifdef MD_FALLBACK_FRAME_STATE_FOR
      MD_FALLBACK_FRAME_STATE_FOR (context, fs, success);
      return _URC_END_OF_STACK;
    success:
      return _URC_NO_REASON;
#else
      return _URC_END_OF_STACK;
#endif
    }

  fs->pc = context->bases.func;

  cie = get_cie (fde);
  insn = extract_cie_info (cie, context, fs);
  if (insn == NULL)
    /* CIE contained unknown augmentation.  */
    return _URC_FATAL_PHASE1_ERROR;

  /* First decode all the insns in the CIE.  */
  end = (unsigned char *) next_fde ((struct dwarf_fde *) cie);
  execute_cfa_program (insn, end, context, fs);

  /* Locate augmentation for the fde.  */
  aug = (unsigned char *) fde + sizeof (*fde);
  aug += 2 * size_of_encoded_value (fs->fde_encoding);
  insn = NULL;
  if (fs->saw_z)
    {
      _Unwind_Word i;
      aug = read_uleb128 (aug, &i);
      insn = aug + i;
    }
  if (fs->lsda_encoding != DW_EH_PE_omit)
    {
      _Unwind_Ptr lsda;
      aug = read_encoded_value (context, fs->lsda_encoding, aug, &lsda);
      context->lsda = (void *) lsda;
    }

  /* Then the insns in the FDE up to our target PC.  */
  if (insn == NULL)
    insn = aug;
  end = (unsigned char *) next_fde (fde);
  execute_cfa_program (insn, end, context, fs);

  return _URC_NO_REASON;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static _Unwind_Ptr uw_identify_context ( struct _Unwind_Context context) [inline, static]

Definition at line 1299 of file unwind-dw2.c.

{
  return _Unwind_GetIP (context);
static void uw_init_context_1 ( struct _Unwind_Context context,
void *  outer_cfa,
void *  outer_ra 
) [static]

Definition at line 1202 of file unwind-dw2.c.

{
  void *ra = __builtin_extract_return_addr (__builtin_return_address (0));
  _Unwind_FrameState fs;
  _Unwind_Word sp_slot;

  memset (context, 0, sizeof (struct _Unwind_Context));
  context->ra = ra;

  if (uw_frame_state_for (context, &fs) != _URC_NO_REASON)
    abort ();

  /* Force the frame state to use the known cfa value.  */
  sp_slot = (_Unwind_Ptr) outer_cfa;
  context->reg[__builtin_dwarf_sp_column ()] = &sp_slot;
  fs.cfa_how = CFA_REG_OFFSET;
  fs.cfa_reg = __builtin_dwarf_sp_column ();
  fs.cfa_offset = 0;

  uw_update_context_1 (context, &fs);

  /* If the return address column was saved in a register in the
     initialization context, then we can't see it in the given
     call frame data.  So have the initialization context tell us.  */
  context->ra = __builtin_extract_return_addr (outer_ra);

Here is the call graph for this function:

static long uw_install_context_1 ( struct _Unwind_Context current,
struct _Unwind_Context target 
) [static]

Definition at line 1251 of file unwind-dw2.c.

{
  long i;

#if __GTHREADS
  {
    static __gthread_once_t once_regsizes = __GTHREAD_ONCE_INIT;
    if (__gthread_once (&once_regsizes, init_dwarf_reg_size_table) != 0
       || dwarf_reg_size_table[0] == 0)
      init_dwarf_reg_size_table ();
  }
#else
  if (dwarf_reg_size_table[0] == 0)
    init_dwarf_reg_size_table ();
#endif

  for (i = 0; i < DWARF_FRAME_REGISTERS; ++i)
    {
      void *c = current->reg[i];
      void *t = target->reg[i];
      if (t && c && t != c)
       memcpy (c, t, dwarf_reg_size_table[i]);
    }

#ifdef EH_RETURN_STACKADJ_RTX
  {
    void *target_cfa;

    /* If the last frame records a saved stack pointer, use it.  */
    if (target->reg[__builtin_dwarf_sp_column ()])
      target_cfa = (void *)(_Unwind_Ptr)
        _Unwind_GetGR (target, __builtin_dwarf_sp_column ());
    else
      target_cfa = target->cfa;

    /* We adjust SP by the difference between CURRENT and TARGET's CFA.  */
    if (STACK_GROWS_DOWNWARD)
      return target_cfa - current->cfa + target->args_size;
    else
      return current->cfa - target_cfa - target->args_size;
  }
#else
  return 0;
#endif

Here is the call graph for this function:

static void uw_update_context ( struct _Unwind_Context context,
_Unwind_FrameState fs 
) [static]

Definition at line 1178 of file unwind-dw2.c.

{
  uw_update_context_1 (context, fs);

  /* Compute the return address now, since the return address column
     can change from frame to frame.  */
  context->ra = __builtin_extract_return_addr
    ((void *) (_Unwind_Ptr) _Unwind_GetGR (context, fs->retaddr_column));
}

Here is the call graph for this function:

static void uw_update_context_1 ( struct _Unwind_Context context,
_Unwind_FrameState fs 
) [static]

Definition at line 1086 of file unwind-dw2.c.

{
  struct _Unwind_Context orig_context = *context;
  void *cfa;
  long i;

#ifdef EH_RETURN_STACKADJ_RTX
  /* Special handling here: Many machines do not use a frame pointer,
     and track the CFA only through offsets from the stack pointer from
     one frame to the next.  In this case, the stack pointer is never
     stored, so it has no saved address in the context.  What we do
     have is the CFA from the previous stack frame.

     In very special situations (such as unwind info for signal return),
     there may be location expressions that use the stack pointer as well.

     Do this conditionally for one frame.  This allows the unwind info
     for one frame to save a copy of the stack pointer from the previous
     frame, and be able to use much easier CFA mechanisms to do it.
     Always zap the saved stack pointer value for the next frame; carrying
     the value over from one frame to another doesn't make sense.  */

  _Unwind_Word tmp_sp;

  if (!orig_context.reg[__builtin_dwarf_sp_column ()])
    {
      tmp_sp = (_Unwind_Ptr) context->cfa;
      orig_context.reg[__builtin_dwarf_sp_column ()] = &tmp_sp;
    }
  context->reg[__builtin_dwarf_sp_column ()] = NULL;
#endif

  /* Compute this frame's CFA.  */
  switch (fs->cfa_how)
    {
    case CFA_REG_OFFSET:
      cfa = (void *) (_Unwind_Ptr) _Unwind_GetGR (&orig_context, fs->cfa_reg);
      cfa += fs->cfa_offset;
      break;

    case CFA_EXP:
      {
       const unsigned char *exp = fs->cfa_exp;
       _Unwind_Word len;

       exp = read_uleb128 (exp, &len);
       cfa = (void *) (_Unwind_Ptr)
         execute_stack_op (exp, exp + len, &orig_context, 0);
       break;
      }

    default:
      abort ();
    }
  context->cfa = cfa;

  /* Compute the addresses of all registers saved in this frame.  */
  for (i = 0; i < DWARF_FRAME_REGISTERS + 1; ++i)
    switch (fs->regs.reg[i].how)
      {
      case REG_UNSAVED:
       break;

      case REG_SAVED_OFFSET:
       context->reg[i] = cfa + fs->regs.reg[i].loc.offset;
       break;

      case REG_SAVED_REG:
       context->reg[i] = orig_context.reg[fs->regs.reg[i].loc.reg];
       break;

      case REG_SAVED_EXP:
       {
         const unsigned char *exp = fs->regs.reg[i].loc.exp;
         _Unwind_Word len;
         _Unwind_Ptr val;

         exp = read_uleb128 (exp, &len);
         val = execute_stack_op (exp, exp + len, &orig_context,
                              (_Unwind_Ptr) cfa);
         context->reg[i] = (void *) val;
       }
       break;
      }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 77 of file unwind-dw2.c.

void* p

Definition at line 145 of file unwind-dw2.c.