contrib/compiler-rt/lib/builtins/gcc_personality_v0.c

   1 /* ===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------===
   2  *
   3  *                     The LLVM Compiler Infrastructure
   4  *
   5  * This file is dual licensed under the MIT and the University of Illinois Open
   6  * Source Licenses. See LICENSE.TXT for details.
   7  *
   8  * ===----------------------------------------------------------------------===
   9  *
  10  */
  11
  12 #include "int_lib.h"
  13
  14 #include <unwind.h>
  15
  16 /*
  17  * Pointer encodings documented at:
  18  *   http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html
  19  */
  20
  21 #define DW_EH_PE_omit      0xff  /* no data follows */
  22
  23 #define DW_EH_PE_absptr    0x00
  24 #define DW_EH_PE_uleb128   0x01
  25 #define DW_EH_PE_udata2    0x02
  26 #define DW_EH_PE_udata4    0x03
  27 #define DW_EH_PE_udata8    0x04
  28 #define DW_EH_PE_sleb128   0x09
  29 #define DW_EH_PE_sdata2    0x0A
  30 #define DW_EH_PE_sdata4    0x0B
  31 #define DW_EH_PE_sdata8    0x0C
  32
  33 #define DW_EH_PE_pcrel     0x10
  34 #define DW_EH_PE_textrel   0x20
  35 #define DW_EH_PE_datarel   0x30
  36 #define DW_EH_PE_funcrel   0x40
  37 #define DW_EH_PE_aligned   0x50
  38 #define DW_EH_PE_indirect  0x80 /* gcc extension */
  39
  40
  41
  42 /* read a uleb128 encoded value and advance pointer */
  43 static uintptr_t readULEB128(const uint8_t** data)
  44 {
  45     uintptr_t result = 0;
  46     uintptr_t shift = 0;
  47     unsigned char byte;
  48     const uint8_t* p = *data;
  49     do {
  50         byte = *p++;
  51         result |= (byte & 0x7f) << shift;
  52         shift += 7;
  53     } while (byte & 0x80);
  54     *data = p;
  55     return result;
  56 }
  57
  58 /* read a pointer encoded value and advance pointer */
  59 static uintptr_t readEncodedPointer(const uint8_t** data, uint8_t encoding)
  60 {
  61     const uint8_t* p = *data;
  62     uintptr_t result = 0;
  63
  64     if ( encoding == DW_EH_PE_omit )
  65         return 0;
  66
  67     /* first get value */
  68     switch (encoding & 0x0F) {
  69         case DW_EH_PE_absptr:
  70             result = *((const uintptr_t*)p);
  71             p += sizeof(uintptr_t);
  72             break;
  73         case DW_EH_PE_uleb128:
  74             result = readULEB128(&p);
  75             break;
  76         case DW_EH_PE_udata2:
  77             result = *((const uint16_t*)p);
  78             p += sizeof(uint16_t);
  79             break;
  80         case DW_EH_PE_udata4:
  81             result = *((const uint32_t*)p);
  82             p += sizeof(uint32_t);
  83             break;
  84         case DW_EH_PE_udata8:
  85             result = *((const uint64_t*)p);
  86             p += sizeof(uint64_t);
  87             break;
  88         case DW_EH_PE_sdata2:
  89             result = *((const int16_t*)p);
  90             p += sizeof(int16_t);
  91             break;
  92         case DW_EH_PE_sdata4:
  93             result = *((const int32_t*)p);
  94             p += sizeof(int32_t);
  95             break;
  96         case DW_EH_PE_sdata8:
  97             result = *((const int64_t*)p);
  98             p += sizeof(int64_t);
  99             break;
 100         case DW_EH_PE_sleb128:
 101         default:
 102             /* not supported */
 103             compilerrt_abort();
 104             break;
 105     }
 106
 107     /* then add relative offset */
 108     switch ( encoding & 0x70 ) {
 109         case DW_EH_PE_absptr:
 110             /* do nothing */
 111             break;
 112         case DW_EH_PE_pcrel:
 113             result += (uintptr_t)(*data);
 114             break;
 115         case DW_EH_PE_textrel:
 116         case DW_EH_PE_datarel:
 117         case DW_EH_PE_funcrel:
 118         case DW_EH_PE_aligned:
 119         default:
 120             /* not supported */
 121             compilerrt_abort();
 122             break;
 123     }
 124
 125     /* then apply indirection */
 126     if (encoding & DW_EH_PE_indirect) {
 127         result = *((const uintptr_t*)result);
 128     }
 129
 130     *data = p;
 131     return result;
 132 }
 133
 134 #if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) &&                 \
 135     !defined(__ARM_DWARF_EH__)
 136 #define USING_ARM_EHABI 1
 137 _Unwind_Reason_Code __gnu_unwind_frame(struct _Unwind_Exception *,
 138                                        struct _Unwind_Context *);
 139 #endif
 140
 141 static inline _Unwind_Reason_Code
 142 continueUnwind(struct _Unwind_Exception *exceptionObject,
 143                struct _Unwind_Context *context) {
 144 #if USING_ARM_EHABI
 145     /*
 146      * On ARM EHABI the personality routine is responsible for actually
 147      * unwinding a single stack frame before returning (ARM EHABI Sec. 6.1).
 148      */
 149     if (__gnu_unwind_frame(exceptionObject, context) != _URC_OK)
 150         return _URC_FAILURE;
 151 #endif
 152     return _URC_CONTINUE_UNWIND;
 153 }
 154
 155 /*
 156  * The C compiler makes references to __gcc_personality_v0 in
 157  * the dwarf unwind information for translation units that use
 158  * __attribute__((cleanup(xx))) on local variables.
 159  * This personality routine is called by the system unwinder
 160  * on each frame as the stack is unwound during a C++ exception
 161  * throw through a C function compiled with -fexceptions.
 162  */
 163 #if __USING_SJLJ_EXCEPTIONS__
 164 /* the setjump-longjump based exceptions personality routine has a
 165  * different name */
 166 COMPILER_RT_ABI _Unwind_Reason_Code
 167 __gcc_personality_sj0(int version, _Unwind_Action actions,
 168          uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject,
 169          struct _Unwind_Context *context)
 170 #elif USING_ARM_EHABI
 171 /* The ARM EHABI personality routine has a different signature. */
 172 COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
 173          _Unwind_State state, struct _Unwind_Exception *exceptionObject,
 174          struct _Unwind_Context *context)
 175 #else
 176 COMPILER_RT_ABI _Unwind_Reason_Code
 177 __gcc_personality_v0(int version, _Unwind_Action actions,
 178          uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject,
 179          struct _Unwind_Context *context)
 180 #endif
 181 {
 182     /* Since C does not have catch clauses, there is nothing to do during */
 183     /* phase 1 (the search phase). */
 184 #if USING_ARM_EHABI
 185     /* After resuming from a cleanup we should also continue on to the next
 186      * frame straight away. */
 187     if ((state & _US_ACTION_MASK) != _US_UNWIND_FRAME_STARTING)
 188 #else
 189     if ( actions & _UA_SEARCH_PHASE )
 190 #endif
 191         return continueUnwind(exceptionObject, context);
 192
 193     /* There is nothing to do if there is no LSDA for this frame. */
 194     const uint8_t* lsda = (uint8_t*)_Unwind_GetLanguageSpecificData(context);
 195     if ( lsda == (uint8_t*) 0 )
 196         return continueUnwind(exceptionObject, context);
 197
 198     uintptr_t pc = _Unwind_GetIP(context)-1;
 199     uintptr_t funcStart = _Unwind_GetRegionStart(context);
 200     uintptr_t pcOffset = pc - funcStart;
 201
 202     /* Parse LSDA header. */
 203     uint8_t lpStartEncoding = *lsda++;
 204     if (lpStartEncoding != DW_EH_PE_omit) {
 205         readEncodedPointer(&lsda, lpStartEncoding);
 206     }
 207     uint8_t ttypeEncoding = *lsda++;
 208     if (ttypeEncoding != DW_EH_PE_omit) {
 209         readULEB128(&lsda);
 210     }
 211     /* Walk call-site table looking for range that includes current PC. */
 212     uint8_t         callSiteEncoding = *lsda++;
 213     uint32_t        callSiteTableLength = readULEB128(&lsda);
 214     const uint8_t*  callSiteTableStart = lsda;
 215     const uint8_t*  callSiteTableEnd = callSiteTableStart + callSiteTableLength;
 216     const uint8_t* p=callSiteTableStart;
 217     while (p < callSiteTableEnd) {
 218         uintptr_t start = readEncodedPointer(&p, callSiteEncoding);
 219         uintptr_t length = readEncodedPointer(&p, callSiteEncoding);
 220         uintptr_t landingPad = readEncodedPointer(&p, callSiteEncoding);
 221         readULEB128(&p); /* action value not used for C code */
 222         if ( landingPad == 0 )
 223             continue; /* no landing pad for this entry */
 224         if ( (start <= pcOffset) && (pcOffset < (start+length)) ) {
 225             /* Found landing pad for the PC.
 226              * Set Instruction Pointer to so we re-enter function
 227              * at landing pad. The landing pad is created by the compiler
 228              * to take two parameters in registers.
 229              */
 230             _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
 231                           (uintptr_t)exceptionObject);
 232             _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0);
 233             _Unwind_SetIP(context, (funcStart + landingPad));
 234             return _URC_INSTALL_CONTEXT;
 235         }
 236     }
 237
 238     /* No landing pad found, continue unwinding. */
 239     return continueUnwind(exceptionObject, context);
 240 }
 241