ExceptionDemo.cpp

//===-- ExceptionDemo.cpp - An example using llvm Exceptions --------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Demo program which implements an example LLVM exception implementation, and
// shows several test cases including the handling of foreign exceptions.
// It is run with type info types arguments to throw. A test will
// be run for each given type info type. While type info types with the value
// of -1 will trigger a foreign C++ exception to be thrown; type info types
// <= 6 and >= 1 will cause the associated generated exceptions to be thrown
// and caught by generated test functions; and type info types > 6
// will result in exceptions which pass through to the test harness. All other
// type info types are not supported and could cause a crash. In all cases,
// the "finally" blocks of every generated test functions will executed
// regardless of whether or not that test function ignores or catches the
// thrown exception.
//
// examples:
//
// ExceptionDemo
//
// causes a usage to be printed to stderr
//
// ExceptionDemo 2 3 7 -1
//
// results in the following cases:
// - Value 2 causes an exception with a type info type of 2 to be
// thrown and caught by an inner generated test function.
// - Value 3 causes an exception with a type info type of 3 to be
// thrown and caught by an outer generated test function.
// - Value 7 causes an exception with a type info type of 7 to be
// thrown and NOT be caught by any generated function.
// - Value -1 causes a foreign C++ exception to be thrown and not be
// caught by any generated function
//
// Cases -1 and 7 are caught by a C++ test harness where the validity of
// of a C++ catch(...) clause catching a generated exception with a
// type info type of 7 is explained by: example in rules 1.6.4 in
// http://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html (v1.22)
//
// This code uses code from the llvm compiler-rt project and the llvm
// Kaleidoscope project.
//
//===----------------------------------------------------------------------===//

#include"llvm/ADT/STLExtras.h"
#include"llvm/BinaryFormat/Dwarf.h"
#include"llvm/ExecutionEngine/Orc/Core.h"
#include"llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
#include"llvm/ExecutionEngine/Orc/LLJIT.h"
#include"llvm/IR/DataLayout.h"
#include"llvm/IR/DerivedTypes.h"
#include"llvm/IR/IRBuilder.h"
#include"llvm/IR/Intrinsics.h"
#include"llvm/IR/LLVMContext.h"
#include"llvm/IR/LegacyPassManager.h"
#include"llvm/IR/Module.h"
#include"llvm/IR/Verifier.h"
#include"llvm/Support/TargetSelect.h"
#include"llvm/Target/TargetOptions.h"
#include"llvm/Transforms/Scalar.h"

// FIXME: Although all systems tested with (Linux, OS X), do not need this
// header file included. A user on ubuntu reported, undefined symbols
// for stderr, and fprintf, and the addition of this include fixed the
// issue for them. Given that LLVM's best practices include the goal
// of reducing the number of redundant header files included, the
// correct solution would be to find out why these symbols are not
// defined for the system in question, and fix the issue by finding out
// which LLVM header file, if any, would include these symbols.
#include<cstdio>

#include<sstream>
#include<stdexcept>

#include<inttypes.h>

#include<unwind.h>

#ifndef USE_GLOBAL_STR_CONSTS
#defineUSE_GLOBAL_STR_CONSTStrue
#endif

llvm::ExitOnError ExitOnErr;

//
// Example types
//

/// This is our simplistic type info
structOurExceptionType_t {
/// type info type
int type;
};


/// This is our Exception class which relies on a negative offset to calculate
/// pointers to its instances from pointers to its unwindException member.
///
/// Note: The above unwind.h defines struct _Unwind_Exception to be aligned
/// on a double word boundary. This is necessary to match the standard:
/// http://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
structOurBaseException_t {
structOurExceptionType_t type;

// Note: This is properly aligned in unwind.h
struct_Unwind_Exception unwindException;
};


// Note: Not needed since we are C++
typedefstructOurBaseException_t OurException;
typedefstruct_Unwind_Exception OurUnwindException;

