Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libcompiler_rt/gcc_personality_v0.c	Lines:	0	78	0.0 %
Date:	2017-11-07	Branches:	0	37	0.0 %


/* ===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------===
 *
 *      	       The LLVM Compiler Infrastructure
 *
 * This file is dual licensed under the MIT and the University of Illinois Open
 * Source Licenses. See LICENSE.TXT for details.
 *
 * ===----------------------------------------------------------------------===
 *
 */

#include "int_lib.h"

#include <unwind.h>
#if defined(__arm__) && !defined(__ARM_DWARF_EH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
/*
 * When building with older compilers (e.g. clang <3.9), it is possible that we
 * have a version of unwind.h which does not provide the EHABI declarations
 * which are quired for the C personality to conform to the specification.  In
 * order to provide forward compatibility for such compilers, we re-declare the
 * necessary interfaces in the helper to permit a standalone compilation of the
 * builtins (which contains the C unwinding personality for historical reasons).
 */
#include "unwind-ehabi-helpers.h"
#endif

/*
 * Pointer encodings documented at:
 *   http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html
 */

#define DW_EH_PE_omit      0xff  /* no data follows */

#define DW_EH_PE_absptr    0x00
#define DW_EH_PE_uleb128   0x01
#define DW_EH_PE_udata2    0x02
#define DW_EH_PE_udata4    0x03
#define DW_EH_PE_udata8    0x04
#define DW_EH_PE_sleb128   0x09
#define DW_EH_PE_sdata2    0x0A
#define DW_EH_PE_sdata4    0x0B
#define DW_EH_PE_sdata8    0x0C

#define DW_EH_PE_pcrel     0x10
#define DW_EH_PE_textrel   0x20
#define DW_EH_PE_datarel   0x30
#define DW_EH_PE_funcrel   0x40
#define DW_EH_PE_aligned   0x50
#define DW_EH_PE_indirect  0x80 /* gcc extension */



/* read a uleb128 encoded value and advance pointer */
static uintptr_t readULEB128(const uint8_t** data)
{
    uintptr_t result = 0;
    uintptr_t shift = 0;
    unsigned char byte;
    const uint8_t* p = *data;
    do {
        byte = *p++;
        result |= (byte & 0x7f) << shift;
        shift += 7;
    } while (byte & 0x80);
    *data = p;
    return result;
}

/* read a pointer encoded value and advance pointer */
static uintptr_t readEncodedPointer(const uint8_t** data, uint8_t encoding)
{
    const uint8_t* p = *data;
    uintptr_t result = 0;

    if ( encoding == DW_EH_PE_omit )
        return 0;

    /* first get value */
    switch (encoding & 0x0F) {
        case DW_EH_PE_absptr:
            result = *((const uintptr_t*)p);
            p += sizeof(uintptr_t);
            break;
        case DW_EH_PE_uleb128:
            result = readULEB128(&p);
            break;
        case DW_EH_PE_udata2:
            result = *((const uint16_t*)p);
            p += sizeof(uint16_t);
            break;
        case DW_EH_PE_udata4:
            result = *((const uint32_t*)p);
            p += sizeof(uint32_t);
            break;
        case DW_EH_PE_udata8:
            result = *((const uint64_t*)p);
            p += sizeof(uint64_t);
            break;
        case DW_EH_PE_sdata2:
            result = *((const int16_t*)p);
            p += sizeof(int16_t);
            break;
        case DW_EH_PE_sdata4:
            result = *((const int32_t*)p);
            p += sizeof(int32_t);
            break;
        case DW_EH_PE_sdata8:
            result = *((const int64_t*)p);
            p += sizeof(int64_t);
            break;
        case DW_EH_PE_sleb128:
        default:
            /* not supported */
            compilerrt_abort();
            break;
    }

    /* then add relative offset */
    switch ( encoding & 0x70 ) {
        case DW_EH_PE_absptr:
            /* do nothing */
            break;
        case DW_EH_PE_pcrel:
            result += (uintptr_t)(*data);
            break;
        case DW_EH_PE_textrel:
        case DW_EH_PE_datarel:
        case DW_EH_PE_funcrel:
        case DW_EH_PE_aligned:
        default:
            /* not supported */
            compilerrt_abort();
            break;
    }

    /* then apply indirection */
    if (encoding & DW_EH_PE_indirect) {
        result = *((const uintptr_t*)result);
    }

    *data = p;
    return result;
}

#if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) &&                 \
    !defined(__ARM_DWARF_EH__)
