/* unwinder.c

 *

 * Copyright 2002-2003 ARM Limited.

 */

/*

  Licence

  1. Subject to the provisions of clause 2, ARM hereby grants to LICENSEE a

  perpetual, non-exclusive, nontransferable, royalty free, worldwide licence

  to use this Example Implementation of Exception Handling solely for the

  purpose of developing, having developed, manufacturing, having

  manufactured, offering to sell, selling, supplying or otherwise

  distributing products which comply with the Exception Handling ABI for the

  ARM Architecture specification. All other rights are reserved to ARM or its

  licensors.

  2. THIS EXAMPLE IMPLEMENTATION OF EXCEPTION HANDLING  IS PROVIDED "AS IS"

  WITH NO WARRANTIES EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT LIMITED

  TO ANY WARRANTY OF SATISFACTORY QUALITY, MERCHANTABILITY, NONINFRINGEMENT

  OR FITNESS FOR A PARTICULAR PURPOSE.

*/

/*

 * RCS $Revision: 1.16 $

 * Checkin $Date: 2003/10/23 13:57:39 $

 * Revising $Author: agrant $

 */

/* Language-independent unwinder implementation */

/* This source file is compiled automatically by ARM's make system into

 * multiple object files. The source regions constituting object file

 * xxx.o are delimited by ifdef xxx_c / endif directives.

 *

 * The source regions currently marked are:

 * unwinder_c

 * unwind_activity_c

 */

#include <stddef.h>

#include <stdlib.h>

/* Environment: */

#include "unwind_env.h"

/* Language-independent unwinder declarations: */

#include "unwinder.h"

/* Define UNWIND_ACTIVITY_DIAGNOSTICS for printed information from _Unwind_Activity */

/* Define VRS_DIAGNOSTICS for printed diagnostics about VRS operations */

#if defined(VRS_DIAGNOSTICS) || defined(UNWIND_ACTIVITY_DIAGNOSTICS)

extern int printf(const char *, ...);

#endif

#ifdef unwinder_c

/* =========================                      ========================= */

/* ========================= Virtual register set ========================= */

/* =========================                      ========================= */

/* The approach taken by this implementation is to use the real machine

 * registers to hold all but the values of core (integer)

 * registers. Consequently the implementation must use only the core

 * registers except when manipulating the virtual register set. Non-core

 * registers are saved only on first use, so the single implementation can

 * cope with execution on processors which lack certain registers.  The

 * registers as they were at the start of the propagation must be preserved

 * over phase 1 so that the machine state is correct at the start of phase

 * 2. This requires a copy to be taken (which can be stack allocated). During

 * a stack unwind (phase 1 or phase 2), the "current" virtual register set is

 * implemented as core register values held in a data structure, and non-core

 * register values held in the registers themselves. To ensure that all

 * original register values are available at the beginning of phase 2, the

 * core registers are saved in a second structure at the start of phase 1 and

 * the non-core registers are demand-saved into another part of the data

 * structure that holds the current core registers during the phase 1 stack

 * unwind.

 */

/* Extent to which the access routines are implemented:

 * _Unwind_VRS_Get and _Unwind_VRS_Set implement only access to the core registers.

 * _Unwind_VRS_Pop implements only popping of core, vfp and fpa registers.

 * There is no support here for the Intel WMMX registers, but space is nevertheless

 * reserved in the virtual register set structure to indicate whether demand-saving

 * of those registers is required (as they are unsupported, it never is). The space

 * costs nothing as it is required for alignment.

 * The level of supported functionality is compliant with the requirements of the

 * Exceptions ABI.

 */

typedef unsigned char bool;

struct core_s  { uint32_t r[16]; };        /* core integer regs */

struct vfp_s   { uint64_t vfp[16+1]; };    /* VFP registers saved in FSTMX format */

                                           /* Extra 2 words for the format word + unused  */

struct fpa_reg { uint32_t word[3]; };

struct fpa_s   { struct fpa_reg fpa[8]; }; /* FPA registers saved in SFM format */