//
// Various globals used to support typeinfo and generatted exceptions in
// general
//

static std::map<std::string, llvm::Value*> namedValues;

int64_t ourBaseFromUnwindOffset;

constunsignedchar ourBaseExcpClassChars[] =
{'o', 'b', 'j', '\0', 'b', 'a', 's', '\0'};


staticuint64_t ourBaseExceptionClass = 0;

static std::vector<std::string> ourTypeInfoNames;
static std::map<int, std::string> ourTypeInfoNamesIndex;

static llvm::StructType *ourTypeInfoType;
static llvm::StructType *ourCaughtResultType;
static llvm::StructType *ourExceptionType;
static llvm::StructType *ourUnwindExceptionType;

static llvm::ConstantInt *ourExceptionNotThrownState;
static llvm::ConstantInt *ourExceptionThrownState;
static llvm::ConstantInt *ourExceptionCaughtState;

typedef std::vector<std::string> ArgNames;
typedef std::vector<llvm::Type*> ArgTypes;
typedef llvm::ArrayRef<llvm::Type *> TypeArray;

//
// Code Generation Utilities
//

/// Utility used to create a function, both declarations and definitions
/// @param module for module instance
/// @param retType function return type
/// @param theArgTypes function's ordered argument types
/// @param theArgNames function's ordered arguments needed if use of this
/// function corresponds to a function definition. Use empty
/// aggregate for function declarations.
/// @param functName function name
/// @param linkage function linkage
/// @param declarationOnly for function declarations
/// @param isVarArg function uses vararg arguments
/// @returns function instance
llvm::Function *createFunction(llvm::Module &module,
 llvm::Type *retType,
const ArgTypes &theArgTypes,
const ArgNames &theArgNames,
const std::string &functName,
 llvm::GlobalValue::LinkageTypes linkage,
bool declarationOnly,
bool isVarArg) {
 llvm::FunctionType *functType =
llvm::FunctionType::get(retType, theArgTypes, isVarArg);
 llvm::Function *ret =
llvm::Function::Create(functType, linkage, functName, &module);
if (!ret || declarationOnly)
return(ret);

 namedValues.clear();
unsigned i = 0;
for (llvm::Function::arg_iterator argIndex = ret->arg_begin();
 i != theArgNames.size();
 ++argIndex, ++i) {

 argIndex->setName(theArgNames[i]);
 namedValues[theArgNames[i]] = argIndex;
 }

return(ret);
}


/// Create an alloca instruction in the entry block of
/// the parent function. This is used for mutable variables etc.
/// @param function parent instance
/// @param varName stack variable name
/// @param type stack variable type
/// @param initWith optional constant initialization value
/// @returns AllocaInst instance
static llvm::AllocaInst *createEntryBlockAlloca(llvm::Function &function,
const std::string &varName,
 llvm::Type *type,
 llvm::Constant *initWith = 0) {
 llvm::BasicBlock &block = function.getEntryBlock();
 llvm::IRBuilder<> tmp(&block, block.begin());
 llvm::AllocaInst *ret = tmp.CreateAlloca(type, 0, varName);

if (initWith)
 tmp.CreateStore(initWith, ret);

return(ret);
}


//
// Code Generation Utilities End
//

//
// Runtime C Library functions
//

namespace {
template <typename Type_>
uintptr_tReadType(constuint8_t *&p) {
 Type_ value;
memcpy(&value, p, sizeof(Type_));
 p += sizeof(Type_);
returnstatic_cast<uintptr_t>(value);
}
}