#define USING_ARM_EHABI 1
_Unwind_Reason_Code __gnu_unwind_frame(struct _Unwind_Exception *,
                                       struct _Unwind_Context *);
#endif

static inline _Unwind_Reason_Code
continueUnwind(struct _Unwind_Exception *exceptionObject,
               struct _Unwind_Context *context) {
#if USING_ARM_EHABI
    /*
     * On ARM EHABI the personality routine is responsible for actually
     * unwinding a single stack frame before returning (ARM EHABI Sec. 6.1).
     */
    if (__gnu_unwind_frame(exceptionObject, context) != _URC_OK)
        return _URC_FAILURE;
#endif
    return _URC_CONTINUE_UNWIND;
}

/*
 * The C compiler makes references to __gcc_personality_v0 in
 * the dwarf unwind information for translation units that use
 * __attribute__((cleanup(xx))) on local variables.
 * This personality routine is called by the system unwinder
 * on each frame as the stack is unwound during a C++ exception
 * throw through a C function compiled with -fexceptions.
 */
#if __USING_SJLJ_EXCEPTIONS__
/* the setjump-longjump based exceptions personality routine has a
 * different name */
COMPILER_RT_ABI _Unwind_Reason_Code
__gcc_personality_sj0(int version, _Unwind_Action actions,
         uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject,
         struct _Unwind_Context *context)
#elif USING_ARM_EHABI
/* The ARM EHABI personality routine has a different signature. */
COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
         _Unwind_State state, struct _Unwind_Exception *exceptionObject,
         struct _Unwind_Context *context)
#else
COMPILER_RT_ABI _Unwind_Reason_Code
__gcc_personality_v0(int version, _Unwind_Action actions,
         uint64_t exceptionClass, struct _Unwind_Exception* exceptionObject,
         struct _Unwind_Context *context)
#endif
{
    /* Since C does not have catch clauses, there is nothing to do during */
    /* phase 1 (the search phase). */
#if USING_ARM_EHABI
    /* After resuming from a cleanup we should also continue on to the next
     * frame straight away. */
    if ((state & _US_ACTION_MASK) != _US_UNWIND_FRAME_STARTING)
#else
    if ( actions & _UA_SEARCH_PHASE )
#endif
        return continueUnwind(exceptionObject, context);

    /* There is nothing to do if there is no LSDA for this frame. */
    const uint8_t* lsda = (uint8_t*)_Unwind_GetLanguageSpecificData(context);
    if ( lsda == (uint8_t*) 0 )
        return continueUnwind(exceptionObject, context);

    uintptr_t pc = _Unwind_GetIP(context)-1;
    uintptr_t funcStart = _Unwind_GetRegionStart(context);
    uintptr_t pcOffset = pc - funcStart;

    /* Parse LSDA header. */
    uint8_t lpStartEncoding = *lsda++;
    if (lpStartEncoding != DW_EH_PE_omit) {
        readEncodedPointer(&lsda, lpStartEncoding);
    }
    uint8_t ttypeEncoding = *lsda++;
    if (ttypeEncoding != DW_EH_PE_omit) {
        readULEB128(&lsda);
    }
    /* Walk call-site table looking for range that includes current PC. */
    uint8_t         callSiteEncoding = *lsda++;
    uint32_t        callSiteTableLength = readULEB128(&lsda);
    const uint8_t*  callSiteTableStart = lsda;
    const uint8_t*  callSiteTableEnd = callSiteTableStart + callSiteTableLength;
    const uint8_t* p=callSiteTableStart;
    while (p < callSiteTableEnd) {
        uintptr_t start = readEncodedPointer(&p, callSiteEncoding);
        uintptr_t length = readEncodedPointer(&p, callSiteEncoding);
        uintptr_t landingPad = readEncodedPointer(&p, callSiteEncoding);
        readULEB128(&p); /* action value not used for C code */
        if ( landingPad == 0 )
            continue; /* no landing pad for this entry */
        if ( (start <= pcOffset) && (pcOffset < (start+length)) ) {
            /* Found landing pad for the PC.
             * Set Instruction Pointer to so we re-enter function
             * at landing pad. The landing pad is created by the compiler
             * to take two parameters in registers.
             */
            _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
                          (uintptr_t)exceptionObject);
            _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0);
            _Unwind_SetIP(context, (funcStart + landingPad));
            return _URC_INSTALL_CONTEXT;
        }
    }

    /* No landing pad found, continue unwinding. */
    return continueUnwind(exceptionObject, context);
}



Generated by: GCOVR (Version 3.3)

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