exidx_unwind.h

#ifndef __EXIDX_UNWIND_H
#define __EXIDX_UNWIND_H
/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#include <predef.h>
#include <stdint.h>
#include <stddef.h>
 
#define COMP_ENTRY_IDX_MASK (0xF << 24)
#define ARM_EXIDX_CMD_FINISH 0xB0
#define ARM_EXIDX_CMD_REFUSED 0x80
#define ARM_EXIDX_CMD_REG_POP 0xB1
#define ARM_EXIDX_CMD_DATA_POP 0xB2
#define ARM_EXIDX_CMD_VFP_POP 0xB3
#define ARM_EXIDX_CMD_WCGR_POP 0xC7
#define ARM_EXIDX_PRS_CANT_UNWIND 0x00000001
 
typedef enum
{
    ARM_RET_HND_FP = 0xFFFFFFE1,
    ARM_RET_MSP_FP = 0xFFFFFFE9,
    ARM_RET_PSP_FP = 0xFFFFFFED,
    ARM_RET_HND_NOFP = 0xFFFFFFF1,
    ARM_RET_MSP_NOFP = 0xFFFFFFF9,
    ARM_RET_PSP_NOFP = 0xFFFFFFFD,
} ExceptRet_LR_t;
 
struct insn_t
{
    const uint32_t *prs32;   // pointer to table entry holding the instructions
    int rem;                 // Remaining instruction count to unwind frame
    int idx;                 // index of next instruction in entry word
 
    int getNext();
    int peek();
    uint32_t get_uleb128();
    void init(const uint32_t *tab_entry);
};
 
/*
 * To convert the index table entry into an exception address, we must first
 *  sign extend the offset value (since only 31 bits are stored).
 *  We then add this offset to the address of the entry to get the handling
 *  table entry. I think...
 */
inline uint32_t prel31Addr(const uint32_t *prel31)
{
    int32_t s_ext_offset = (*((int32_t *)prel31) << 1) >> 1;
    return (((uint32_t)prel31) + s_ext_offset) & 0x7FffFFff;
}
 
struct exidx_t
{
    uint32_t offset;
    uint32_t xtab_insn;
 
    inline uint32_t asAddr() const { return prel31Addr(&offset); }
    const int getInsn(insn_t *insn) const;
};
 
extern const exidx_t __exidx_start[];
extern const exidx_t __exidx_end[];
 
// Virtual Register set for stack unwinding
struct vrs_t
{
    union
    {
        uint32_t r[16];
        struct
        {
            uint32_t _r[12];
            uint32_t ip;
            uint32_t *sp;
            uint32_t lr;
            uint32_t pc;
        };
    };
    uint32_t xpsr;
    uint64_t fpr[16];
    uint32_t fpscr;
    bool bVPSP;   // is our virtual stack pointer currently the Process Stack Pointer
};
 
typedef void *unwind_trace_dat_t;
typedef int (*unwind_trace_fn)(const vrs_t &vrs, unwind_trace_dat_t trace_dat);
 
struct unwind_ctx
{
    vrs_t vrs;
    insn_t insn;
    uint32_t maxRecurse;
    uint32_t flags;
 
    int step();
    int unwind_frame();
    inline void init() volatile
    {
        // Do not modify without verifying dissassembly...
        uint32_t offset;
        offset = offsetof(unwind_ctx, vrs) + offsetof(vrs_t, r) + 4 * sizeof(vrs.r[0]);
        asm volatile(
            "add %%r1,  %0, %1\n\t"
            "str %%r4,  [%%r1], #4\n\t"
            "str %%r5,  [%%r1], #4\n\t"
            "str %%r6,  [%%r1], #4\n\t"
            "str %%r7,  [%%r1], #4\n\t"
            "str %%r8,  [%%r1], #4\n\t"
            "str %%r9,  [%%r1], #4\n\t"
            "str %%r10, [%%r1], #4\n\t"
            "str %%r11, [%%r1], #4\n\t"
            :
            : "r"(this), "r"(offset)
            : "r1", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "memory");
    }
    inline void initFpr() volatile
    {
#if ((__SOFTFP__ != 1) || (defined __ARM_FP))
        // Do not modify without verifying dissassembly...
        uint32_t offset;
        offset = offsetof(unwind_ctx, vrs) + offsetof(vrs_t, fpr);
        asm volatile(
            "add %%r1,  %0, %1\n\t"
            "vstm.64 %%r1!, {%%d0-%%d15}\n\t"
            "vmrs    %%r2, FPSCR\n\t"
            "str     %%r2, [%%r1]\n\t"
            :
            : "r"(this), "r"(offset)
            : "r1", "r2", "memory");
#endif
    }
    inline void initForRunning() volatile
    {
        // Do not modify without verifying dissassembly...
        uint32_t offset;
        offset = offsetof(unwind_ctx, vrs) + offsetof(vrs_t, r) + 2 * sizeof(vrs.r[0]);
        asm volatile(
            "add %%r1,  %0, %1\n\t"
            "stm r1!, {r2-r12}\n\t"
            "str sp, [r1], #4\n\t"
            "str lr, [r1], #4\n\t"
            :
            : "r"(this), "r"(offset)
            : "r1", "memory");
    }
    void init(volatile cpu_tcb *ptcb);
    void init(uint32_t sp, uint32_t lr, uint32_t pc);
    void unwind_eframe();
    int unwind_stack(unwind_trace_fn trace_cb, unwind_trace_dat_t trace_dat);
};
 
// Exception Frame for no FPU or FPU disabled.
typedef struct
{
    union
    {
        struct
        {
            uint32_t r0;
            uint32_t r1;
            uint32_t r2;
            uint32_t r3;
            uint32_t r12;
            uint32_t lr;
            uint32_t pc;
            uint32_t xprs;
        };
        uint32_t r[16];
    };
} eframe_t;
 
// Exception Frame with FPU
typedef struct
{
    union
    {
        struct
        {
            uint32_t r0;
            uint32_t r1;
            uint32_t r2;
            uint32_t r3;
            uint32_t r12;
            uint32_t lr;
            uint32_t pc;
            uint32_t xprs;
        };
        uint32_t r[16];
    };
    union
    {
        uint32_t fp[32];
        uint64_t dfp[16];
    };
    uint32_t fpscr;
} eframe_fp_t;
 
// Minimal state context for stack unwind
typedef struct
{
    uint32_t pc;
    uint32_t lr;
    uint32_t sp;
} uwctx;
 
// extab exception table entry
typedef struct
{
    uint32_t prs_fn_offset;
    uint32_t prs_data;
} extab_entry_gen;
 
struct extab_insn_tbl
{
    inline uint8_t operator[](int i);
};
 
struct extab_insn_ctx
{
};
 
struct extab_entry_comp
{
    uint32_t idx_prs;
    uint32_t prs_data[];
    uint8_t operator[](int i);
};
 
exidx_t *find_insn(uint32_t *start, uint32_t *end, uint32_t pc);
 
#endif /* ----- #ifndef __EXIDX_UNWIND_H  ----- */