// Note: using an extern "C" block so that static functions can be used
extern"C" {

// Note: Better ways to decide on bit width
//
/// Prints a 32 bit number, according to the format, to stderr.
/// @param intToPrint integer to print
/// @param format printf like format to use when printing
voidprint32Int(int intToPrint, constchar *format) {
if (format) {
// Note: No NULL check
fprintf(stderr, format, intToPrint);
 }
else {
// Note: No NULL check
fprintf(stderr, "::print32Int(...):NULL arg.\n");
 }
}


// Note: Better ways to decide on bit width
//
/// Prints a 64 bit number, according to the format, to stderr.
/// @param intToPrint integer to print
/// @param format printf like format to use when printing
voidprint64Int(longint intToPrint, constchar *format) {
if (format) {
// Note: No NULL check
fprintf(stderr, format, intToPrint);
 }
else {
// Note: No NULL check
fprintf(stderr, "::print64Int(...):NULL arg.\n");
 }
}


/// Prints a C string to stderr
/// @param toPrint string to print
voidprintStr(char *toPrint) {
if (toPrint) {
fprintf(stderr, "%s", toPrint);
 }
else {
fprintf(stderr, "::printStr(...):NULL arg.\n");
 }
}


/// Deletes the true previously allocated exception whose address
/// is calculated from the supplied OurBaseException_t::unwindException
/// member address. Handles (ignores), NULL pointers.
/// @param expToDelete exception to delete
voiddeleteOurException(OurUnwindException *expToDelete) {
#ifdef DEBUG
fprintf(stderr,
"deleteOurException(...).\n");
#endif

if (expToDelete &&
 (expToDelete->exception_class == ourBaseExceptionClass)) {

free(((char*) expToDelete) + ourBaseFromUnwindOffset);
 }
}


/// This function is the struct _Unwind_Exception API mandated delete function
/// used by foreign exception handlers when deleting our exception
/// (OurException), instances.
/// @param reason See @link http://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
/// @unlink
/// @param expToDelete exception instance to delete
voiddeleteFromUnwindOurException(_Unwind_Reason_Code reason,
 OurUnwindException *expToDelete) {
#ifdef DEBUG
fprintf(stderr,
"deleteFromUnwindOurException(...).\n");
#endif

deleteOurException(expToDelete);
}


/// Creates (allocates on the heap), an exception (OurException instance),
/// of the supplied type info type.
/// @param type type info type
OurUnwindException *createOurException(int type) {
size_t size = sizeof(OurException);
 OurException *ret = (OurException*) memset(malloc(size), 0, size);
 (ret->type).type = type;
 (ret->unwindException).exception_class = ourBaseExceptionClass;
 (ret->unwindException).exception_cleanup = deleteFromUnwindOurException;

return(&(ret->unwindException));
}


/// Read a uleb128 encoded value and advance pointer
/// See Variable Length Data in:
/// @link http://dwarfstd.org/Dwarf3.pdf @unlink
/// @param data reference variable holding memory pointer to decode from
/// @returns decoded value
staticuintptr_treadULEB128(constuint8_t **data) {
uintptr_t result = 0;
uintptr_t shift = 0;
unsignedchar byte;
constuint8_t *p = *data;

do {
 byte = *p++;
 result |= (byte & 0x7f) << shift;
 shift += 7;
 }
while (byte & 0x80);

 *data = p;

return result;
}


/// Read a sleb128 encoded value and advance pointer
/// See Variable Length Data in:
/// @link http://dwarfstd.org/Dwarf3.pdf @unlink
/// @param data reference variable holding memory pointer to decode from
/// @returns decoded value
staticuintptr_treadSLEB128(constuint8_t **data) {
uintptr_t result = 0;
uintptr_t shift = 0;
unsignedchar byte;
constuint8_t *p = *data;

do {
 byte = *p++;
 result |= (byte & 0x7f) << shift;
 shift += 7;
 }
while (byte & 0x80);

 *data = p;

if ((byte & 0x40) && (shift < (sizeof(result) << 3))) {
 result |= (~0 << shift);
 }

return result;
}

unsignedgetEncodingSize(uint8_t Encoding) {
if (Encoding == llvm::dwarf::DW_EH_PE_omit)
return0;

switch (Encoding & 0x0F) {
case llvm::dwarf::DW_EH_PE_absptr:
returnsizeof(uintptr_t);
case llvm::dwarf::DW_EH_PE_udata2:
returnsizeof(uint16_t);
case llvm::dwarf::DW_EH_PE_udata4:
returnsizeof(uint32_t);
case llvm::dwarf::DW_EH_PE_udata8:
returnsizeof(uint64_t);
case llvm::dwarf::DW_EH_PE_sdata2:
returnsizeof(int16_t);
case llvm::dwarf::DW_EH_PE_sdata4:
returnsizeof(int32_t);
case llvm::dwarf::DW_EH_PE_sdata8:
returnsizeof(int64_t);
default:
// not supported
abort();
 }
}

/// Read a pointer encoded value and advance pointer
/// See Variable Length Data in:
/// @link http://dwarfstd.org/Dwarf3.pdf @unlink
/// @param data reference variable holding memory pointer to decode from
/// @param encoding dwarf encoding type
/// @returns decoded value
staticuintptr_treadEncodedPointer(constuint8_t **data, uint8_t encoding) {
uintptr_t result = 0;
constuint8_t *p = *data;

if (encoding == llvm::dwarf::DW_EH_PE_omit)
return(result);

// first get value
switch (encoding & 0x0F) {
case llvm::dwarf::DW_EH_PE_absptr:
 result = ReadType<uintptr_t>(p);
break;
case llvm::dwarf::DW_EH_PE_uleb128:
 result = readULEB128(&p);
break;
// Note: This case has not been tested
case llvm::dwarf::DW_EH_PE_sleb128:
 result = readSLEB128(&p);
break;
case llvm::dwarf::DW_EH_PE_udata2:
 result = ReadType<uint16_t>(p);
break;
case llvm::dwarf::DW_EH_PE_udata4:
 result = ReadType<uint32_t>(p);
break;
case llvm::dwarf::DW_EH_PE_udata8:
 result = ReadType<uint64_t>(p);
break;
case llvm::dwarf::DW_EH_PE_sdata2:
 result = ReadType<int16_t>(p);
break;
case llvm::dwarf::DW_EH_PE_sdata4:
 result = ReadType<int32_t>(p);
break;
case llvm::dwarf::DW_EH_PE_sdata8:
 result = ReadType<int64_t>(p);
break;
default:
// not supported
abort();
break;
 }

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

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

 *data = p;

return result;
}


/// Deals with Dwarf actions matching our type infos
/// (OurExceptionType_t instances). Returns whether or not a dwarf emitted
/// action matches the supplied exception type. If such a match succeeds,
/// the resultAction argument will be set with > 0 index value. Only
/// corresponding llvm.eh.selector type info arguments, cleanup arguments
/// are supported. Filters are not supported.
/// See Variable Length Data in:
/// @link http://dwarfstd.org/Dwarf3.pdf @unlink
/// Also see @link http://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html @unlink
/// @param resultAction reference variable which will be set with result
/// @param classInfo our array of type info pointers (to globals)
/// @param actionEntry index into above type info array or 0 (clean up).
/// We do not support filters.
/// @param exceptionClass exception class (_Unwind_Exception::exception_class)
/// of thrown exception.
/// @param exceptionObject thrown _Unwind_Exception instance.
/// @returns whether or not a type info was found. False is returned if only
/// a cleanup was found
staticboolhandleActionValue(int64_t *resultAction,
uint8_t TTypeEncoding,
constuint8_t *ClassInfo,
uintptr_t actionEntry,
uint64_t exceptionClass,
struct_Unwind_Exception *exceptionObject) {
bool ret = false;

if (!resultAction ||
 !exceptionObject ||
 (exceptionClass != ourBaseExceptionClass))
return(ret);

structOurBaseException_t *excp = (structOurBaseException_t*)
 (((char*) exceptionObject) + ourBaseFromUnwindOffset);
structOurExceptionType_t *excpType = &(excp->type);
int type = excpType->type;

#ifdef DEBUG
fprintf(stderr,
"handleActionValue(...): exceptionObject = <%p>, "
"excp = <%p>.\n",
 (void*)exceptionObject,
 (void*)excp);
#endif

constuint8_t *actionPos = (uint8_t*) actionEntry,
 *tempActionPos;
int64_t typeOffset = 0,
 actionOffset;

for (int i = 0; true; ++i) {
// Each emitted dwarf action corresponds to a 2 tuple of
// type info address offset, and action offset to the next
// emitted action.
 typeOffset = readSLEB128(&actionPos);
 tempActionPos = actionPos;
 actionOffset = readSLEB128(&tempActionPos);

#ifdef DEBUG
fprintf(stderr,
"handleActionValue(...):typeOffset: <%" PRIi64 ">, "
"actionOffset: <%" PRIi64 ">.\n",
 typeOffset,
 actionOffset);
#endif
assert((typeOffset >= 0) &&
"handleActionValue(...):filters are not supported.");

// Note: A typeOffset == 0 implies that a cleanup llvm.eh.selector
// argument has been matched.
if (typeOffset > 0) {
#ifdef DEBUG
fprintf(stderr,
"handleActionValue(...):actionValue <%d> found.\n",
 i);
#endif
unsigned EncSize = getEncodingSize(TTypeEncoding);
constuint8_t *EntryP = ClassInfo - typeOffset * EncSize;
uintptr_t P = readEncodedPointer(&EntryP, TTypeEncoding);
structOurExceptionType_t *ThisClassInfo =
reinterpret_cast<structOurExceptionType_t *>(P);
if (ThisClassInfo->type == type) {
 *resultAction = i + 1;
 ret = true;
break;
 }
 }

#ifdef DEBUG
fprintf(stderr,
"handleActionValue(...):actionValue not found.\n");
#endif
if (!actionOffset)
break;

 actionPos += actionOffset;
 }

return(ret);
}


/// Deals with the Language specific data portion of the emitted dwarf code.
/// See @link http://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html @unlink
/// @param version unsupported (ignored), unwind version
/// @param lsda language specific data area
/// @param _Unwind_Action actions minimally supported unwind stage
/// (forced specifically not supported)
/// @param exceptionClass exception class (_Unwind_Exception::exception_class)
/// of thrown exception.
/// @param exceptionObject thrown _Unwind_Exception instance.
/// @param context unwind system context
/// @returns minimally supported unwinding control indicator
static _Unwind_Reason_Code handleLsda(int version, constuint8_t *lsda,
 _Unwind_Action actions,
 _Unwind_Exception_Class exceptionClass,
struct_Unwind_Exception *exceptionObject,
struct_Unwind_Context *context) {
 _Unwind_Reason_Code ret = _URC_CONTINUE_UNWIND;

if (!lsda)
return(ret);

#ifdef DEBUG
fprintf(stderr,
"handleLsda(...):lsda is non-zero.\n");
#endif

// Get the current instruction pointer and offset it before next
// instruction in the current frame which threw the exception.
uintptr_t pc = _Unwind_GetIP(context)-1;

// Get beginning current frame's code (as defined by the
// emitted dwarf code)
uintptr_t funcStart = _Unwind_GetRegionStart(context);
uintptr_t pcOffset = pc - funcStart;
constuint8_t *ClassInfo = NULL;

// Note: See JITDwarfEmitter::EmitExceptionTable(...) for corresponding
// dwarf emission

// Parse LSDA header.
uint8_t lpStartEncoding = *lsda++;

if (lpStartEncoding != llvm::dwarf::DW_EH_PE_omit) {
readEncodedPointer(&lsda, lpStartEncoding);
 }

uint8_t ttypeEncoding = *lsda++;
uintptr_t classInfoOffset;

if (ttypeEncoding != llvm::dwarf::DW_EH_PE_omit) {
// Calculate type info locations in emitted dwarf code which
// were flagged by type info arguments to llvm.eh.selector
// intrinsic
 classInfoOffset = readULEB128(&lsda);
 ClassInfo = lsda + classInfoOffset;
 }

// Walk call-site table looking for range that
// includes current PC.

uint8_t callSiteEncoding = *lsda++;
uint32_t callSiteTableLength = readULEB128(&lsda);
constuint8_t *callSiteTableStart = lsda;
constuint8_t *callSiteTableEnd = callSiteTableStart +
 callSiteTableLength;
constuint8_t *actionTableStart = callSiteTableEnd;
constuint8_t *callSitePtr = callSiteTableStart;

while (callSitePtr < callSiteTableEnd) {
uintptr_t start = readEncodedPointer(&callSitePtr,
 callSiteEncoding);
uintptr_t length = readEncodedPointer(&callSitePtr,
 callSiteEncoding);
uintptr_t landingPad = readEncodedPointer(&callSitePtr,
 callSiteEncoding);

// Note: Action value
uintptr_t actionEntry = readULEB128(&callSitePtr);

if (exceptionClass != ourBaseExceptionClass) {
// We have been notified of a foreign exception being thrown,
// and we therefore need to execute cleanup landing pads
 actionEntry = 0;
 }

if (landingPad == 0) {
#ifdef DEBUG
fprintf(stderr,
"handleLsda(...): No landing pad found.\n");
#endif

continue; // no landing pad for this entry
 }

if (actionEntry) {
 actionEntry += ((uintptr_t) actionTableStart) - 1;
 }
else {
#ifdef DEBUG
fprintf(stderr,
"handleLsda(...):No action table found.\n");
#endif
 }

bool exceptionMatched = false;

if ((start <= pcOffset) && (pcOffset < (start + length))) {
#ifdef DEBUG
fprintf(stderr,
"handleLsda(...): Landing pad found.\n");
#endif
int64_t actionValue = 0;

if (actionEntry) {
 exceptionMatched = handleActionValue(&actionValue,
 ttypeEncoding,
 ClassInfo,
 actionEntry,
 exceptionClass,
 exceptionObject);
 }

if (!(actions & _UA_SEARCH_PHASE)) {
#ifdef DEBUG
fprintf(stderr,
"handleLsda(...): installed landing pad "
"context.\n");
#endif

// 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);

// Note: this virtual register directly corresponds
// to the return of the llvm.eh.selector intrinsic
if (!actionEntry || !exceptionMatched) {
// We indicate cleanup only
_Unwind_SetGR(context,
__builtin_eh_return_data_regno(1),
0);
 }
else {
// Matched type info index of llvm.eh.selector intrinsic
// passed here.
_Unwind_SetGR(context,
__builtin_eh_return_data_regno(1),
 actionValue);
 }

// To execute landing pad set here
_Unwind_SetIP(context, funcStart + landingPad);
 ret = _URC_INSTALL_CONTEXT;
 }
elseif (exceptionMatched) {
#ifdef DEBUG
fprintf(stderr,
"handleLsda(...): setting handler found.\n");
#endif
 ret = _URC_HANDLER_FOUND;
 }
else {
// Note: Only non-clean up handlers are marked as
// found. Otherwise the clean up handlers will be
// re-found and executed during the clean up
// phase.
#ifdef DEBUG
fprintf(stderr,
"handleLsda(...): cleanup handler found.\n");
#endif
 }

break;
 }
 }

return(ret);
}


/// This is the personality function which is embedded (dwarf emitted), in the
/// dwarf unwind info block. Again see: JITDwarfEmitter.cpp.
/// See @link http://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html @unlink
/// @param version unsupported (ignored), unwind version
/// @param _Unwind_Action actions minimally supported unwind stage
/// (forced specifically not supported)
/// @param exceptionClass exception class (_Unwind_Exception::exception_class)
/// of thrown exception.
/// @param exceptionObject thrown _Unwind_Exception instance.
/// @param context unwind system context
/// @returns minimally supported unwinding control indicator
_Unwind_Reason_Code ourPersonality(int version, _Unwind_Action actions,
 _Unwind_Exception_Class exceptionClass,
struct_Unwind_Exception *exceptionObject,
struct_Unwind_Context *context) {
#ifdef DEBUG
fprintf(stderr,
"We are in ourPersonality(...):actions is <%d>.\n",
 actions);

if (actions & _UA_SEARCH_PHASE) {
fprintf(stderr, "ourPersonality(...):In search phase.\n");
 }
else {
fprintf(stderr, "ourPersonality(...):In non-search phase.\n");
 }
#endif

constuint8_t *lsda = (constuint8_t *)_Unwind_GetLanguageSpecificData(context);

#ifdef DEBUG
fprintf(stderr,
"ourPersonality(...):lsda = <%p>.\n",
 (void*)lsda);
#endif

// The real work of the personality function is captured here
return(handleLsda(version,
 lsda,
 actions,
 exceptionClass,
 exceptionObject,
 context));
}


/// Generates our _Unwind_Exception class from a given character array.
/// thereby handling arbitrary lengths (not in standard), and handling
/// embedded \0s.
/// See @link http://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html @unlink
/// @param classChars char array to encode. NULL values not checkedf
/// @param classCharsSize number of chars in classChars. Value is not checked.
/// @returns class value
uint64_tgenClass(constunsignedchar classChars[], size_t classCharsSize)
{
uint64_t ret = classChars[0];

for (unsigned i = 1; i < classCharsSize; ++i) {
 ret <<= 8;
 ret += classChars[i];
 }

return(ret);
}

} // extern "C"