/* Phase 1 virtual register set includes demand-save areas */

/* The phase 2 virtual register set must be a prefix of the phase 1 set */

typedef struct phase1_virtual_register_set_s {

  /* demand_save flag == 1 means save the registers in the demand-save area */

  bool demand_save_vfp;

  bool demand_save_fpa;

  bool demand_save_wmmxd;

  bool demand_save_wmmxc;

  struct core_s core;      /* current core registers */

  struct vfp_s  vfp;       /* demand-saved vfp registers */

  struct fpa_s  fpa;       /* demand-saved fpa registers */

} phase1_virtual_register_set;

/* Phase 2 virtual register set has no demand-save areas */

/* The phase 2 virtual register set must be a prefix of the phase 1 set */

/* The assembly fragments for _Unwind_RaiseException and _Unwind_Resume create

 * a phase2_virtual_register_set_s by hand so be careful.

 */

typedef struct phase2_virtual_register_set_s {

  /* demand_save flag == 1 means save the registers in the demand-save area */

  /* Always 0 in phase 2 */

  bool demand_save_vfp;

  bool demand_save_fpa;

  bool demand_save_wmmxd;

  bool demand_save_wmmxc;

  struct core_s core;      /* current core registers */

} phase2_virtual_register_set;

/* -- Helper macros for the embedded assembly */

#if defined(__TARGET_ARCH_5T) || defined(__TARGET_ARCH_5TXM) || defined(__TARGET_ARCH_5TE) || \

    defined(__TARGET_ARCH_6)  /* || ... */

  #define ARCH_5T_OR_LATER 1

#else

  #define ARCH_5T_OR_LATER 0

#endif

#if defined(__APCS_INTERWORK) && !ARCH_5T_OR_LATER

  #define OLD_STYLE_INTERWORKING 1

#else

  #define OLD_STYLE_INTERWORKING 0

#endif

#if defined(__TARGET_ARCH_4T) || defined(__TARGET_ARCH_4TXM) || ARCH_5T_OR_LATER

  #define HAVE_BX 1

#else

  #define HAVE_BX 0

#endif

#if HAVE_BX

  #define RET_LR bx lr

#else

  #define RET_LR mov pc,lr

#endif

/* ----- Routines: ----- */

/* ----- Helper routines, private but external ----- */

/* Note '%0' refers to local label '0' */

__asm void __ARM_Unwind_VRS_VFPpreserve(void *vfpp)

{

  /* Preserve the vfp registers in the passed memory */

#ifdef __thumb

  #define MAYBE_SWITCH_TO_ARM_STATE SWITCH_TO_ARM_STATE

  #define MAYBE_CODE16 code16

  macro;

  SWITCH_TO_ARM_STATE;

1

  align 4;

2

  assert (%2 - %1) = 0;

  bx pc;

  nop;

  code32;

  mend;

#else

  #define MAYBE_SWITCH_TO_ARM_STATE /* nothing */

  #define MAYBE_CODE16 /* nothing */

#endif

vfp_d0 CN 0;

  MAYBE_SWITCH_TO_ARM_STATE;

  stc   p11,vfp_d0,[r0],{0x21};  /* 0xec800b21  FSTMIAX r0,{d0-d15} */

  RET_LR;

  MAYBE_CODE16;

}

__asm void __ARM_Unwind_VRS_VFPrestore(void *vfpp)

{

  /* Restore the vfp registers from the passed memory */

vfp_d0 CN 0;

  MAYBE_SWITCH_TO_ARM_STATE;

  ldc   p11,vfp_d0,[r0],{0x21};  /* 0xec900b21  FLDMIAX r0,{d0-d15} */

  RET_LR;

  MAYBE_CODE16;

}

__asm void __ARM_Unwind_VRS_FPApreserve(void *vfpp)

