/* unwind_env.h
 *
 * Copyright 2003-2005 ARM Limited. All rights reserved.
 *
 * Your rights to use this code are set out in the accompanying licence
 * text file LICENCE.txt (ARM contract number LEC-ELA-00080 v2.0).
 */
/*
 * RCS $Revision: 1.2 $
 * Checkin $Date: 2010/07/19 19:16:40 $
 * Revising $Author: rtcw50 $
 */

/* Environment definition - abstractions and requirements - to aid
 * portability of the ARM exceptions code.
 */
#if ARM_EABI_EXC_HANDLING

#ifndef UNWINDENV_H
#define UNWINDENV_H

/* ---------------------------------------------------------------------- */

/* Source language
 *
 * The compiler is expected to define preprocessor symbols as follows:
 * __cplusplus when compiling in C++ mode.
 * __thumb when compiling to Thumb code.
 *
 * Some use is made of embedded assembly language, introduced by __asm.
 * This is described in ARM's toolchain documentation. Some edits may be
 * required for other compilers. The compiler should define one or more of:
 * __TARGET_ARCH_4T __TARGET_ARCH_4TXM __TARGET_ARCH_5T __TARGET_ARCH_5TXM
 * __TARGET_ARCH_5TE __TARGET_ARCH_6
 * so the correct assembly wrappers are generated for certain functions.
 *
 * __APCS_INTERWORK should be defined if ARM/Thumb interworking is required.
 *
 * For all the above symbols, if your compiler does not provide appropriate
 * definitions, add them here.
 *
 * Some source language extensions are also used.
 */

/* ---------------------------------------------------------------------- */

/* Library structure
 *
 * ARM's private make system contains an automated facility for compiling
 * source files multiple times to create multiple object files. The source
 * regions intended to constitute object file xxx.o are delimited by
 * #ifdef xxx_c / #endif directives. The exact preprocessor symbols used
 * for this conditionalisation are described in a comment at the start of
 * each file. When porting to a different system, compilations must be
 * performed with these preprocessor symbols appropriately defined
 * (or remove the conditionalisation).
 *
 * ARM declares (or redeclares) some routines as weak in order that
 * references to them are weak, so that the static linker will not load
 * unwanted code. This is achieved by decorating routine declarations
 * with appropriate language extensions. Note that compilers supporting
 * similar features but via a different syntax may require edits to
 * the library source.
 *
 * Define those decorations here (define as empty if not required):
 */

#define WEAKDECL __weak        /* token in C and C++ */
#define WEAKASMDECL [WEAK]     /* token in assembler */

/* ---------------------------------------------------------------------- */

/* Source language support and language extensions */

/* It is possible to compile the C++ semantics code using a compiler
 * which does not support C++ exceptions; this was useful to ARM whilst
 * ARM's compiler was being developed, and the facility has not been
 * removed. C++ exceptions syntax is conditionalised by
 * #ifdef ARM_EXCEPTIONS_ENABLED / #endif. Define ARM_EXCEPTIONS_ENABLED
 * by some means here if you want a usable library:
 */

#ifdef __cplusplus
extern "C" {
  /* For conditionalisation, specifically on ARM_EXCEPTIONS_ENABLED */
//#include "basics.h"
}
#endif

/* ---------------------------------------------------------------------- */

/* Types */

/* The implementation requires types uint8_t, uint16_t, uint32_t and
 * uint64_t to be defined as unsigned integers of the appropriate number
 * of bits.
 *
 * Do that here:
 */

#include <stdint.h>

/* The C++ semantics support requires definition of the RTTI object
 * layout. We use the same structures and names as the generic C++
 * ABI for Itanium.
 *
 * Define those structures here:
 */

#ifdef __cplusplus
extern "C" {
#include "cxxabi.h"
}
#endif

/* ---------------------------------------------------------------------- */

/* External requirements */

/* The C++ exception-handling 'globals' should be allocated per-thread.
 * The Exceptions ABI does not specify how this happens, but it is
 * intended that the details are localised to __cxa_get_globals.
 *
 * In the ARM implementation of __cxa_get_globals, it is assumed that a
 * zero-initialised location in a known per-thread place is somehow
 * obtainable, and can be assigned (by __cxa_get_globals) a pointer to
 * the allocated globals data structure. The macro EH_GLOBALS should be
 * defined here to yield a suitable address of type void*. This is used
 * only in __cxa_get_globals.
 *
 * Define it here:
 */

#ifdef __cplusplus
extern "C" {
  /* for __user_perproc_libspace() machinery */
//#include <interns.h>
#define EH_GLOBALS plibspace.eh_globals
}
#endif


/* A routine is required for C++ derived class to base class conversion.
 * This is used once, in __cxa_type_match. It is likely that suitable
 * code exists as part of the RTTI support code. Therefore access it
 * via a macro:
 * DERIVED_TO_BASE_CONVERSION(PTR, P_NEW_PTR, CLASS_INFO, BASE_INFO)
 *   Convert PTR from a pointer to a derived class (described by
 *   CLASS_INFO) to a pointer to a base class (described by BASE_INFO)
 *   and store the resulting pointer in P_NEW_PTR. Return true (or
 *   non-zero) if the base class was found and the conversion was done,
 *   otherwise return false (or zero).
 *
 * Define the macro here:
 */