//
// Runtime C Library functions End
//

//
// Code generation functions
//

/// Generates code to print given constant string
/// @param context llvm context
/// @param module code for module instance
/// @param builder builder instance
/// @param toPrint string to print
/// @param useGlobal A value of true (default) indicates a GlobalValue is
/// generated, and is used to hold the constant string. A value of
/// false indicates that the constant string will be stored on the
/// stack.
voidgenerateStringPrint(llvm::LLVMContext &context,
 llvm::Module &module,
 llvm::IRBuilder<> &builder,
 std::string toPrint,
bool useGlobal = true) {
 llvm::Function *printFunct = module.getFunction("printStr");

 llvm::Value *stringVar;
 llvm::Constant *stringConstant =
llvm::ConstantDataArray::getString(context, toPrint);

if (useGlobal) {
// Note: Does not work without allocation
 stringVar =
newllvm::GlobalVariable(module,
 stringConstant->getType(),
true,
 llvm::GlobalValue::PrivateLinkage,
 stringConstant,
"");
 }
else {
 stringVar = builder.CreateAlloca(stringConstant->getType());
 builder.CreateStore(stringConstant, stringVar);
 }

 llvm::Value *cast = builder.CreatePointerCast(stringVar,
 builder.getPtrTy());
 builder.CreateCall(printFunct, cast);
}