{

  /* Preserve the fpa registers in the passed memory */

fpa_f0 CN 0;

fpa_f4 CN 0;

  MAYBE_SWITCH_TO_ARM_STATE;

  stc   p2, fpa_f0, [r0];       /* 0xed800200  SFM f0,4,[r0,#0]    */

  stc   p2, fpa_f4, [r0, #48];  /* 0xed80420c  SFM f4,4,[r0,#0x30] */

  RET_LR;

  MAYBE_CODE16;

}

__asm void __ARM_Unwind_VRS_FPArestore(void *vfpp)

{

  /* Restore the fpa registers from the passed memory */

fpa_f0 CN 0;

fpa_f4 CN 0;

  MAYBE_SWITCH_TO_ARM_STATE;

  ldc   p2, fpa_f0, [r0];       /* 0xed900200  LFM f0,4,[r0,#0]    */

  ldc   p2, fpa_f4, [r0, #48];  /* 0xed90020c  LFM f4,4,[r0,#0x30] */

  RET_LR;

  MAYBE_CODE16;

}

__asm NORETURNDECL void __ARM_Unwind_VRS_corerestore(void *corep)

{

  /* By hypothesis this is preserve8 but the load of sp means the

   * assembler can't infer that.

   */

  preserve8;

  MAYBE_SWITCH_TO_ARM_STATE;

#if OLD_STYLE_INTERWORKING

  mov r14, r0;

  ldmia r14!,{r0-r12};

  ldr   r12,[r14, #4*2]; /* pc */

  ldmia r14,{r13-r14};

  bx    r12;

#else

  ldmia r0,{r0-r15};

#endif

  MAYBE_CODE16;

}

/* ----- Development support ----- */

#ifdef VRS_DIAGNOSTICS

static void debug_print_vrs_vfp(struct vfp_s *vfpp)

{

  uint64_t *lp = (uint64_t *)vfpp;

  int c = 0;

  int i;

  for (i = 0; i < 16; i++) {

    printf("D%-2d  0x%16.16llx    ", i, *lp);

    lp++;

    if (c++ == 1) {

      c = 0;

      printf("\n");

    }

  }

}

static void debug_print_vrs_fpa(struct fpa_s *fpap)

{

  uint32_t *lp = (uint32_t *)fpap;

  int c = 0;

  int i;

  for (i = 0; i < 8; i++) {

    printf("F%-2d  0x%8.8x%8.8x%8.8x    ", i, *lp, *(lp+1), *(lp+2));

    lp+=3;

    if (c++ == 1) {

      c = 0;

      printf("\n");

    }

  }

}

static void debug_print_vrs(_Unwind_Context *context)

{

  phase1_virtual_register_set *vrsp = (phase1_virtual_register_set *)context;

  int i;

  int c;

  printf("------------------------------------------------------------------------\n");

  c = 0;

  for (i = 0; i < 16; i++) {

    printf("r%-2d  0x%8.8x    ", i, vrsp->core.r[i]);

    if (c++ == 3) {

      c = 0;

      printf("\n");

    }

  }

  printf("-----\n");

  if (vrsp->demand_save_vfp == 1)

    printf("VFP is not saved\n");

  else

    debug_print_vrs_vfp(&vrsp->vfp);

  printf("-----\n");

  if (vrsp->demand_save_fpa == 1)

    printf("FPA is not saved\n");

  else

    debug_print_vrs_fpa(&vrsp->fpa);

  printf("------------------------------------------------------------------------\n");

}

#endif

/* ----- Public routines ----- */

_Unwind_VRS_Result _Unwind_VRS_Set(_Unwind_Context *context,

                                   _Unwind_VRS_RegClass regclass,

                                   uint32_t regno,

                                   _Unwind_VRS_DataRepresentation representation,

                                   void *valuep)

{

  phase1_virtual_register_set *vrsp = (phase1_virtual_register_set *)context;

  switch (regclass) {

  case _UVRSC_CORE:

    {

      if (representation != _UVRSD_UINT32 || regno > 15)

        return _UVRSR_FAILED;

       vrsp->core.r[regno] = *(uint32_t *)valuep;

       return _UVRSR_OK;

    }

  case _UVRSC_VFP:

  case _UVRSC_FPA:

  case _UVRSC_WMMXD:

  case _UVRSC_WMMXC:

    return _UVRSR_NOT_IMPLEMENTED;

  default:

    break;

  }

  return _UVRSR_FAILED;

}

_Unwind_VRS_Result _Unwind_VRS_Get(_Unwind_Context *context,

                                   _Unwind_VRS_RegClass regclass,

                                   uint32_t regno,

                                   _Unwind_VRS_DataRepresentation representation,

                                   void *valuep)

{

  phase1_virtual_register_set *vrsp = (phase1_virtual_register_set *)context;

  switch (regclass) {

  case _UVRSC_CORE:

    {

      if (representation != _UVRSD_UINT32 || regno > 15)

        return _UVRSR_FAILED;

      *(uint32_t *)valuep = vrsp->core.r[regno];

      return _UVRSR_OK;

    }

  case _UVRSC_VFP:

  case _UVRSC_FPA:

  case _UVRSC_WMMXD:

  case _UVRSC_WMMXC:

    return _UVRSR_NOT_IMPLEMENTED;

  default:

    break;

  }

  return _UVRSR_FAILED;

}

#define R_SP 13

_Unwind_VRS_Result _Unwind_VRS_Pop(_Unwind_Context *context,

                                   _Unwind_VRS_RegClass regclass,

                                   uint32_t descriminator,

                                   _Unwind_VRS_DataRepresentation representation)

{

  phase1_virtual_register_set *vrsp = (phase1_virtual_register_set *)context;

  switch (regclass) {

  case _UVRSC_CORE:

    {

      /* If SP is included in the mask, the loaded value is used in preference to

       * the writeback value, but only on completion of the loading.

       */

      uint32_t mask, *vsp, *rp, sp_loaded;

      if (representation != _UVRSD_UINT32)

        return _UVRSR_FAILED;

      vsp = (uint32_t *)vrsp->core.r[R_SP];

      rp = (uint32_t *)&vrsp->core;

      mask = descriminator & 0xffff;

      sp_loaded = mask & (1 << R_SP);

      while (mask != 0) {

        if (mask & 1) {

#ifdef VRS_DIAGNOSTICS

          printf("VRS Pop r%d\n", rp - &vrsp->core.r[0]);

#endif

          *rp = *vsp++;

        }

        rp++;

        mask >>= 1;

      }

      if (!sp_loaded)

        vrsp->core.r[R_SP] = (uint32_t)vsp;

      return _UVRSR_OK;

    }

  case _UVRSC_VFP:

    {

      uint32_t start = descriminator >> 16;

      uint32_t count = descriminator & 0xffff;

      if (representation != _UVRSD_VFPX || start + count > 16)

        return _UVRSR_FAILED;

      if (vrsp->demand_save_vfp == 1) { /* Demand-save over phase 1 */

       vrsp->demand_save_vfp = 0;

       __ARM_Unwind_VRS_VFPpreserve(&vrsp->vfp);

      }

      /* Now recover from the stack into the real machine registers.

       * Note we assume FSTMX standard format 1.

       * Do this by saving the current VFP registers to a memory area,

       * moving the in-memory values over that area, and

       * restoring from the whole area.

       */

      {

        struct vfp_s temp_vfp;

        uint64_t *vsp;

        __ARM_Unwind_VRS_VFPpreserve(&temp_vfp);

        vsp = (uint64_t *)vrsp->core.r[R_SP];

        while (count--) {

#ifdef VRS_DIAGNOSTICS

          printf("VRS Pop D%d = 0x%llx\n", start, *vsp);

#endif

          temp_vfp.vfp[start++] = *vsp++;

        }

        vrsp->core.r[R_SP] = (uint32_t)((uint32_t *)vsp + 1); /* +1 to skip the format word */

        __ARM_Unwind_VRS_VFPrestore(&temp_vfp);

      }

      return _UVRSR_OK;

    }

  case _UVRSC_FPA:

    {

      uint32_t start = descriminator >> 16;

      uint32_t count = descriminator & 0xffff;

      if (representation != _UVRSD_FPAX || start > 7 || count > 4)

        return _UVRSR_FAILED;

      if (vrsp->demand_save_fpa == 1) { /* Demand-save over phase 1 */

        vrsp->demand_save_fpa = 0;

        __ARM_Unwind_VRS_FPApreserve(&vrsp->fpa);

      }

      /* Now recover from the stack into the real machine registers.

       * Do this by saving the current FPA registers to a memory area,

       * moving the in-memory values over that area, and

       * restoring from the whole area.

       * Unlike VFP, here the range is allowed to wrap round.

       */

      {

        struct fpa_s temp_fpa;

        struct fpa_reg *vsp;

        __ARM_Unwind_VRS_FPApreserve(&temp_fpa);

        vsp = (struct fpa_reg *)vrsp->core.r[R_SP];

        while (count--) {

#ifdef VRS_DIAGNOSTICS

          printf("VRS Pop F%d = 0x%-8.8x%-8.8x%-8.8x\n", start, *(uint32_t *)vsp,

                 *((uint32_t *)vsp + 1), *((uint32_t *)vsp + 2));

#endif

          temp_fpa.fpa[start++] = *vsp++;

          start &= 7;

        }

        vrsp->core.r[R_SP] = (uint32_t)vsp;

        __ARM_Unwind_VRS_FPArestore(&temp_fpa);

      }

      return _UVRSR_OK;

    }

  case _UVRSC_WMMXD:

  case _UVRSC_WMMXC:

    return _UVRSR_NOT_IMPLEMENTED;

  default:

    break;

  }

  return _UVRSR_FAILED;

}

/* =========================              ========================= */

/* ========================= The unwinder ========================= */

/* =========================              ========================= */

/* This implementation uses the UCB unwinder_cache as follows:

 * reserved1 is documented in the EABI as requiring initialisation to 0.

 *  It is used to manage nested simultaneous propagation. If the value is 0,

 *  the UCB is participating in no propagations. If the value is 1, the UCB

 *  is participating in one propagation. Otherwise the value is a pointer to

 *  a structure holding saved UCB state from the next propagation out.

 *  The structure used is simply a mallocated UCB.

 * reserved2 is used to preserve the call-site address over calls to a

 *  personality routine and cleanup.

 * reserved3 is used to cache the PR address.

 * reserved4 is not used.

 * reserved5 is not used.

 */

#define NESTED_CONTEXT      unwinder_cache.reserved1

#define SAVED_CALLSITE_ADDR unwinder_cache.reserved2

#define PR_ADDR             unwinder_cache.reserved3

/* Index table entry: */

typedef struct __EIT_entry {

  uint32_t fnoffset; /* Relative to base of execution region */

  uint32_t content;

} __EIT_entry;

/* Private defines etc: */

static const uint32_t EXIDX_CANTUNWIND = 1;

static const uint32_t uint32_highbit = 0x80000000;

/* ARM C++ personality routines: */

typedef _Unwind_Reason_Code (*personality_routine)(_Unwind_State,

                                                   _Unwind_Control_Block *,

                                                   _Unwind_Context *);

WEAKDECL _Unwind_Reason_Code __aeabi_unwind_cpp_pr0(_Unwind_State state, _Unwind_Control_Block *,

                                                    _Unwind_Context *context);

WEAKDECL _Unwind_Reason_Code __aeabi_unwind_cpp_pr1(_Unwind_State state, _Unwind_Control_Block *,

                                                    _Unwind_Context *context);

WEAKDECL _Unwind_Reason_Code __aeabi_unwind_cpp_pr2(_Unwind_State state, _Unwind_Control_Block *,

                                                    _Unwind_Context *context);

/* Various image symbols: */

struct ExceptionTableInfo {

  uint32_t EIT_base;

  uint32_t EIT_limit;

};

/* We define __ARM_ETInfo to allow access to some linker-generated

   names that are not legal C identifiers. __ARM_ETInfo is extern only

   because of scope limitations of the embedded assembler */

extern const struct ExceptionTableInfo __ARM_ETInfo;

#define EIT_base \