#ifdef __cplusplus
/* In the ARM implementation, a suitable routine exists elsewhere in the
 * C++ runtime library, where it is part of the dynamic_cast mechanism.
 */
#ifdef __CWCC__
extern "C" int __derived_to_base_conversion(
	void*					obj_ptr,
	void**					base_ptr_result,
	const std::type_info*	obj_info,
	const std::type_info*	base_info
);
#define DERIVED_TO_BASE_CONVERSION(PTR, P_NEW_PTR, CLASS_INFO, BASE_INFO) \
  __derived_to_base_conversion((PTR), (P_NEW_PTR), (CLASS_INFO), (BASE_INFO))

#else
extern "C" int __derived_to_base_conversion(void** p_ptr, void** p_new_ptr,
                                            const std::type_info * class_info,
                                            const std::type_info * base_info,
                                            char** access_flags, int use_access_flags);

#define DERIVED_TO_BASE_CONVERSION(PTR, P_NEW_PTR, CLASS_INFO, BASE_INFO) \
  __derived_to_base_conversion(&(PTR), (P_NEW_PTR), (CLASS_INFO), (BASE_INFO), NULL, 0)
#endif
#endif


/* The effect of R_ARM_TARGET2 relocations is platform-specific. A
 * routine is required for handling references created via such
 * relocations.  The routine takes the address of a location that was
 * relocated by R_ARM_TARGET2, and returns a pointer to the absolute
 * address of the referenced entity.
 */

static void *__ARM_resolve_target2(void *p)
{
#ifdef __APCS_FPIC
  /* SVr4: R_ARM_TARGET2 is equivalent to R_ARM_GOT_PREL (placerel32 indirect) */
  return *(void **)(*(uint32_t *)p + (uint32_t)p);
#else
  /* Bare metal: R_ARM_TARGET2 is equivalent to R_ARM_ABS32 */
  return *(void **)p;
#endif
}

/* ---------------------------------------------------------------------- */

/* Runtime debug support
 *
 * Here we define the interface to a "bottleneck function" to be called
 * by exception handling code at 'interesting' points during execution,
 * and breakpointable by a debugger.
 *
 * This is not part of the Exceptions ABI but is expected to be
 * standardised elsewhere, probably in a Debug ABI.
 *
 * If you don't want this, define DEBUGGER_BOTTLENECK as a dummy, e.g.
 * #define DEBUGGER_BOTTLENECK(UCBP,LANG,ACTIVITY,ARG) (void)0
 */

#ifdef __cplusplus
extern "C" {
#endif

  struct _Unwind_Control_Block;

  typedef enum {
    _UASUBSYS_CPP      = 0x00,
    _UASUBSYS_UNWINDER = 0xff
  } _Unwind_Activity_subsystem;

  typedef enum {
    _UAACT_STARTING     = 0x0,
    _UAACT_ENDING       = 0x1,
    _UAACT_BARRIERFOUND = 0x2,
    _UAACT_PADENTRY     = 0x3,
    _UAACT_CPP_TYPEINFO = 0x80
  } _Unwind_Activity_activity;

  typedef enum {
    _UAARG_ENDING_UNSPECIFIED           = 0x0,
    _UAARG_ENDING_TABLECORRUPT          = 0x1,
    _UAARG_ENDING_NOUNWIND              = 0x2,
    _UAARG_ENDING_VRSFAILED             = 0x3,
    /* C++ only: */
    _UAARG_ENDING_CPP_BADOPCODE         = 0x4,
    /* Unwinder only: */
    _UAARG_ENDING_UNWINDER_LOOKUPFAILED = 0x4,
    _UAARG_ENDING_UNWINDER_BUFFERFAILED = 0x5
  } _Unwind_Activity_arg;

  void _Unwind_Activity(struct _Unwind_Control_Block *ucbp, uint32_t reason, uint32_t arg);
#define DEBUGGER_BOTTLENECK(UCBP,LANG,ACTIVITY,ARG) \
  _Unwind_Activity((UCBP),(((LANG)<<24)|ACTIVITY),(uint32_t)(ARG))

#ifdef __cplusplus
}
#endif


/* ---------------------------------------------------------------------- */

/* Printed diagnostics
 *
 * These may be useful for debugging purposes during development, provided
 * the execution environment supports diagnostics via printf.
 *
 * #define PR_DIAGNOSTICS for printed diagnostics from the personality routine.
 * #define VRS_DIAGNOSTICS for printed diagnostics about VRS operations.
 * #define UNWIND_ACTIVITY_DIAGNOSTICS for printed information from _Unwind_Activity.
 * #define CPP_DIAGNOSTICS for printed diagnostics from the C++ semantics routines.
 */
/* ---------------------------------------------------------------------- */

#endif /* defined UNWINDENV_H */
#endif //ARM_EABI_EXC_HANDLING