/// Generates code to print given runtime integer according to constant
/// string format, and a given print function.
/// @param context llvm context
/// @param module code for module instance
/// @param builder builder instance
/// @param printFunct function used to "print" integer
/// @param toPrint string to print
/// @param format printf like formatting string for print
/// @param useGlobal A value of true (default) indicates a GlobalValue is
/// generated, and is used to hold the constant string. A value of
/// false indicates that the constant string will be stored on the
/// stack.
voidgenerateIntegerPrint(llvm::LLVMContext &context, llvm::Module &module,
 llvm::IRBuilder<> &builder,
 llvm::Function &printFunct, llvm::Value *toPrint,
 std::string format, bool useGlobal = true) {
 llvm::Constant *stringConstant =
llvm::ConstantDataArray::getString(context, format);
 llvm::Value *stringVar;

if (useGlobal) {
// Note: Does not seem to work without allocation
 stringVar =
newllvm::GlobalVariable(module,
 stringConstant->getType(),
true,
 llvm::GlobalValue::PrivateLinkage,
 stringConstant,
"");
 }
else {
 stringVar = builder.CreateAlloca(stringConstant->getType());
 builder.CreateStore(stringConstant, stringVar);
 }

 llvm::Value *cast = builder.CreateBitCast(stringVar,
 builder.getPtrTy());
 builder.CreateCall(&printFunct, {toPrint, cast});
}

