1 //===-- ExceptionDemo.cpp - An example using llvm Exceptions --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Demo program which implements an example LLVM exception implementation, and
11 // shows several test cases including the handling of foreign exceptions.
12 // It is run with type info types arguments to throw. A test will
13 // be run for each given type info type. While type info types with the value
14 // of -1 will trigger a foreign C++ exception to be thrown; type info types
15 // <= 6 and >= 1 will cause the associated generated exceptions to be thrown
16 // and caught by generated test functions; and type info types > 6
17 // will result in exceptions which pass through to the test harness. All other
18 // type info types are not supported and could cause a crash. In all cases,
19 // the "finally" blocks of every generated test functions will executed
20 // regardless of whether or not that test function ignores or catches the
27 // causes a usage to be printed to stderr
29 // ExceptionDemo 2 3 7 -1
31 // results in the following cases:
32 // - Value 2 causes an exception with a type info type of 2 to be
33 // thrown and caught by an inner generated test function.
34 // - Value 3 causes an exception with a type info type of 3 to be
35 // thrown and caught by an outer generated test function.
36 // - Value 7 causes an exception with a type info type of 7 to be
37 // thrown and NOT be caught by any generated function.
38 // - Value -1 causes a foreign C++ exception to be thrown and not be
39 // caught by any generated function
41 // Cases -1 and 7 are caught by a C++ test harness where the validity of
42 // of a C++ catch(...) clause catching a generated exception with a
43 // type info type of 7 is explained by: example in rules 1.6.4 in
44 // http://sourcery.mentor.com/public/cxx-abi/abi-eh.html (v1.22)
46 // This code uses code from the llvm compiler-rt project and the llvm
47 // Kaleidoscope project.
49 //===----------------------------------------------------------------------===//
51 #include "llvm/Analysis/Verifier.h"
52 #include "llvm/DataLayout.h"
53 #include "llvm/DerivedTypes.h"
54 #include "llvm/ExecutionEngine/ExecutionEngine.h"
55 #include "llvm/ExecutionEngine/JIT.h"
56 #include "llvm/IRBuilder.h"
57 #include "llvm/Intrinsics.h"
58 #include "llvm/LLVMContext.h"
59 #include "llvm/Module.h"
60 #include "llvm/PassManager.h"
61 #include "llvm/Support/Dwarf.h"
62 #include "llvm/Support/TargetSelect.h"
63 #include "llvm/Target/TargetOptions.h"
64 #include "llvm/Transforms/Scalar.h"
66 // FIXME: Although all systems tested with (Linux, OS X), do not need this
67 // header file included. A user on ubuntu reported, undefined symbols
68 // for stderr, and fprintf, and the addition of this include fixed the
69 // issue for them. Given that LLVM's best practices include the goal
70 // of reducing the number of redundant header files included, the
71 // correct solution would be to find out why these symbols are not
72 // defined for the system in question, and fix the issue by finding out
73 // which LLVM header file, if any, would include these symbols.
80 #ifndef USE_GLOBAL_STR_CONSTS
81 #define USE_GLOBAL_STR_CONSTS true
84 // System C++ ABI unwind types from:
85 // http://sourcery.mentor.com/public/cxx-abi/abi-eh.html (v1.22)
91 _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
92 _URC_FATAL_PHASE2_ERROR = 2,
93 _URC_FATAL_PHASE1_ERROR = 3,
95 _URC_END_OF_STACK = 5,
96 _URC_HANDLER_FOUND = 6,
97 _URC_INSTALL_CONTEXT = 7,
98 _URC_CONTINUE_UNWIND = 8
99 } _Unwind_Reason_Code;
102 _UA_SEARCH_PHASE = 1,
103 _UA_CLEANUP_PHASE = 2,
104 _UA_HANDLER_FRAME = 4,
105 _UA_FORCE_UNWIND = 8,
106 _UA_END_OF_STACK = 16
109 struct _Unwind_Exception;
111 typedef void (*_Unwind_Exception_Cleanup_Fn) (_Unwind_Reason_Code,
112 struct _Unwind_Exception *);
114 struct _Unwind_Exception {
115 uint64_t exception_class;
116 _Unwind_Exception_Cleanup_Fn exception_cleanup;
121 // @@@ The IA-64 ABI says that this structure must be double-word aligned.
122 // Taking that literally does not make much sense generically. Instead
123 // we provide the maximum alignment required by any type for the machine.
124 } __attribute__((__aligned__));
126 struct _Unwind_Context;
127 typedef struct _Unwind_Context *_Unwind_Context_t;
129 extern const uint8_t *_Unwind_GetLanguageSpecificData (_Unwind_Context_t c);
130 extern uintptr_t _Unwind_GetGR (_Unwind_Context_t c, int i);
131 extern void _Unwind_SetGR (_Unwind_Context_t c, int i, uintptr_t n);
132 extern void _Unwind_SetIP (_Unwind_Context_t, uintptr_t new_value);
133 extern uintptr_t _Unwind_GetIP (_Unwind_Context_t context);
134 extern uintptr_t _Unwind_GetRegionStart (_Unwind_Context_t context);
142 /// This is our simplistic type info
143 struct OurExceptionType_t {
149 /// This is our Exception class which relies on a negative offset to calculate
150 /// pointers to its instances from pointers to its unwindException member.
152 /// Note: The above unwind.h defines struct _Unwind_Exception to be aligned
153 /// on a double word boundary. This is necessary to match the standard:
154 /// http://refspecs.freestandards.org/abi-eh-1.21.html
155 struct OurBaseException_t {
156 struct OurExceptionType_t type;
158 // Note: This is properly aligned in unwind.h
159 struct _Unwind_Exception unwindException;
163 // Note: Not needed since we are C++
164 typedef struct OurBaseException_t OurException;
165 typedef struct _Unwind_Exception OurUnwindException;
168 // Various globals used to support typeinfo and generatted exceptions in
172 static std::map<std::string, llvm::Value*> namedValues;
174 int64_t ourBaseFromUnwindOffset;
176 const unsigned char ourBaseExcpClassChars[] =
177 {'o', 'b', 'j', '\0', 'b', 'a', 's', '\0'};
180 static uint64_t ourBaseExceptionClass = 0;
182 static std::vector<std::string> ourTypeInfoNames;
183 static std::map<int, std::string> ourTypeInfoNamesIndex;
185 static llvm::StructType *ourTypeInfoType;
186 static llvm::StructType *ourCaughtResultType;
187 static llvm::StructType *ourExceptionType;
188 static llvm::StructType *ourUnwindExceptionType;
190 static llvm::ConstantInt *ourExceptionNotThrownState;
191 static llvm::ConstantInt *ourExceptionThrownState;
192 static llvm::ConstantInt *ourExceptionCaughtState;
194 typedef std::vector<std::string> ArgNames;
195 typedef std::vector<llvm::Type*> ArgTypes;
198 // Code Generation Utilities
201 /// Utility used to create a function, both declarations and definitions
202 /// @param module for module instance
203 /// @param retType function return type
204 /// @param theArgTypes function's ordered argument types
205 /// @param theArgNames function's ordered arguments needed if use of this
206 /// function corresponds to a function definition. Use empty
207 /// aggregate for function declarations.
208 /// @param functName function name
209 /// @param linkage function linkage
210 /// @param declarationOnly for function declarations
211 /// @param isVarArg function uses vararg arguments
212 /// @returns function instance
213 llvm::Function *createFunction(llvm::Module &module,
215 const ArgTypes &theArgTypes,
216 const ArgNames &theArgNames,
217 const std::string &functName,
218 llvm::GlobalValue::LinkageTypes linkage,
219 bool declarationOnly,
221 llvm::FunctionType *functType =
222 llvm::FunctionType::get(retType, theArgTypes, isVarArg);
223 llvm::Function *ret =
224 llvm::Function::Create(functType, linkage, functName, &module);
225 if (!ret || declarationOnly)
230 for (llvm::Function::arg_iterator argIndex = ret->arg_begin();
231 i != theArgNames.size();
234 argIndex->setName(theArgNames[i]);
235 namedValues[theArgNames[i]] = argIndex;
242 /// Create an alloca instruction in the entry block of
243 /// the parent function. This is used for mutable variables etc.
244 /// @param function parent instance
245 /// @param varName stack variable name
246 /// @param type stack variable type
247 /// @param initWith optional constant initialization value
248 /// @returns AllocaInst instance
249 static llvm::AllocaInst *createEntryBlockAlloca(llvm::Function &function,
250 const std::string &varName,
252 llvm::Constant *initWith = 0) {
253 llvm::BasicBlock &block = function.getEntryBlock();
254 llvm::IRBuilder<> tmp(&block, block.begin());
255 llvm::AllocaInst *ret = tmp.CreateAlloca(type, 0, varName.c_str());
258 tmp.CreateStore(initWith, ret);
265 // Code Generation Utilities End
269 // Runtime C Library functions
272 // Note: using an extern "C" block so that static functions can be used
275 // Note: Better ways to decide on bit width
277 /// Prints a 32 bit number, according to the format, to stderr.
278 /// @param intToPrint integer to print
279 /// @param format printf like format to use when printing
280 void print32Int(int intToPrint, const char *format) {
282 // Note: No NULL check
283 fprintf(stderr, format, intToPrint);
286 // Note: No NULL check
287 fprintf(stderr, "::print32Int(...):NULL arg.\n");
292 // Note: Better ways to decide on bit width
294 /// Prints a 64 bit number, according to the format, to stderr.
295 /// @param intToPrint integer to print
296 /// @param format printf like format to use when printing
297 void print64Int(long int intToPrint, const char *format) {
299 // Note: No NULL check
300 fprintf(stderr, format, intToPrint);
303 // Note: No NULL check
304 fprintf(stderr, "::print64Int(...):NULL arg.\n");
309 /// Prints a C string to stderr
310 /// @param toPrint string to print
311 void printStr(char *toPrint) {
313 fprintf(stderr, "%s", toPrint);
316 fprintf(stderr, "::printStr(...):NULL arg.\n");
321 /// Deletes the true previosly allocated exception whose address
322 /// is calculated from the supplied OurBaseException_t::unwindException
323 /// member address. Handles (ignores), NULL pointers.
324 /// @param expToDelete exception to delete
325 void deleteOurException(OurUnwindException *expToDelete) {
328 "deleteOurException(...).\n");
332 (expToDelete->exception_class == ourBaseExceptionClass)) {
334 free(((char*) expToDelete) + ourBaseFromUnwindOffset);
339 /// This function is the struct _Unwind_Exception API mandated delete function
340 /// used by foreign exception handlers when deleting our exception
341 /// (OurException), instances.
342 /// @param reason @link http://refspecs.freestandards.org/abi-eh-1.21.html
344 /// @param expToDelete exception instance to delete
345 void deleteFromUnwindOurException(_Unwind_Reason_Code reason,
346 OurUnwindException *expToDelete) {
349 "deleteFromUnwindOurException(...).\n");
352 deleteOurException(expToDelete);
356 /// Creates (allocates on the heap), an exception (OurException instance),
357 /// of the supplied type info type.
358 /// @param type type info type
359 OurUnwindException *createOurException(int type) {
360 size_t size = sizeof(OurException);
361 OurException *ret = (OurException*) memset(malloc(size), 0, size);
362 (ret->type).type = type;
363 (ret->unwindException).exception_class = ourBaseExceptionClass;
364 (ret->unwindException).exception_cleanup = deleteFromUnwindOurException;
366 return(&(ret->unwindException));
370 /// Read a uleb128 encoded value and advance pointer
371 /// See Variable Length Data in:
372 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
373 /// @param data reference variable holding memory pointer to decode from
374 /// @returns decoded value
375 static uintptr_t readULEB128(const uint8_t **data) {
376 uintptr_t result = 0;
379 const uint8_t *p = *data;
383 result |= (byte & 0x7f) << shift;
394 /// Read a sleb128 encoded value and advance pointer
395 /// See Variable Length Data in:
396 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
397 /// @param data reference variable holding memory pointer to decode from
398 /// @returns decoded value
399 static uintptr_t readSLEB128(const uint8_t **data) {
400 uintptr_t result = 0;
403 const uint8_t *p = *data;
407 result |= (byte & 0x7f) << shift;
414 if ((byte & 0x40) && (shift < (sizeof(result) << 3))) {
415 result |= (~0 << shift);
422 /// Read a pointer encoded value and advance pointer
423 /// See Variable Length Data in:
424 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
425 /// @param data reference variable holding memory pointer to decode from
426 /// @param encoding dwarf encoding type
427 /// @returns decoded value
428 static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encoding) {
429 uintptr_t result = 0;
430 const uint8_t *p = *data;
432 if (encoding == llvm::dwarf::DW_EH_PE_omit)
436 switch (encoding & 0x0F) {
437 case llvm::dwarf::DW_EH_PE_absptr:
438 result = *((uintptr_t*)p);
439 p += sizeof(uintptr_t);
441 case llvm::dwarf::DW_EH_PE_uleb128:
442 result = readULEB128(&p);
444 // Note: This case has not been tested
445 case llvm::dwarf::DW_EH_PE_sleb128:
446 result = readSLEB128(&p);
448 case llvm::dwarf::DW_EH_PE_udata2:
449 result = *((uint16_t*)p);
450 p += sizeof(uint16_t);
452 case llvm::dwarf::DW_EH_PE_udata4:
453 result = *((uint32_t*)p);
454 p += sizeof(uint32_t);
456 case llvm::dwarf::DW_EH_PE_udata8:
457 result = *((uint64_t*)p);
458 p += sizeof(uint64_t);
460 case llvm::dwarf::DW_EH_PE_sdata2:
461 result = *((int16_t*)p);
462 p += sizeof(int16_t);
464 case llvm::dwarf::DW_EH_PE_sdata4:
465 result = *((int32_t*)p);
466 p += sizeof(int32_t);
468 case llvm::dwarf::DW_EH_PE_sdata8:
469 result = *((int64_t*)p);
470 p += sizeof(int64_t);
478 // then add relative offset
479 switch (encoding & 0x70) {
480 case llvm::dwarf::DW_EH_PE_absptr:
483 case llvm::dwarf::DW_EH_PE_pcrel:
484 result += (uintptr_t)(*data);
486 case llvm::dwarf::DW_EH_PE_textrel:
487 case llvm::dwarf::DW_EH_PE_datarel:
488 case llvm::dwarf::DW_EH_PE_funcrel:
489 case llvm::dwarf::DW_EH_PE_aligned:
496 // then apply indirection
497 if (encoding & llvm::dwarf::DW_EH_PE_indirect) {
498 result = *((uintptr_t*)result);
507 /// Deals with Dwarf actions matching our type infos
508 /// (OurExceptionType_t instances). Returns whether or not a dwarf emitted
509 /// action matches the supplied exception type. If such a match succeeds,
510 /// the resultAction argument will be set with > 0 index value. Only
511 /// corresponding llvm.eh.selector type info arguments, cleanup arguments
512 /// are supported. Filters are not supported.
513 /// See Variable Length Data in:
514 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
515 /// Also see @link http://refspecs.freestandards.org/abi-eh-1.21.html @unlink
516 /// @param resultAction reference variable which will be set with result
517 /// @param classInfo our array of type info pointers (to globals)
518 /// @param actionEntry index into above type info array or 0 (clean up).
519 /// We do not support filters.
520 /// @param exceptionClass exception class (_Unwind_Exception::exception_class)
521 /// of thrown exception.
522 /// @param exceptionObject thrown _Unwind_Exception instance.
523 /// @returns whether or not a type info was found. False is returned if only
524 /// a cleanup was found
525 static bool handleActionValue(int64_t *resultAction,
526 struct OurExceptionType_t **classInfo,
527 uintptr_t actionEntry,
528 uint64_t exceptionClass,
529 struct _Unwind_Exception *exceptionObject) {
534 (exceptionClass != ourBaseExceptionClass))
537 struct OurBaseException_t *excp = (struct OurBaseException_t*)
538 (((char*) exceptionObject) + ourBaseFromUnwindOffset);
539 struct OurExceptionType_t *excpType = &(excp->type);
540 int type = excpType->type;
544 "handleActionValue(...): exceptionObject = <%p>, "
550 const uint8_t *actionPos = (uint8_t*) actionEntry,
552 int64_t typeOffset = 0,
555 for (int i = 0; true; ++i) {
556 // Each emitted dwarf action corresponds to a 2 tuple of
557 // type info address offset, and action offset to the next
559 typeOffset = readSLEB128(&actionPos);
560 tempActionPos = actionPos;
561 actionOffset = readSLEB128(&tempActionPos);
565 "handleActionValue(...):typeOffset: <%lld>, "
566 "actionOffset: <%lld>.\n",
570 assert((typeOffset >= 0) &&
571 "handleActionValue(...):filters are not supported.");
573 // Note: A typeOffset == 0 implies that a cleanup llvm.eh.selector
574 // argument has been matched.
575 if ((typeOffset > 0) &&
576 (type == (classInfo[-typeOffset])->type)) {
579 "handleActionValue(...):actionValue <%d> found.\n",
582 *resultAction = i + 1;
589 "handleActionValue(...):actionValue not found.\n");
594 actionPos += actionOffset;
601 /// Deals with the Language specific data portion of the emitted dwarf code.
602 /// See @link http://refspecs.freestandards.org/abi-eh-1.21.html @unlink
603 /// @param version unsupported (ignored), unwind version
604 /// @param lsda language specific data area
605 /// @param _Unwind_Action actions minimally supported unwind stage
606 /// (forced specifically not supported)
607 /// @param exceptionClass exception class (_Unwind_Exception::exception_class)
608 /// of thrown exception.
609 /// @param exceptionObject thrown _Unwind_Exception instance.
610 /// @param context unwind system context
611 /// @returns minimally supported unwinding control indicator
612 static _Unwind_Reason_Code handleLsda(int version,
614 _Unwind_Action actions,
615 uint64_t exceptionClass,
616 struct _Unwind_Exception *exceptionObject,
617 _Unwind_Context_t context) {
618 _Unwind_Reason_Code ret = _URC_CONTINUE_UNWIND;
625 "handleLsda(...):lsda is non-zero.\n");
628 // Get the current instruction pointer and offset it before next
629 // instruction in the current frame which threw the exception.
630 uintptr_t pc = _Unwind_GetIP(context)-1;
632 // Get beginning current frame's code (as defined by the
633 // emitted dwarf code)
634 uintptr_t funcStart = _Unwind_GetRegionStart(context);
635 uintptr_t pcOffset = pc - funcStart;
636 struct OurExceptionType_t **classInfo = NULL;
638 // Note: See JITDwarfEmitter::EmitExceptionTable(...) for corresponding
641 // Parse LSDA header.
642 uint8_t lpStartEncoding = *lsda++;
644 if (lpStartEncoding != llvm::dwarf::DW_EH_PE_omit) {
645 readEncodedPointer(&lsda, lpStartEncoding);
648 uint8_t ttypeEncoding = *lsda++;
649 uintptr_t classInfoOffset;
651 if (ttypeEncoding != llvm::dwarf::DW_EH_PE_omit) {
652 // Calculate type info locations in emitted dwarf code which
653 // were flagged by type info arguments to llvm.eh.selector
655 classInfoOffset = readULEB128(&lsda);
656 classInfo = (struct OurExceptionType_t**) (lsda + classInfoOffset);
659 // Walk call-site table looking for range that
660 // includes current PC.
662 uint8_t callSiteEncoding = *lsda++;
663 uint32_t callSiteTableLength = readULEB128(&lsda);
664 const uint8_t *callSiteTableStart = lsda;
665 const uint8_t *callSiteTableEnd = callSiteTableStart +
667 const uint8_t *actionTableStart = callSiteTableEnd;
668 const uint8_t *callSitePtr = callSiteTableStart;
670 while (callSitePtr < callSiteTableEnd) {
671 uintptr_t start = readEncodedPointer(&callSitePtr,
673 uintptr_t length = readEncodedPointer(&callSitePtr,
675 uintptr_t landingPad = readEncodedPointer(&callSitePtr,
678 // Note: Action value
679 uintptr_t actionEntry = readULEB128(&callSitePtr);
681 if (exceptionClass != ourBaseExceptionClass) {
682 // We have been notified of a foreign exception being thrown,
683 // and we therefore need to execute cleanup landing pads
687 if (landingPad == 0) {
690 "handleLsda(...): No landing pad found.\n");
693 continue; // no landing pad for this entry
697 actionEntry += ((uintptr_t) actionTableStart) - 1;
702 "handleLsda(...):No action table found.\n");
706 bool exceptionMatched = false;
708 if ((start <= pcOffset) && (pcOffset < (start + length))) {
711 "handleLsda(...): Landing pad found.\n");
713 int64_t actionValue = 0;
716 exceptionMatched = handleActionValue(&actionValue,
723 if (!(actions & _UA_SEARCH_PHASE)) {
726 "handleLsda(...): installed landing pad "
730 // Found landing pad for the PC.
731 // Set Instruction Pointer to so we re-enter function
732 // at landing pad. The landing pad is created by the
733 // compiler to take two parameters in registers.
734 _Unwind_SetGR(context,
735 __builtin_eh_return_data_regno(0),
736 (uintptr_t)exceptionObject);
738 // Note: this virtual register directly corresponds
739 // to the return of the llvm.eh.selector intrinsic
740 if (!actionEntry || !exceptionMatched) {
741 // We indicate cleanup only
742 _Unwind_SetGR(context,
743 __builtin_eh_return_data_regno(1),
747 // Matched type info index of llvm.eh.selector intrinsic
749 _Unwind_SetGR(context,
750 __builtin_eh_return_data_regno(1),
754 // To execute landing pad set here
755 _Unwind_SetIP(context, funcStart + landingPad);
756 ret = _URC_INSTALL_CONTEXT;
758 else if (exceptionMatched) {
761 "handleLsda(...): setting handler found.\n");
763 ret = _URC_HANDLER_FOUND;
766 // Note: Only non-clean up handlers are marked as
767 // found. Otherwise the clean up handlers will be
768 // re-found and executed during the clean up
772 "handleLsda(...): cleanup handler found.\n");
784 /// This is the personality function which is embedded (dwarf emitted), in the
785 /// dwarf unwind info block. Again see: JITDwarfEmitter.cpp.
786 /// See @link http://refspecs.freestandards.org/abi-eh-1.21.html @unlink
787 /// @param version unsupported (ignored), unwind version
788 /// @param _Unwind_Action actions minimally supported unwind stage
789 /// (forced specifically not supported)
790 /// @param exceptionClass exception class (_Unwind_Exception::exception_class)
791 /// of thrown exception.
792 /// @param exceptionObject thrown _Unwind_Exception instance.
793 /// @param context unwind system context
794 /// @returns minimally supported unwinding control indicator
795 _Unwind_Reason_Code ourPersonality(int version,
796 _Unwind_Action actions,
797 uint64_t exceptionClass,
798 struct _Unwind_Exception *exceptionObject,
799 _Unwind_Context_t context) {
802 "We are in ourPersonality(...):actions is <%d>.\n",
805 if (actions & _UA_SEARCH_PHASE) {
806 fprintf(stderr, "ourPersonality(...):In search phase.\n");
809 fprintf(stderr, "ourPersonality(...):In non-search phase.\n");
813 const uint8_t *lsda = _Unwind_GetLanguageSpecificData(context);
817 "ourPersonality(...):lsda = <%p>.\n",
821 // The real work of the personality function is captured here
822 return(handleLsda(version,
831 /// Generates our _Unwind_Exception class from a given character array.
832 /// thereby handling arbitrary lengths (not in standard), and handling
834 /// See @link http://refspecs.freestandards.org/abi-eh-1.21.html @unlink
835 /// @param classChars char array to encode. NULL values not checkedf
836 /// @param classCharsSize number of chars in classChars. Value is not checked.
837 /// @returns class value
838 uint64_t genClass(const unsigned char classChars[], size_t classCharsSize)
840 uint64_t ret = classChars[0];
842 for (unsigned i = 1; i < classCharsSize; ++i) {
844 ret += classChars[i];
853 // Runtime C Library functions End
857 // Code generation functions
860 /// Generates code to print given constant string
861 /// @param context llvm context
862 /// @param module code for module instance
863 /// @param builder builder instance
864 /// @param toPrint string to print
865 /// @param useGlobal A value of true (default) indicates a GlobalValue is
866 /// generated, and is used to hold the constant string. A value of
867 /// false indicates that the constant string will be stored on the
869 void generateStringPrint(llvm::LLVMContext &context,
870 llvm::Module &module,
871 llvm::IRBuilder<> &builder,
873 bool useGlobal = true) {
874 llvm::Function *printFunct = module.getFunction("printStr");
876 llvm::Value *stringVar;
877 llvm::Constant *stringConstant =
878 llvm::ConstantDataArray::getString(context, toPrint);
881 // Note: Does not work without allocation
883 new llvm::GlobalVariable(module,
884 stringConstant->getType(),
886 llvm::GlobalValue::LinkerPrivateLinkage,
891 stringVar = builder.CreateAlloca(stringConstant->getType());
892 builder.CreateStore(stringConstant, stringVar);
895 llvm::Value *cast = builder.CreatePointerCast(stringVar,
896 builder.getInt8PtrTy());
897 builder.CreateCall(printFunct, cast);
901 /// Generates code to print given runtime integer according to constant
902 /// string format, and a given print function.
903 /// @param context llvm context
904 /// @param module code for module instance
905 /// @param builder builder instance
906 /// @param printFunct function used to "print" integer
907 /// @param toPrint string to print
908 /// @param format printf like formating string for print
909 /// @param useGlobal A value of true (default) indicates a GlobalValue is
910 /// generated, and is used to hold the constant string. A value of
911 /// false indicates that the constant string will be stored on the
913 void generateIntegerPrint(llvm::LLVMContext &context,
914 llvm::Module &module,
915 llvm::IRBuilder<> &builder,
916 llvm::Function &printFunct,
917 llvm::Value &toPrint,
919 bool useGlobal = true) {
920 llvm::Constant *stringConstant =
921 llvm::ConstantDataArray::getString(context, format);
922 llvm::Value *stringVar;
925 // Note: Does not seem to work without allocation
927 new llvm::GlobalVariable(module,
928 stringConstant->getType(),
930 llvm::GlobalValue::LinkerPrivateLinkage,
935 stringVar = builder.CreateAlloca(stringConstant->getType());
936 builder.CreateStore(stringConstant, stringVar);
939 llvm::Value *cast = builder.CreateBitCast(stringVar,
940 builder.getInt8PtrTy());
941 builder.CreateCall2(&printFunct, &toPrint, cast);
945 /// Generates code to handle finally block type semantics: always runs
946 /// regardless of whether a thrown exception is passing through or the
947 /// parent function is simply exiting. In addition to printing some state
948 /// to stderr, this code will resume the exception handling--runs the
949 /// unwind resume block, if the exception has not been previously caught
950 /// by a catch clause, and will otherwise execute the end block (terminator
951 /// block). In addition this function creates the corresponding function's
952 /// stack storage for the exception pointer and catch flag status.
953 /// @param context llvm context
954 /// @param module code for module instance
955 /// @param builder builder instance
956 /// @param toAddTo parent function to add block to
957 /// @param blockName block name of new "finally" block.
958 /// @param functionId output id used for printing
959 /// @param terminatorBlock terminator "end" block
960 /// @param unwindResumeBlock unwind resume block
961 /// @param exceptionCaughtFlag reference exception caught/thrown status storage
962 /// @param exceptionStorage reference to exception pointer storage
963 /// @param caughtResultStorage reference to landingpad result storage
964 /// @returns newly created block
965 static llvm::BasicBlock *createFinallyBlock(llvm::LLVMContext &context,
966 llvm::Module &module,
967 llvm::IRBuilder<> &builder,
968 llvm::Function &toAddTo,
969 std::string &blockName,
970 std::string &functionId,
971 llvm::BasicBlock &terminatorBlock,
972 llvm::BasicBlock &unwindResumeBlock,
973 llvm::Value **exceptionCaughtFlag,
974 llvm::Value **exceptionStorage,
975 llvm::Value **caughtResultStorage) {
976 assert(exceptionCaughtFlag &&
977 "ExceptionDemo::createFinallyBlock(...):exceptionCaughtFlag "
979 assert(exceptionStorage &&
980 "ExceptionDemo::createFinallyBlock(...):exceptionStorage "
982 assert(caughtResultStorage &&
983 "ExceptionDemo::createFinallyBlock(...):caughtResultStorage "
986 *exceptionCaughtFlag = createEntryBlockAlloca(toAddTo,
988 ourExceptionNotThrownState->getType(),
989 ourExceptionNotThrownState);
991 llvm::PointerType *exceptionStorageType = builder.getInt8PtrTy();
992 *exceptionStorage = createEntryBlockAlloca(toAddTo,
994 exceptionStorageType,
995 llvm::ConstantPointerNull::get(
996 exceptionStorageType));
997 *caughtResultStorage = createEntryBlockAlloca(toAddTo,
998 "caughtResultStorage",
1000 llvm::ConstantAggregateZero::get(
1001 ourCaughtResultType));
1003 llvm::BasicBlock *ret = llvm::BasicBlock::Create(context,
1007 builder.SetInsertPoint(ret);
1009 std::ostringstream bufferToPrint;
1010 bufferToPrint << "Gen: Executing finally block "
1011 << blockName << " in " << functionId << "\n";
1012 generateStringPrint(context,
1015 bufferToPrint.str(),
1016 USE_GLOBAL_STR_CONSTS);
1018 llvm::SwitchInst *theSwitch = builder.CreateSwitch(builder.CreateLoad(
1019 *exceptionCaughtFlag),
1022 theSwitch->addCase(ourExceptionCaughtState, &terminatorBlock);
1023 theSwitch->addCase(ourExceptionThrownState, &unwindResumeBlock);
1029 /// Generates catch block semantics which print a string to indicate type of
1030 /// catch executed, sets an exception caught flag, and executes passed in
1031 /// end block (terminator block).
1032 /// @param context llvm context
1033 /// @param module code for module instance
1034 /// @param builder builder instance
1035 /// @param toAddTo parent function to add block to
1036 /// @param blockName block name of new "catch" block.
1037 /// @param functionId output id used for printing
1038 /// @param terminatorBlock terminator "end" block
1039 /// @param exceptionCaughtFlag exception caught/thrown status
1040 /// @returns newly created block
1041 static llvm::BasicBlock *createCatchBlock(llvm::LLVMContext &context,
1042 llvm::Module &module,
1043 llvm::IRBuilder<> &builder,
1044 llvm::Function &toAddTo,
1045 std::string &blockName,
1046 std::string &functionId,
1047 llvm::BasicBlock &terminatorBlock,
1048 llvm::Value &exceptionCaughtFlag) {
1050 llvm::BasicBlock *ret = llvm::BasicBlock::Create(context,
1054 builder.SetInsertPoint(ret);
1056 std::ostringstream bufferToPrint;
1057 bufferToPrint << "Gen: Executing catch block "
1062 generateStringPrint(context,
1065 bufferToPrint.str(),
1066 USE_GLOBAL_STR_CONSTS);
1067 builder.CreateStore(ourExceptionCaughtState, &exceptionCaughtFlag);
1068 builder.CreateBr(&terminatorBlock);
1074 /// Generates a function which invokes a function (toInvoke) and, whose
1075 /// unwind block will "catch" the type info types correspondingly held in the
1076 /// exceptionTypesToCatch argument. If the toInvoke function throws an
1077 /// exception which does not match any type info types contained in
1078 /// exceptionTypesToCatch, the generated code will call _Unwind_Resume
1079 /// with the raised exception. On the other hand the generated code will
1080 /// normally exit if the toInvoke function does not throw an exception.
1081 /// The generated "finally" block is always run regardless of the cause of
1082 /// the generated function exit.
1083 /// The generated function is returned after being verified.
1084 /// @param module code for module instance
1085 /// @param builder builder instance
1086 /// @param fpm a function pass manager holding optional IR to IR
1088 /// @param toInvoke inner function to invoke
1089 /// @param ourId id used to printing purposes
1090 /// @param numExceptionsToCatch length of exceptionTypesToCatch array
1091 /// @param exceptionTypesToCatch array of type info types to "catch"
1092 /// @returns generated function
1094 llvm::Function *createCatchWrappedInvokeFunction(llvm::Module &module,
1095 llvm::IRBuilder<> &builder,
1096 llvm::FunctionPassManager &fpm,
1097 llvm::Function &toInvoke,
1099 unsigned numExceptionsToCatch,
1100 unsigned exceptionTypesToCatch[]) {
1102 llvm::LLVMContext &context = module.getContext();
1103 llvm::Function *toPrint32Int = module.getFunction("print32Int");
1106 argTypes.push_back(builder.getInt32Ty());
1109 argNames.push_back("exceptTypeToThrow");
1111 llvm::Function *ret = createFunction(module,
1112 builder.getVoidTy(),
1116 llvm::Function::ExternalLinkage,
1120 // Block which calls invoke
1121 llvm::BasicBlock *entryBlock = llvm::BasicBlock::Create(context,
1124 // Normal block for invoke
1125 llvm::BasicBlock *normalBlock = llvm::BasicBlock::Create(context,
1128 // Unwind block for invoke
1129 llvm::BasicBlock *exceptionBlock = llvm::BasicBlock::Create(context,
1133 // Block which routes exception to correct catch handler block
1134 llvm::BasicBlock *exceptionRouteBlock = llvm::BasicBlock::Create(context,
1138 // Foreign exception handler
1139 llvm::BasicBlock *externalExceptionBlock = llvm::BasicBlock::Create(context,
1140 "externalException",
1143 // Block which calls _Unwind_Resume
1144 llvm::BasicBlock *unwindResumeBlock = llvm::BasicBlock::Create(context,
1148 // Clean up block which delete exception if needed
1149 llvm::BasicBlock *endBlock = llvm::BasicBlock::Create(context, "end", ret);
1151 std::string nextName;
1152 std::vector<llvm::BasicBlock*> catchBlocks(numExceptionsToCatch);
1153 llvm::Value *exceptionCaughtFlag = NULL;
1154 llvm::Value *exceptionStorage = NULL;
1155 llvm::Value *caughtResultStorage = NULL;
1157 // Finally block which will branch to unwindResumeBlock if
1158 // exception is not caught. Initializes/allocates stack locations.
1159 llvm::BasicBlock *finallyBlock = createFinallyBlock(context,
1163 nextName = "finally",
1167 &exceptionCaughtFlag,
1169 &caughtResultStorage
1172 for (unsigned i = 0; i < numExceptionsToCatch; ++i) {
1173 nextName = ourTypeInfoNames[exceptionTypesToCatch[i]];
1175 // One catch block per type info to be caught
1176 catchBlocks[i] = createCatchBlock(context,
1183 *exceptionCaughtFlag);
1188 builder.SetInsertPoint(entryBlock);
1190 std::vector<llvm::Value*> args;
1191 args.push_back(namedValues["exceptTypeToThrow"]);
1192 builder.CreateInvoke(&toInvoke,
1199 builder.SetInsertPoint(endBlock);
1201 generateStringPrint(context,
1204 "Gen: In end block: exiting in " + ourId + ".\n",
1205 USE_GLOBAL_STR_CONSTS);
1206 llvm::Function *deleteOurException = module.getFunction("deleteOurException");
1208 // Note: function handles NULL exceptions
1209 builder.CreateCall(deleteOurException,
1210 builder.CreateLoad(exceptionStorage));
1211 builder.CreateRetVoid();
1215 builder.SetInsertPoint(normalBlock);
1217 generateStringPrint(context,
1220 "Gen: No exception in " + ourId + "!\n",
1221 USE_GLOBAL_STR_CONSTS);
1223 // Finally block is always called
1224 builder.CreateBr(finallyBlock);
1226 // Unwind Resume Block
1228 builder.SetInsertPoint(unwindResumeBlock);
1230 builder.CreateResume(builder.CreateLoad(caughtResultStorage));
1234 builder.SetInsertPoint(exceptionBlock);
1236 llvm::Function *personality = module.getFunction("ourPersonality");
1238 llvm::LandingPadInst *caughtResult =
1239 builder.CreateLandingPad(ourCaughtResultType,
1241 numExceptionsToCatch,
1244 caughtResult->setCleanup(true);
1246 for (unsigned i = 0; i < numExceptionsToCatch; ++i) {
1247 // Set up type infos to be caught
1248 caughtResult->addClause(module.getGlobalVariable(
1249 ourTypeInfoNames[exceptionTypesToCatch[i]]));
1252 llvm::Value *unwindException = builder.CreateExtractValue(caughtResult, 0);
1253 llvm::Value *retTypeInfoIndex = builder.CreateExtractValue(caughtResult, 1);
1255 // FIXME: Redundant storage which, beyond utilizing value of
1256 // caughtResultStore for unwindException storage, may be alleviated
1257 // altogether with a block rearrangement
1258 builder.CreateStore(caughtResult, caughtResultStorage);
1259 builder.CreateStore(unwindException, exceptionStorage);
1260 builder.CreateStore(ourExceptionThrownState, exceptionCaughtFlag);
1262 // Retrieve exception_class member from thrown exception
1263 // (_Unwind_Exception instance). This member tells us whether or not
1264 // the exception is foreign.
1265 llvm::Value *unwindExceptionClass =
1266 builder.CreateLoad(builder.CreateStructGEP(
1267 builder.CreatePointerCast(unwindException,
1268 ourUnwindExceptionType->getPointerTo()),
1271 // Branch to the externalExceptionBlock if the exception is foreign or
1272 // to a catch router if not. Either way the finally block will be run.
1273 builder.CreateCondBr(builder.CreateICmpEQ(unwindExceptionClass,
1274 llvm::ConstantInt::get(builder.getInt64Ty(),
1275 ourBaseExceptionClass)),
1276 exceptionRouteBlock,
1277 externalExceptionBlock);
1279 // External Exception Block
1281 builder.SetInsertPoint(externalExceptionBlock);
1283 generateStringPrint(context,
1286 "Gen: Foreign exception received.\n",
1287 USE_GLOBAL_STR_CONSTS);
1289 // Branch to the finally block
1290 builder.CreateBr(finallyBlock);
1292 // Exception Route Block
1294 builder.SetInsertPoint(exceptionRouteBlock);
1296 // Casts exception pointer (_Unwind_Exception instance) to parent
1297 // (OurException instance).
1299 // Note: ourBaseFromUnwindOffset is usually negative
1300 llvm::Value *typeInfoThrown = builder.CreatePointerCast(
1301 builder.CreateConstGEP1_64(unwindException,
1302 ourBaseFromUnwindOffset),
1303 ourExceptionType->getPointerTo());
1305 // Retrieve thrown exception type info type
1307 // Note: Index is not relative to pointer but instead to structure
1308 // unlike a true getelementptr (GEP) instruction
1309 typeInfoThrown = builder.CreateStructGEP(typeInfoThrown, 0);
1311 llvm::Value *typeInfoThrownType =
1312 builder.CreateStructGEP(typeInfoThrown, 0);
1314 generateIntegerPrint(context,
1318 *(builder.CreateLoad(typeInfoThrownType)),
1319 "Gen: Exception type <%d> received (stack unwound) "
1323 USE_GLOBAL_STR_CONSTS);
1325 // Route to matched type info catch block or run cleanup finally block
1326 llvm::SwitchInst *switchToCatchBlock = builder.CreateSwitch(retTypeInfoIndex,
1328 numExceptionsToCatch);
1330 unsigned nextTypeToCatch;
1332 for (unsigned i = 1; i <= numExceptionsToCatch; ++i) {
1333 nextTypeToCatch = i - 1;
1334 switchToCatchBlock->addCase(llvm::ConstantInt::get(
1335 llvm::Type::getInt32Ty(context), i),
1336 catchBlocks[nextTypeToCatch]);
1339 llvm::verifyFunction(*ret);
1346 /// Generates function which throws either an exception matched to a runtime
1347 /// determined type info type (argument to generated function), or if this
1348 /// runtime value matches nativeThrowType, throws a foreign exception by
1349 /// calling nativeThrowFunct.
1350 /// @param module code for module instance
1351 /// @param builder builder instance
1352 /// @param fpm a function pass manager holding optional IR to IR
1354 /// @param ourId id used to printing purposes
1355 /// @param nativeThrowType a runtime argument of this value results in
1356 /// nativeThrowFunct being called to generate/throw exception.
1357 /// @param nativeThrowFunct function which will throw a foreign exception
1358 /// if the above nativeThrowType matches generated function's arg.
1359 /// @returns generated function
1361 llvm::Function *createThrowExceptionFunction(llvm::Module &module,
1362 llvm::IRBuilder<> &builder,
1363 llvm::FunctionPassManager &fpm,
1365 int32_t nativeThrowType,
1366 llvm::Function &nativeThrowFunct) {
1367 llvm::LLVMContext &context = module.getContext();
1368 namedValues.clear();
1369 ArgTypes unwindArgTypes;
1370 unwindArgTypes.push_back(builder.getInt32Ty());
1371 ArgNames unwindArgNames;
1372 unwindArgNames.push_back("exceptTypeToThrow");
1374 llvm::Function *ret = createFunction(module,
1375 builder.getVoidTy(),
1379 llvm::Function::ExternalLinkage,
1383 // Throws either one of our exception or a native C++ exception depending
1384 // on a runtime argument value containing a type info type.
1385 llvm::BasicBlock *entryBlock = llvm::BasicBlock::Create(context,
1388 // Throws a foreign exception
1389 llvm::BasicBlock *nativeThrowBlock = llvm::BasicBlock::Create(context,
1392 // Throws one of our Exceptions
1393 llvm::BasicBlock *generatedThrowBlock = llvm::BasicBlock::Create(context,
1396 // Retrieved runtime type info type to throw
1397 llvm::Value *exceptionType = namedValues["exceptTypeToThrow"];
1399 // nativeThrowBlock block
1401 builder.SetInsertPoint(nativeThrowBlock);
1403 // Throws foreign exception
1404 builder.CreateCall(&nativeThrowFunct, exceptionType);
1405 builder.CreateUnreachable();
1409 builder.SetInsertPoint(entryBlock);
1411 llvm::Function *toPrint32Int = module.getFunction("print32Int");
1412 generateIntegerPrint(context,
1417 "\nGen: About to throw exception type <%d> in " +
1420 USE_GLOBAL_STR_CONSTS);
1422 // Switches on runtime type info type value to determine whether or not
1423 // a foreign exception is thrown. Defaults to throwing one of our
1424 // generated exceptions.
1425 llvm::SwitchInst *theSwitch = builder.CreateSwitch(exceptionType,
1426 generatedThrowBlock,
1429 theSwitch->addCase(llvm::ConstantInt::get(llvm::Type::getInt32Ty(context),
1433 // generatedThrow block
1435 builder.SetInsertPoint(generatedThrowBlock);
1437 llvm::Function *createOurException = module.getFunction("createOurException");
1438 llvm::Function *raiseOurException = module.getFunction(
1439 "_Unwind_RaiseException");
1441 // Creates exception to throw with runtime type info type.
1442 llvm::Value *exception = builder.CreateCall(createOurException,
1443 namedValues["exceptTypeToThrow"]);
1445 // Throw generated Exception
1446 builder.CreateCall(raiseOurException, exception);
1447 builder.CreateUnreachable();
1449 llvm::verifyFunction(*ret);
1455 static void createStandardUtilityFunctions(unsigned numTypeInfos,
1456 llvm::Module &module,
1457 llvm::IRBuilder<> &builder);
1459 /// Creates test code by generating and organizing these functions into the
1460 /// test case. The test case consists of an outer function setup to invoke
1461 /// an inner function within an environment having multiple catch and single
1462 /// finally blocks. This inner function is also setup to invoke a throw
1463 /// function within an evironment similar in nature to the outer function's
1464 /// catch and finally blocks. Each of these two functions catch mutually
1465 /// exclusive subsets (even or odd) of the type info types configured
1466 /// for this this. All generated functions have a runtime argument which
1467 /// holds a type info type to throw that each function takes and passes it
1468 /// to the inner one if such a inner function exists. This type info type is
1469 /// looked at by the generated throw function to see whether or not it should
1470 /// throw a generated exception with the same type info type, or instead call
1471 /// a supplied a function which in turn will throw a foreign exception.
1472 /// @param module code for module instance
1473 /// @param builder builder instance
1474 /// @param fpm a function pass manager holding optional IR to IR
1476 /// @param nativeThrowFunctName name of external function which will throw
1477 /// a foreign exception
1478 /// @returns outermost generated test function.
1479 llvm::Function *createUnwindExceptionTest(llvm::Module &module,
1480 llvm::IRBuilder<> &builder,
1481 llvm::FunctionPassManager &fpm,
1482 std::string nativeThrowFunctName) {
1483 // Number of type infos to generate
1484 unsigned numTypeInfos = 6;
1486 // Initialze intrisics and external functions to use along with exception
1487 // and type info globals.
1488 createStandardUtilityFunctions(numTypeInfos,
1491 llvm::Function *nativeThrowFunct = module.getFunction(nativeThrowFunctName);
1493 // Create exception throw function using the value ~0 to cause
1494 // foreign exceptions to be thrown.
1495 llvm::Function *throwFunct = createThrowExceptionFunction(module,
1501 // Inner function will catch even type infos
1502 unsigned innerExceptionTypesToCatch[] = {6, 2, 4};
1503 size_t numExceptionTypesToCatch = sizeof(innerExceptionTypesToCatch) /
1506 // Generate inner function.
1507 llvm::Function *innerCatchFunct = createCatchWrappedInvokeFunction(module,
1512 numExceptionTypesToCatch,
1513 innerExceptionTypesToCatch);
1515 // Outer function will catch odd type infos
1516 unsigned outerExceptionTypesToCatch[] = {3, 1, 5};
1517 numExceptionTypesToCatch = sizeof(outerExceptionTypesToCatch) /
1520 // Generate outer function
1521 llvm::Function *outerCatchFunct = createCatchWrappedInvokeFunction(module,
1526 numExceptionTypesToCatch,
1527 outerExceptionTypesToCatch);
1529 // Return outer function to run
1530 return(outerCatchFunct);
1534 /// Represents our foreign exceptions
1535 class OurCppRunException : public std::runtime_error {
1537 OurCppRunException(const std::string reason) :
1538 std::runtime_error(reason) {}
1540 OurCppRunException (const OurCppRunException &toCopy) :
1541 std::runtime_error(toCopy) {}
1543 OurCppRunException &operator = (const OurCppRunException &toCopy) {
1544 return(reinterpret_cast<OurCppRunException&>(
1545 std::runtime_error::operator=(toCopy)));
1548 ~OurCppRunException (void) throw () {}
1552 /// Throws foreign C++ exception.
1553 /// @param ignoreIt unused parameter that allows function to match implied
1554 /// generated function contract.
1556 void throwCppException (int32_t ignoreIt) {
1557 throw(OurCppRunException("thrown by throwCppException(...)"));
1560 typedef void (*OurExceptionThrowFunctType) (int32_t typeToThrow);
1562 /// This is a test harness which runs test by executing generated
1563 /// function with a type info type to throw. Harness wraps the execution
1564 /// of generated function in a C++ try catch clause.
1565 /// @param engine execution engine to use for executing generated function.
1566 /// This demo program expects this to be a JIT instance for demo
1568 /// @param function generated test function to run
1569 /// @param typeToThrow type info type of generated exception to throw, or
1570 /// indicator to cause foreign exception to be thrown.
1572 void runExceptionThrow(llvm::ExecutionEngine *engine,
1573 llvm::Function *function,
1574 int32_t typeToThrow) {
1576 // Find test's function pointer
1577 OurExceptionThrowFunctType functPtr =
1578 reinterpret_cast<OurExceptionThrowFunctType>(
1579 reinterpret_cast<intptr_t>(engine->getPointerToFunction(function)));
1583 (*functPtr)(typeToThrow);
1585 catch (OurCppRunException exc) {
1586 // Catch foreign C++ exception
1588 "\nrunExceptionThrow(...):In C++ catch OurCppRunException "
1589 "with reason: %s.\n",
1593 // Catch all exceptions including our generated ones. This latter
1594 // functionality works according to the example in rules 1.6.4 of
1595 // http://sourcery.mentor.com/public/cxx-abi/abi-eh.html (v1.22),
1596 // given that these will be exceptions foreign to C++
1597 // (the _Unwind_Exception::exception_class should be different from
1598 // the one used by C++).
1600 "\nrunExceptionThrow(...):In C++ catch all.\n");
1605 // End test functions
1608 typedef llvm::ArrayRef<llvm::Type*> TypeArray;
1610 /// This initialization routine creates type info globals and
1611 /// adds external function declarations to module.
1612 /// @param numTypeInfos number of linear type info associated type info types
1613 /// to create as GlobalVariable instances, starting with the value 1.
1614 /// @param module code for module instance
1615 /// @param builder builder instance
1616 static void createStandardUtilityFunctions(unsigned numTypeInfos,
1617 llvm::Module &module,
1618 llvm::IRBuilder<> &builder) {
1620 llvm::LLVMContext &context = module.getContext();
1622 // Exception initializations
1624 // Setup exception catch state
1625 ourExceptionNotThrownState =
1626 llvm::ConstantInt::get(llvm::Type::getInt8Ty(context), 0),
1627 ourExceptionThrownState =
1628 llvm::ConstantInt::get(llvm::Type::getInt8Ty(context), 1),
1629 ourExceptionCaughtState =
1630 llvm::ConstantInt::get(llvm::Type::getInt8Ty(context), 2),
1634 // Create our type info type
1635 ourTypeInfoType = llvm::StructType::get(context,
1636 TypeArray(builder.getInt32Ty()));
1638 llvm::Type *caughtResultFieldTypes[] = {
1639 builder.getInt8PtrTy(),
1640 builder.getInt32Ty()
1643 // Create our landingpad result type
1644 ourCaughtResultType = llvm::StructType::get(context,
1645 TypeArray(caughtResultFieldTypes));
1647 // Create OurException type
1648 ourExceptionType = llvm::StructType::get(context,
1649 TypeArray(ourTypeInfoType));
1651 // Create portion of _Unwind_Exception type
1653 // Note: Declaring only a portion of the _Unwind_Exception struct.
1654 // Does this cause problems?
1655 ourUnwindExceptionType =
1656 llvm::StructType::get(context,
1657 TypeArray(builder.getInt64Ty()));
1659 struct OurBaseException_t dummyException;
1661 // Calculate offset of OurException::unwindException member.
1662 ourBaseFromUnwindOffset = ((uintptr_t) &dummyException) -
1663 ((uintptr_t) &(dummyException.unwindException));
1667 "createStandardUtilityFunctions(...):ourBaseFromUnwindOffset "
1668 "= %lld, sizeof(struct OurBaseException_t) - "
1669 "sizeof(struct _Unwind_Exception) = %lu.\n",
1670 ourBaseFromUnwindOffset,
1671 sizeof(struct OurBaseException_t) -
1672 sizeof(struct _Unwind_Exception));
1675 size_t numChars = sizeof(ourBaseExcpClassChars) / sizeof(char);
1677 // Create our _Unwind_Exception::exception_class value
1678 ourBaseExceptionClass = genClass(ourBaseExcpClassChars, numChars);
1682 std::string baseStr = "typeInfo", typeInfoName;
1683 std::ostringstream typeInfoNameBuilder;
1684 std::vector<llvm::Constant*> structVals;
1686 llvm::Constant *nextStruct;
1688 // Generate each type info
1690 // Note: First type info is not used.
1691 for (unsigned i = 0; i <= numTypeInfos; ++i) {
1693 structVals.push_back(llvm::ConstantInt::get(builder.getInt32Ty(), i));
1694 nextStruct = llvm::ConstantStruct::get(ourTypeInfoType, structVals);
1696 typeInfoNameBuilder.str("");
1697 typeInfoNameBuilder << baseStr << i;
1698 typeInfoName = typeInfoNameBuilder.str();
1700 // Note: Does not seem to work without allocation
1701 new llvm::GlobalVariable(module,
1704 llvm::GlobalValue::ExternalLinkage,
1708 ourTypeInfoNames.push_back(typeInfoName);
1709 ourTypeInfoNamesIndex[i] = typeInfoName;
1714 llvm::Function *funct = NULL;
1718 llvm::Type *retType = builder.getVoidTy();
1721 argTypes.push_back(builder.getInt32Ty());
1722 argTypes.push_back(builder.getInt8PtrTy());
1726 createFunction(module,
1731 llvm::Function::ExternalLinkage,
1737 retType = builder.getVoidTy();
1740 argTypes.push_back(builder.getInt64Ty());
1741 argTypes.push_back(builder.getInt8PtrTy());
1745 createFunction(module,
1750 llvm::Function::ExternalLinkage,
1756 retType = builder.getVoidTy();
1759 argTypes.push_back(builder.getInt8PtrTy());
1763 createFunction(module,
1768 llvm::Function::ExternalLinkage,
1772 // throwCppException
1774 retType = builder.getVoidTy();
1777 argTypes.push_back(builder.getInt32Ty());
1781 createFunction(module,
1785 "throwCppException",
1786 llvm::Function::ExternalLinkage,
1790 // deleteOurException
1792 retType = builder.getVoidTy();
1795 argTypes.push_back(builder.getInt8PtrTy());
1799 createFunction(module,
1803 "deleteOurException",
1804 llvm::Function::ExternalLinkage,
1808 // createOurException
1810 retType = builder.getInt8PtrTy();
1813 argTypes.push_back(builder.getInt32Ty());
1817 createFunction(module,
1821 "createOurException",
1822 llvm::Function::ExternalLinkage,
1826 // _Unwind_RaiseException
1828 retType = builder.getInt32Ty();
1831 argTypes.push_back(builder.getInt8PtrTy());
1835 funct = createFunction(module,
1839 "_Unwind_RaiseException",
1840 llvm::Function::ExternalLinkage,
1844 funct->setDoesNotReturn();
1848 retType = builder.getInt32Ty();
1851 argTypes.push_back(builder.getInt8PtrTy());
1855 funct = createFunction(module,
1860 llvm::Function::ExternalLinkage,
1864 funct->setDoesNotReturn();
1868 retType = builder.getInt32Ty();
1871 argTypes.push_back(builder.getInt32Ty());
1872 argTypes.push_back(builder.getInt32Ty());
1873 argTypes.push_back(builder.getInt64Ty());
1874 argTypes.push_back(builder.getInt8PtrTy());
1875 argTypes.push_back(builder.getInt8PtrTy());
1879 createFunction(module,
1884 llvm::Function::ExternalLinkage,
1888 // llvm.eh.typeid.for intrinsic
1890 getDeclaration(&module, llvm::Intrinsic::eh_typeid_for);
1894 //===----------------------------------------------------------------------===//
1895 // Main test driver code.
1896 //===----------------------------------------------------------------------===//
1898 /// Demo main routine which takes the type info types to throw. A test will
1899 /// be run for each given type info type. While type info types with the value
1900 /// of -1 will trigger a foreign C++ exception to be thrown; type info types
1901 /// <= 6 and >= 1 will be caught by test functions; and type info types > 6
1902 /// will result in exceptions which pass through to the test harness. All other
1903 /// type info types are not supported and could cause a crash.
1904 int main(int argc, char *argv[]) {
1907 "\nUsage: ExceptionDemo <exception type to throw> "
1908 "[<type 2>...<type n>].\n"
1909 " Each type must have the value of 1 - 6 for "
1910 "generated exceptions to be caught;\n"
1911 " the value -1 for foreign C++ exceptions to be "
1912 "generated and thrown;\n"
1913 " or the values > 6 for exceptions to be ignored.\n"
1914 "\nTry: ExceptionDemo 2 3 7 -1\n"
1915 " for a full test.\n\n");
1919 // If not set, exception handling will not be turned on
1920 llvm::TargetOptions Opts;
1921 Opts.JITExceptionHandling = true;
1923 llvm::InitializeNativeTarget();
1924 llvm::LLVMContext &context = llvm::getGlobalContext();
1925 llvm::IRBuilder<> theBuilder(context);
1927 // Make the module, which holds all the code.
1928 llvm::Module *module = new llvm::Module("my cool jit", context);
1930 // Build engine with JIT
1931 llvm::EngineBuilder factory(module);
1932 factory.setEngineKind(llvm::EngineKind::JIT);
1933 factory.setAllocateGVsWithCode(false);
1934 factory.setTargetOptions(Opts);
1935 llvm::ExecutionEngine *executionEngine = factory.create();
1938 llvm::FunctionPassManager fpm(module);
1940 // Set up the optimizer pipeline.
1941 // Start with registering info about how the
1942 // target lays out data structures.
1943 fpm.add(new llvm::DataLayout(*executionEngine->getDataLayout()));
1945 // Optimizations turned on
1946 #ifdef ADD_OPT_PASSES
1948 // Basic AliasAnslysis support for GVN.
1949 fpm.add(llvm::createBasicAliasAnalysisPass());
1951 // Promote allocas to registers.
1952 fpm.add(llvm::createPromoteMemoryToRegisterPass());
1954 // Do simple "peephole" optimizations and bit-twiddling optzns.
1955 fpm.add(llvm::createInstructionCombiningPass());
1957 // Reassociate expressions.
1958 fpm.add(llvm::createReassociatePass());
1960 // Eliminate Common SubExpressions.
1961 fpm.add(llvm::createGVNPass());
1963 // Simplify the control flow graph (deleting unreachable
1965 fpm.add(llvm::createCFGSimplificationPass());
1966 #endif // ADD_OPT_PASSES
1968 fpm.doInitialization();
1970 // Generate test code using function throwCppException(...) as
1971 // the function which throws foreign exceptions.
1972 llvm::Function *toRun =
1973 createUnwindExceptionTest(*module,
1976 "throwCppException");
1978 fprintf(stderr, "\nBegin module dump:\n\n");
1982 fprintf(stderr, "\nEnd module dump:\n");
1984 fprintf(stderr, "\n\nBegin Test:\n");
1986 for (int i = 1; i < argc; ++i) {
1987 // Run test for each argument whose value is the exception
1989 runExceptionThrow(executionEngine,
1991 (unsigned) strtoul(argv[i], NULL, 10));
1994 fprintf(stderr, "\nEnd Test:\n\n");
1997 delete executionEngine;