/// Generates code to handle finally block type semantics: always runs
/// regardless of whether a thrown exception is passing through or the
/// parent function is simply exiting. In addition to printing some state
/// to stderr, this code will resume the exception handling--runs the
/// unwind resume block, if the exception has not been previously caught
/// by a catch clause, and will otherwise execute the end block (terminator
/// block). In addition this function creates the corresponding function's
/// stack storage for the exception pointer and catch flag status.
/// @param context llvm context
/// @param module code for module instance
/// @param builder builder instance
/// @param toAddTo parent function to add block to
/// @param blockName block name of new "finally" block.
/// @param functionId output id used for printing
/// @param terminatorBlock terminator "end" block
/// @param unwindResumeBlock unwind resume block
/// @param exceptionCaughtFlag reference exception caught/thrown status storage
/// @param exceptionStorage reference to exception pointer storage
/// @param caughtResultStorage reference to landingpad result storage
/// @returns newly created block
static llvm::BasicBlock *createFinallyBlock(llvm::LLVMContext &context,
 llvm::Module &module,
 llvm::IRBuilder<> &builder,
 llvm::Function &toAddTo,
 std::string &blockName,
 std::string &functionId,
 llvm::BasicBlock &terminatorBlock,
 llvm::BasicBlock &unwindResumeBlock,
 llvm::Value **exceptionCaughtFlag,
 llvm::Value **exceptionStorage,
 llvm::Value **caughtResultStorage) {
assert(exceptionCaughtFlag &&
"ExceptionDemo::createFinallyBlock(...):exceptionCaughtFlag "
"is NULL");
assert(exceptionStorage &&
"ExceptionDemo::createFinallyBlock(...):exceptionStorage "
"is NULL");
assert(caughtResultStorage &&
"ExceptionDemo::createFinallyBlock(...):caughtResultStorage "
"is NULL");

 *exceptionCaughtFlag = createEntryBlockAlloca(toAddTo,
"exceptionCaught",
 ourExceptionNotThrownState->getType(),
 ourExceptionNotThrownState);

 llvm::PointerType *exceptionStorageType = builder.getPtrTy();
 *exceptionStorage = createEntryBlockAlloca(toAddTo,
"exceptionStorage",
 exceptionStorageType,
llvm::ConstantPointerNull::get(
 exceptionStorageType));
 *caughtResultStorage = createEntryBlockAlloca(toAddTo,
"caughtResultStorage",
 ourCaughtResultType,
llvm::ConstantAggregateZero::get(
 ourCaughtResultType));

 llvm::BasicBlock *ret = llvm::BasicBlock::Create(context,
 blockName,
 &toAddTo);

 builder.SetInsertPoint(ret);

 std::ostringstream bufferToPrint;
 bufferToPrint << "Gen: Executing finally block "
 << blockName << " in " << functionId << "\n";
generateStringPrint(context,
 module,
 builder,
 bufferToPrint.str(),
 USE_GLOBAL_STR_CONSTS);

 llvm::SwitchInst *theSwitch = builder.CreateSwitch(
 builder.CreateLoad(ourExceptionNotThrownState->getType(),