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://mentorembedded.github.com/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/ADT/STLExtras.h"
52 #include "llvm/IR/Verifier.h"
53 #include "llvm/ExecutionEngine/MCJIT.h"
54 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
55 #include "llvm/IR/DataLayout.h"
56 #include "llvm/IR/DerivedTypes.h"
57 #include "llvm/IR/IRBuilder.h"
58 #include "llvm/IR/Intrinsics.h"
59 #include "llvm/IR/LLVMContext.h"
60 #include "llvm/IR/LegacyPassManager.h"
61 #include "llvm/IR/Module.h"
62 #include "llvm/Support/Dwarf.h"
63 #include "llvm/Support/TargetSelect.h"
64 #include "llvm/Target/TargetOptions.h"
65 #include "llvm/Transforms/Scalar.h"
67 // FIXME: Although all systems tested with (Linux, OS X), do not need this
68 // header file included. A user on ubuntu reported, undefined symbols
69 // for stderr, and fprintf, and the addition of this include fixed the
70 // issue for them. Given that LLVM's best practices include the goal
71 // of reducing the number of redundant header files included, the
72 // correct solution would be to find out why these symbols are not
73 // defined for the system in question, and fix the issue by finding out
74 // which LLVM header file, if any, would include these symbols.
82 #ifndef USE_GLOBAL_STR_CONSTS
83 #define USE_GLOBAL_STR_CONSTS true
86 // System C++ ABI unwind types from:
87 // http://mentorembedded.github.com/cxx-abi/abi-eh.html (v1.22)
93 _URC_FOREIGN_EXCEPTION_CAUGHT
= 1,
94 _URC_FATAL_PHASE2_ERROR
= 2,
95 _URC_FATAL_PHASE1_ERROR
= 3,
97 _URC_END_OF_STACK
= 5,
98 _URC_HANDLER_FOUND
= 6,
99 _URC_INSTALL_CONTEXT
= 7,
100 _URC_CONTINUE_UNWIND
= 8
101 } _Unwind_Reason_Code
;
104 _UA_SEARCH_PHASE
= 1,
105 _UA_CLEANUP_PHASE
= 2,
106 _UA_HANDLER_FRAME
= 4,
107 _UA_FORCE_UNWIND
= 8,
108 _UA_END_OF_STACK
= 16
111 struct _Unwind_Exception
;
113 typedef void (*_Unwind_Exception_Cleanup_Fn
) (_Unwind_Reason_Code
,
114 struct _Unwind_Exception
*);
116 struct _Unwind_Exception
{
117 uint64_t exception_class
;
118 _Unwind_Exception_Cleanup_Fn exception_cleanup
;
123 // @@@ The IA-64 ABI says that this structure must be double-word aligned.
124 // Taking that literally does not make much sense generically. Instead
125 // we provide the maximum alignment required by any type for the machine.
126 } __attribute__((__aligned__
));
128 struct _Unwind_Context
;
129 typedef struct _Unwind_Context
*_Unwind_Context_t
;
131 extern const uint8_t *_Unwind_GetLanguageSpecificData (_Unwind_Context_t c
);
132 extern uintptr_t _Unwind_GetGR (_Unwind_Context_t c
, int i
);
133 extern void _Unwind_SetGR (_Unwind_Context_t c
, int i
, uintptr_t n
);
134 extern void _Unwind_SetIP (_Unwind_Context_t
, uintptr_t new_value
);
135 extern uintptr_t _Unwind_GetIP (_Unwind_Context_t context
);
136 extern uintptr_t _Unwind_GetRegionStart (_Unwind_Context_t context
);
144 /// This is our simplistic type info
145 struct OurExceptionType_t
{
151 /// This is our Exception class which relies on a negative offset to calculate
152 /// pointers to its instances from pointers to its unwindException member.
154 /// Note: The above unwind.h defines struct _Unwind_Exception to be aligned
155 /// on a double word boundary. This is necessary to match the standard:
156 /// http://mentorembedded.github.com/cxx-abi/abi-eh.html
157 struct OurBaseException_t
{
158 struct OurExceptionType_t type
;
160 // Note: This is properly aligned in unwind.h
161 struct _Unwind_Exception unwindException
;
165 // Note: Not needed since we are C++
166 typedef struct OurBaseException_t OurException
;
167 typedef struct _Unwind_Exception OurUnwindException
;
170 // Various globals used to support typeinfo and generatted exceptions in
174 static std::map
<std::string
, llvm::Value
*> namedValues
;
176 int64_t ourBaseFromUnwindOffset
;
178 const unsigned char ourBaseExcpClassChars
[] =
179 {'o', 'b', 'j', '\0', 'b', 'a', 's', '\0'};
182 static uint64_t ourBaseExceptionClass
= 0;
184 static std::vector
<std::string
> ourTypeInfoNames
;
185 static std::map
<int, std::string
> ourTypeInfoNamesIndex
;
187 static llvm::StructType
*ourTypeInfoType
;
188 static llvm::StructType
*ourCaughtResultType
;
189 static llvm::StructType
*ourExceptionType
;
190 static llvm::StructType
*ourUnwindExceptionType
;
192 static llvm::ConstantInt
*ourExceptionNotThrownState
;
193 static llvm::ConstantInt
*ourExceptionThrownState
;
194 static llvm::ConstantInt
*ourExceptionCaughtState
;
196 typedef std::vector
<std::string
> ArgNames
;
197 typedef std::vector
<llvm::Type
*> ArgTypes
;
200 // Code Generation Utilities
203 /// Utility used to create a function, both declarations and definitions
204 /// @param module for module instance
205 /// @param retType function return type
206 /// @param theArgTypes function's ordered argument types
207 /// @param theArgNames function's ordered arguments needed if use of this
208 /// function corresponds to a function definition. Use empty
209 /// aggregate for function declarations.
210 /// @param functName function name
211 /// @param linkage function linkage
212 /// @param declarationOnly for function declarations
213 /// @param isVarArg function uses vararg arguments
214 /// @returns function instance
215 llvm::Function
*createFunction(llvm::Module
&module
,
217 const ArgTypes
&theArgTypes
,
218 const ArgNames
&theArgNames
,
219 const std::string
&functName
,
220 llvm::GlobalValue::LinkageTypes linkage
,
221 bool declarationOnly
,
223 llvm::FunctionType
*functType
=
224 llvm::FunctionType::get(retType
, theArgTypes
, isVarArg
);
225 llvm::Function
*ret
=
226 llvm::Function::Create(functType
, linkage
, functName
, &module
);
227 if (!ret
|| declarationOnly
)
232 for (llvm::Function::arg_iterator argIndex
= ret
->arg_begin();
233 i
!= theArgNames
.size();
236 argIndex
->setName(theArgNames
[i
]);
237 namedValues
[theArgNames
[i
]] = argIndex
;
244 /// Create an alloca instruction in the entry block of
245 /// the parent function. This is used for mutable variables etc.
246 /// @param function parent instance
247 /// @param varName stack variable name
248 /// @param type stack variable type
249 /// @param initWith optional constant initialization value
250 /// @returns AllocaInst instance
251 static llvm::AllocaInst
*createEntryBlockAlloca(llvm::Function
&function
,
252 const std::string
&varName
,
254 llvm::Constant
*initWith
= 0) {
255 llvm::BasicBlock
&block
= function
.getEntryBlock();
256 llvm::IRBuilder
<> tmp(&block
, block
.begin());
257 llvm::AllocaInst
*ret
= tmp
.CreateAlloca(type
, 0, varName
.c_str());
260 tmp
.CreateStore(initWith
, ret
);
267 // Code Generation Utilities End
271 // Runtime C Library functions
274 // Note: using an extern "C" block so that static functions can be used
277 // Note: Better ways to decide on bit width
279 /// Prints a 32 bit number, according to the format, to stderr.
280 /// @param intToPrint integer to print
281 /// @param format printf like format to use when printing
282 void print32Int(int intToPrint
, const char *format
) {
284 // Note: No NULL check
285 fprintf(stderr
, format
, intToPrint
);
288 // Note: No NULL check
289 fprintf(stderr
, "::print32Int(...):NULL arg.\n");
294 // Note: Better ways to decide on bit width
296 /// Prints a 64 bit number, according to the format, to stderr.
297 /// @param intToPrint integer to print
298 /// @param format printf like format to use when printing
299 void print64Int(long int intToPrint
, const char *format
) {
301 // Note: No NULL check
302 fprintf(stderr
, format
, intToPrint
);
305 // Note: No NULL check
306 fprintf(stderr
, "::print64Int(...):NULL arg.\n");
311 /// Prints a C string to stderr
312 /// @param toPrint string to print
313 void printStr(char *toPrint
) {
315 fprintf(stderr
, "%s", toPrint
);
318 fprintf(stderr
, "::printStr(...):NULL arg.\n");
323 /// Deletes the true previously allocated exception whose address
324 /// is calculated from the supplied OurBaseException_t::unwindException
325 /// member address. Handles (ignores), NULL pointers.
326 /// @param expToDelete exception to delete
327 void deleteOurException(OurUnwindException
*expToDelete
) {
330 "deleteOurException(...).\n");
334 (expToDelete
->exception_class
== ourBaseExceptionClass
)) {
336 free(((char*) expToDelete
) + ourBaseFromUnwindOffset
);
341 /// This function is the struct _Unwind_Exception API mandated delete function
342 /// used by foreign exception handlers when deleting our exception
343 /// (OurException), instances.
344 /// @param reason See @link http://mentorembedded.github.com/cxx-abi/abi-eh.html
346 /// @param expToDelete exception instance to delete
347 void deleteFromUnwindOurException(_Unwind_Reason_Code reason
,
348 OurUnwindException
*expToDelete
) {
351 "deleteFromUnwindOurException(...).\n");
354 deleteOurException(expToDelete
);
358 /// Creates (allocates on the heap), an exception (OurException instance),
359 /// of the supplied type info type.
360 /// @param type type info type
361 OurUnwindException
*createOurException(int type
) {
362 size_t size
= sizeof(OurException
);
363 OurException
*ret
= (OurException
*) memset(malloc(size
), 0, size
);
364 (ret
->type
).type
= type
;
365 (ret
->unwindException
).exception_class
= ourBaseExceptionClass
;
366 (ret
->unwindException
).exception_cleanup
= deleteFromUnwindOurException
;
368 return(&(ret
->unwindException
));
372 /// Read a uleb128 encoded value and advance pointer
373 /// See Variable Length Data in:
374 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
375 /// @param data reference variable holding memory pointer to decode from
376 /// @returns decoded value
377 static uintptr_t readULEB128(const uint8_t **data
) {
378 uintptr_t result
= 0;
381 const uint8_t *p
= *data
;
385 result
|= (byte
& 0x7f) << shift
;
396 /// Read a sleb128 encoded value and advance pointer
397 /// See Variable Length Data in:
398 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
399 /// @param data reference variable holding memory pointer to decode from
400 /// @returns decoded value
401 static uintptr_t readSLEB128(const uint8_t **data
) {
402 uintptr_t result
= 0;
405 const uint8_t *p
= *data
;
409 result
|= (byte
& 0x7f) << shift
;
416 if ((byte
& 0x40) && (shift
< (sizeof(result
) << 3))) {
417 result
|= (~0 << shift
);
423 unsigned getEncodingSize(uint8_t Encoding
) {
424 if (Encoding
== llvm::dwarf::DW_EH_PE_omit
)
427 switch (Encoding
& 0x0F) {
428 case llvm::dwarf::DW_EH_PE_absptr
:
429 return sizeof(uintptr_t);
430 case llvm::dwarf::DW_EH_PE_udata2
:
431 return sizeof(uint16_t);
432 case llvm::dwarf::DW_EH_PE_udata4
:
433 return sizeof(uint32_t);
434 case llvm::dwarf::DW_EH_PE_udata8
:
435 return sizeof(uint64_t);
436 case llvm::dwarf::DW_EH_PE_sdata2
:
437 return sizeof(int16_t);
438 case llvm::dwarf::DW_EH_PE_sdata4
:
439 return sizeof(int32_t);
440 case llvm::dwarf::DW_EH_PE_sdata8
:
441 return sizeof(int64_t);
448 /// Read a pointer encoded value and advance pointer
449 /// See Variable Length Data in:
450 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
451 /// @param data reference variable holding memory pointer to decode from
452 /// @param encoding dwarf encoding type
453 /// @returns decoded value
454 static uintptr_t readEncodedPointer(const uint8_t **data
, uint8_t encoding
) {
455 uintptr_t result
= 0;
456 const uint8_t *p
= *data
;
458 if (encoding
== llvm::dwarf::DW_EH_PE_omit
)
462 switch (encoding
& 0x0F) {
463 case llvm::dwarf::DW_EH_PE_absptr
:
464 result
= *((uintptr_t*)p
);
465 p
+= sizeof(uintptr_t);
467 case llvm::dwarf::DW_EH_PE_uleb128
:
468 result
= readULEB128(&p
);
470 // Note: This case has not been tested
471 case llvm::dwarf::DW_EH_PE_sleb128
:
472 result
= readSLEB128(&p
);
474 case llvm::dwarf::DW_EH_PE_udata2
:
475 result
= *((uint16_t*)p
);
476 p
+= sizeof(uint16_t);
478 case llvm::dwarf::DW_EH_PE_udata4
:
479 result
= *((uint32_t*)p
);
480 p
+= sizeof(uint32_t);
482 case llvm::dwarf::DW_EH_PE_udata8
:
483 result
= *((uint64_t*)p
);
484 p
+= sizeof(uint64_t);
486 case llvm::dwarf::DW_EH_PE_sdata2
:
487 result
= *((int16_t*)p
);
488 p
+= sizeof(int16_t);
490 case llvm::dwarf::DW_EH_PE_sdata4
:
491 result
= *((int32_t*)p
);
492 p
+= sizeof(int32_t);
494 case llvm::dwarf::DW_EH_PE_sdata8
:
495 result
= *((int64_t*)p
);
496 p
+= sizeof(int64_t);
504 // then add relative offset
505 switch (encoding
& 0x70) {
506 case llvm::dwarf::DW_EH_PE_absptr
:
509 case llvm::dwarf::DW_EH_PE_pcrel
:
510 result
+= (uintptr_t)(*data
);
512 case llvm::dwarf::DW_EH_PE_textrel
:
513 case llvm::dwarf::DW_EH_PE_datarel
:
514 case llvm::dwarf::DW_EH_PE_funcrel
:
515 case llvm::dwarf::DW_EH_PE_aligned
:
522 // then apply indirection
523 if (encoding
& llvm::dwarf::DW_EH_PE_indirect
) {
524 result
= *((uintptr_t*)result
);
533 /// Deals with Dwarf actions matching our type infos
534 /// (OurExceptionType_t instances). Returns whether or not a dwarf emitted
535 /// action matches the supplied exception type. If such a match succeeds,
536 /// the resultAction argument will be set with > 0 index value. Only
537 /// corresponding llvm.eh.selector type info arguments, cleanup arguments
538 /// are supported. Filters are not supported.
539 /// See Variable Length Data in:
540 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
541 /// Also see @link http://mentorembedded.github.com/cxx-abi/abi-eh.html @unlink
542 /// @param resultAction reference variable which will be set with result
543 /// @param classInfo our array of type info pointers (to globals)
544 /// @param actionEntry index into above type info array or 0 (clean up).
545 /// We do not support filters.
546 /// @param exceptionClass exception class (_Unwind_Exception::exception_class)
547 /// of thrown exception.
548 /// @param exceptionObject thrown _Unwind_Exception instance.
549 /// @returns whether or not a type info was found. False is returned if only
550 /// a cleanup was found
551 static bool handleActionValue(int64_t *resultAction
,
552 uint8_t TTypeEncoding
,
553 const uint8_t *ClassInfo
,
554 uintptr_t actionEntry
,
555 uint64_t exceptionClass
,
556 struct _Unwind_Exception
*exceptionObject
) {
561 (exceptionClass
!= ourBaseExceptionClass
))
564 struct OurBaseException_t
*excp
= (struct OurBaseException_t
*)
565 (((char*) exceptionObject
) + ourBaseFromUnwindOffset
);
566 struct OurExceptionType_t
*excpType
= &(excp
->type
);
567 int type
= excpType
->type
;
571 "handleActionValue(...): exceptionObject = <%p>, "
573 (void*)exceptionObject
,
577 const uint8_t *actionPos
= (uint8_t*) actionEntry
,
579 int64_t typeOffset
= 0,
582 for (int i
= 0; true; ++i
) {
583 // Each emitted dwarf action corresponds to a 2 tuple of
584 // type info address offset, and action offset to the next
586 typeOffset
= readSLEB128(&actionPos
);
587 tempActionPos
= actionPos
;
588 actionOffset
= readSLEB128(&tempActionPos
);
592 "handleActionValue(...):typeOffset: <%" PRIi64
">, "
593 "actionOffset: <%" PRIi64
">.\n",
597 assert((typeOffset
>= 0) &&
598 "handleActionValue(...):filters are not supported.");
600 // Note: A typeOffset == 0 implies that a cleanup llvm.eh.selector
601 // argument has been matched.
602 if (typeOffset
> 0) {
605 "handleActionValue(...):actionValue <%d> found.\n",
608 unsigned EncSize
= getEncodingSize(TTypeEncoding
);
609 const uint8_t *EntryP
= ClassInfo
- typeOffset
* EncSize
;
610 uintptr_t P
= readEncodedPointer(&EntryP
, TTypeEncoding
);
611 struct OurExceptionType_t
*ThisClassInfo
=
612 reinterpret_cast<struct OurExceptionType_t
*>(P
);
613 if (ThisClassInfo
->type
== type
) {
614 *resultAction
= i
+ 1;
622 "handleActionValue(...):actionValue not found.\n");
627 actionPos
+= actionOffset
;
634 /// Deals with the Language specific data portion of the emitted dwarf code.
635 /// See @link http://mentorembedded.github.com/cxx-abi/abi-eh.html @unlink
636 /// @param version unsupported (ignored), unwind version
637 /// @param lsda language specific data area
638 /// @param _Unwind_Action actions minimally supported unwind stage
639 /// (forced specifically not supported)
640 /// @param exceptionClass exception class (_Unwind_Exception::exception_class)
641 /// of thrown exception.
642 /// @param exceptionObject thrown _Unwind_Exception instance.
643 /// @param context unwind system context
644 /// @returns minimally supported unwinding control indicator
645 static _Unwind_Reason_Code
handleLsda(int version
,
647 _Unwind_Action actions
,
648 uint64_t exceptionClass
,
649 struct _Unwind_Exception
*exceptionObject
,
650 _Unwind_Context_t context
) {
651 _Unwind_Reason_Code ret
= _URC_CONTINUE_UNWIND
;
658 "handleLsda(...):lsda is non-zero.\n");
661 // Get the current instruction pointer and offset it before next
662 // instruction in the current frame which threw the exception.
663 uintptr_t pc
= _Unwind_GetIP(context
)-1;
665 // Get beginning current frame's code (as defined by the
666 // emitted dwarf code)
667 uintptr_t funcStart
= _Unwind_GetRegionStart(context
);
668 uintptr_t pcOffset
= pc
- funcStart
;
669 const uint8_t *ClassInfo
= NULL
;
671 // Note: See JITDwarfEmitter::EmitExceptionTable(...) for corresponding
674 // Parse LSDA header.
675 uint8_t lpStartEncoding
= *lsda
++;
677 if (lpStartEncoding
!= llvm::dwarf::DW_EH_PE_omit
) {
678 readEncodedPointer(&lsda
, lpStartEncoding
);
681 uint8_t ttypeEncoding
= *lsda
++;
682 uintptr_t classInfoOffset
;
684 if (ttypeEncoding
!= llvm::dwarf::DW_EH_PE_omit
) {
685 // Calculate type info locations in emitted dwarf code which
686 // were flagged by type info arguments to llvm.eh.selector
688 classInfoOffset
= readULEB128(&lsda
);
689 ClassInfo
= lsda
+ classInfoOffset
;
692 // Walk call-site table looking for range that
693 // includes current PC.
695 uint8_t callSiteEncoding
= *lsda
++;
696 uint32_t callSiteTableLength
= readULEB128(&lsda
);
697 const uint8_t *callSiteTableStart
= lsda
;
698 const uint8_t *callSiteTableEnd
= callSiteTableStart
+
700 const uint8_t *actionTableStart
= callSiteTableEnd
;
701 const uint8_t *callSitePtr
= callSiteTableStart
;
703 while (callSitePtr
< callSiteTableEnd
) {
704 uintptr_t start
= readEncodedPointer(&callSitePtr
,
706 uintptr_t length
= readEncodedPointer(&callSitePtr
,
708 uintptr_t landingPad
= readEncodedPointer(&callSitePtr
,
711 // Note: Action value
712 uintptr_t actionEntry
= readULEB128(&callSitePtr
);
714 if (exceptionClass
!= ourBaseExceptionClass
) {
715 // We have been notified of a foreign exception being thrown,
716 // and we therefore need to execute cleanup landing pads
720 if (landingPad
== 0) {
723 "handleLsda(...): No landing pad found.\n");
726 continue; // no landing pad for this entry
730 actionEntry
+= ((uintptr_t) actionTableStart
) - 1;
735 "handleLsda(...):No action table found.\n");
739 bool exceptionMatched
= false;
741 if ((start
<= pcOffset
) && (pcOffset
< (start
+ length
))) {
744 "handleLsda(...): Landing pad found.\n");
746 int64_t actionValue
= 0;
749 exceptionMatched
= handleActionValue(&actionValue
,
757 if (!(actions
& _UA_SEARCH_PHASE
)) {
760 "handleLsda(...): installed landing pad "
764 // Found landing pad for the PC.
765 // Set Instruction Pointer to so we re-enter function
766 // at landing pad. The landing pad is created by the
767 // compiler to take two parameters in registers.
768 _Unwind_SetGR(context
,
769 __builtin_eh_return_data_regno(0),
770 (uintptr_t)exceptionObject
);
772 // Note: this virtual register directly corresponds
773 // to the return of the llvm.eh.selector intrinsic
774 if (!actionEntry
|| !exceptionMatched
) {
775 // We indicate cleanup only
776 _Unwind_SetGR(context
,
777 __builtin_eh_return_data_regno(1),
781 // Matched type info index of llvm.eh.selector intrinsic
783 _Unwind_SetGR(context
,
784 __builtin_eh_return_data_regno(1),
788 // To execute landing pad set here
789 _Unwind_SetIP(context
, funcStart
+ landingPad
);
790 ret
= _URC_INSTALL_CONTEXT
;
792 else if (exceptionMatched
) {
795 "handleLsda(...): setting handler found.\n");
797 ret
= _URC_HANDLER_FOUND
;
800 // Note: Only non-clean up handlers are marked as
801 // found. Otherwise the clean up handlers will be
802 // re-found and executed during the clean up
806 "handleLsda(...): cleanup handler found.\n");
818 /// This is the personality function which is embedded (dwarf emitted), in the
819 /// dwarf unwind info block. Again see: JITDwarfEmitter.cpp.
820 /// See @link http://mentorembedded.github.com/cxx-abi/abi-eh.html @unlink
821 /// @param version unsupported (ignored), unwind version
822 /// @param _Unwind_Action actions minimally supported unwind stage
823 /// (forced specifically not supported)
824 /// @param exceptionClass exception class (_Unwind_Exception::exception_class)
825 /// of thrown exception.
826 /// @param exceptionObject thrown _Unwind_Exception instance.
827 /// @param context unwind system context
828 /// @returns minimally supported unwinding control indicator
829 _Unwind_Reason_Code
ourPersonality(int version
,
830 _Unwind_Action actions
,
831 uint64_t exceptionClass
,
832 struct _Unwind_Exception
*exceptionObject
,
833 _Unwind_Context_t context
) {
836 "We are in ourPersonality(...):actions is <%d>.\n",
839 if (actions
& _UA_SEARCH_PHASE
) {
840 fprintf(stderr
, "ourPersonality(...):In search phase.\n");
843 fprintf(stderr
, "ourPersonality(...):In non-search phase.\n");
847 const uint8_t *lsda
= _Unwind_GetLanguageSpecificData(context
);
851 "ourPersonality(...):lsda = <%p>.\n",
855 // The real work of the personality function is captured here
856 return(handleLsda(version
,
865 /// Generates our _Unwind_Exception class from a given character array.
866 /// thereby handling arbitrary lengths (not in standard), and handling
868 /// See @link http://mentorembedded.github.com/cxx-abi/abi-eh.html @unlink
869 /// @param classChars char array to encode. NULL values not checkedf
870 /// @param classCharsSize number of chars in classChars. Value is not checked.
871 /// @returns class value
872 uint64_t genClass(const unsigned char classChars
[], size_t classCharsSize
)
874 uint64_t ret
= classChars
[0];
876 for (unsigned i
= 1; i
< classCharsSize
; ++i
) {
878 ret
+= classChars
[i
];
887 // Runtime C Library functions End
891 // Code generation functions
894 /// Generates code to print given constant string
895 /// @param context llvm context
896 /// @param module code for module instance
897 /// @param builder builder instance
898 /// @param toPrint string to print
899 /// @param useGlobal A value of true (default) indicates a GlobalValue is
900 /// generated, and is used to hold the constant string. A value of
901 /// false indicates that the constant string will be stored on the
903 void generateStringPrint(llvm::LLVMContext
&context
,
904 llvm::Module
&module
,
905 llvm::IRBuilder
<> &builder
,
907 bool useGlobal
= true) {
908 llvm::Function
*printFunct
= module
.getFunction("printStr");
910 llvm::Value
*stringVar
;
911 llvm::Constant
*stringConstant
=
912 llvm::ConstantDataArray::getString(context
, toPrint
);
915 // Note: Does not work without allocation
917 new llvm::GlobalVariable(module
,
918 stringConstant
->getType(),
920 llvm::GlobalValue::PrivateLinkage
,
925 stringVar
= builder
.CreateAlloca(stringConstant
->getType());
926 builder
.CreateStore(stringConstant
, stringVar
);
929 llvm::Value
*cast
= builder
.CreatePointerCast(stringVar
,
930 builder
.getInt8PtrTy());
931 builder
.CreateCall(printFunct
, cast
);
935 /// Generates code to print given runtime integer according to constant
936 /// string format, and a given print function.
937 /// @param context llvm context
938 /// @param module code for module instance
939 /// @param builder builder instance
940 /// @param printFunct function used to "print" integer
941 /// @param toPrint string to print
942 /// @param format printf like formating string for print
943 /// @param useGlobal A value of true (default) indicates a GlobalValue is
944 /// generated, and is used to hold the constant string. A value of
945 /// false indicates that the constant string will be stored on the
947 void generateIntegerPrint(llvm::LLVMContext
&context
,
948 llvm::Module
&module
,
949 llvm::IRBuilder
<> &builder
,
950 llvm::Function
&printFunct
,
951 llvm::Value
&toPrint
,
953 bool useGlobal
= true) {
954 llvm::Constant
*stringConstant
=
955 llvm::ConstantDataArray::getString(context
, format
);
956 llvm::Value
*stringVar
;
959 // Note: Does not seem to work without allocation
961 new llvm::GlobalVariable(module
,
962 stringConstant
->getType(),
964 llvm::GlobalValue::PrivateLinkage
,
969 stringVar
= builder
.CreateAlloca(stringConstant
->getType());
970 builder
.CreateStore(stringConstant
, stringVar
);
973 llvm::Value
*cast
= builder
.CreateBitCast(stringVar
,
974 builder
.getInt8PtrTy());
975 builder
.CreateCall(&printFunct
, {&toPrint
, cast
});
979 /// Generates code to handle finally block type semantics: always runs
980 /// regardless of whether a thrown exception is passing through or the
981 /// parent function is simply exiting. In addition to printing some state
982 /// to stderr, this code will resume the exception handling--runs the
983 /// unwind resume block, if the exception has not been previously caught
984 /// by a catch clause, and will otherwise execute the end block (terminator
985 /// block). In addition this function creates the corresponding function's
986 /// stack storage for the exception pointer and catch flag status.
987 /// @param context llvm context
988 /// @param module code for module instance
989 /// @param builder builder instance
990 /// @param toAddTo parent function to add block to
991 /// @param blockName block name of new "finally" block.
992 /// @param functionId output id used for printing
993 /// @param terminatorBlock terminator "end" block
994 /// @param unwindResumeBlock unwind resume block
995 /// @param exceptionCaughtFlag reference exception caught/thrown status storage
996 /// @param exceptionStorage reference to exception pointer storage
997 /// @param caughtResultStorage reference to landingpad result storage
998 /// @returns newly created block
999 static llvm::BasicBlock
*createFinallyBlock(llvm::LLVMContext
&context
,
1000 llvm::Module
&module
,
1001 llvm::IRBuilder
<> &builder
,
1002 llvm::Function
&toAddTo
,
1003 std::string
&blockName
,
1004 std::string
&functionId
,
1005 llvm::BasicBlock
&terminatorBlock
,
1006 llvm::BasicBlock
&unwindResumeBlock
,
1007 llvm::Value
**exceptionCaughtFlag
,
1008 llvm::Value
**exceptionStorage
,
1009 llvm::Value
**caughtResultStorage
) {
1010 assert(exceptionCaughtFlag
&&
1011 "ExceptionDemo::createFinallyBlock(...):exceptionCaughtFlag "
1013 assert(exceptionStorage
&&
1014 "ExceptionDemo::createFinallyBlock(...):exceptionStorage "
1016 assert(caughtResultStorage
&&
1017 "ExceptionDemo::createFinallyBlock(...):caughtResultStorage "
1020 *exceptionCaughtFlag
= createEntryBlockAlloca(toAddTo
,
1022 ourExceptionNotThrownState
->getType(),
1023 ourExceptionNotThrownState
);
1025 llvm::PointerType
*exceptionStorageType
= builder
.getInt8PtrTy();
1026 *exceptionStorage
= createEntryBlockAlloca(toAddTo
,
1028 exceptionStorageType
,
1029 llvm::ConstantPointerNull::get(
1030 exceptionStorageType
));
1031 *caughtResultStorage
= createEntryBlockAlloca(toAddTo
,
1032 "caughtResultStorage",
1033 ourCaughtResultType
,
1034 llvm::ConstantAggregateZero::get(
1035 ourCaughtResultType
));
1037 llvm::BasicBlock
*ret
= llvm::BasicBlock::Create(context
,
1041 builder
.SetInsertPoint(ret
);
1043 std::ostringstream bufferToPrint
;
1044 bufferToPrint
<< "Gen: Executing finally block "
1045 << blockName
<< " in " << functionId
<< "\n";
1046 generateStringPrint(context
,
1049 bufferToPrint
.str(),
1050 USE_GLOBAL_STR_CONSTS
);
1052 llvm::SwitchInst
*theSwitch
= builder
.CreateSwitch(builder
.CreateLoad(
1053 *exceptionCaughtFlag
),
1056 theSwitch
->addCase(ourExceptionCaughtState
, &terminatorBlock
);
1057 theSwitch
->addCase(ourExceptionThrownState
, &unwindResumeBlock
);
1063 /// Generates catch block semantics which print a string to indicate type of
1064 /// catch executed, sets an exception caught flag, and executes passed in
1065 /// end block (terminator block).
1066 /// @param context llvm context
1067 /// @param module code for module instance
1068 /// @param builder builder instance
1069 /// @param toAddTo parent function to add block to
1070 /// @param blockName block name of new "catch" block.
1071 /// @param functionId output id used for printing
1072 /// @param terminatorBlock terminator "end" block
1073 /// @param exceptionCaughtFlag exception caught/thrown status
1074 /// @returns newly created block
1075 static llvm::BasicBlock
*createCatchBlock(llvm::LLVMContext
&context
,
1076 llvm::Module
&module
,
1077 llvm::IRBuilder
<> &builder
,
1078 llvm::Function
&toAddTo
,
1079 std::string
&blockName
,
1080 std::string
&functionId
,
1081 llvm::BasicBlock
&terminatorBlock
,
1082 llvm::Value
&exceptionCaughtFlag
) {
1084 llvm::BasicBlock
*ret
= llvm::BasicBlock::Create(context
,
1088 builder
.SetInsertPoint(ret
);
1090 std::ostringstream bufferToPrint
;
1091 bufferToPrint
<< "Gen: Executing catch block "
1096 generateStringPrint(context
,
1099 bufferToPrint
.str(),
1100 USE_GLOBAL_STR_CONSTS
);
1101 builder
.CreateStore(ourExceptionCaughtState
, &exceptionCaughtFlag
);
1102 builder
.CreateBr(&terminatorBlock
);
1108 /// Generates a function which invokes a function (toInvoke) and, whose
1109 /// unwind block will "catch" the type info types correspondingly held in the
1110 /// exceptionTypesToCatch argument. If the toInvoke function throws an
1111 /// exception which does not match any type info types contained in
1112 /// exceptionTypesToCatch, the generated code will call _Unwind_Resume
1113 /// with the raised exception. On the other hand the generated code will
1114 /// normally exit if the toInvoke function does not throw an exception.
1115 /// The generated "finally" block is always run regardless of the cause of
1116 /// the generated function exit.
1117 /// The generated function is returned after being verified.
1118 /// @param module code for module instance
1119 /// @param builder builder instance
1120 /// @param fpm a function pass manager holding optional IR to IR
1122 /// @param toInvoke inner function to invoke
1123 /// @param ourId id used to printing purposes
1124 /// @param numExceptionsToCatch length of exceptionTypesToCatch array
1125 /// @param exceptionTypesToCatch array of type info types to "catch"
1126 /// @returns generated function
1127 static llvm::Function
*createCatchWrappedInvokeFunction(
1128 llvm::Module
&module
, llvm::IRBuilder
<> &builder
,
1129 llvm::legacy::FunctionPassManager
&fpm
, llvm::Function
&toInvoke
,
1130 std::string ourId
, unsigned numExceptionsToCatch
,
1131 unsigned exceptionTypesToCatch
[]) {
1133 llvm::LLVMContext
&context
= module
.getContext();
1134 llvm::Function
*toPrint32Int
= module
.getFunction("print32Int");
1137 argTypes
.push_back(builder
.getInt32Ty());
1140 argNames
.push_back("exceptTypeToThrow");
1142 llvm::Function
*ret
= createFunction(module
,
1143 builder
.getVoidTy(),
1147 llvm::Function::ExternalLinkage
,
1151 // Block which calls invoke
1152 llvm::BasicBlock
*entryBlock
= llvm::BasicBlock::Create(context
,
1155 // Normal block for invoke
1156 llvm::BasicBlock
*normalBlock
= llvm::BasicBlock::Create(context
,
1159 // Unwind block for invoke
1160 llvm::BasicBlock
*exceptionBlock
= llvm::BasicBlock::Create(context
,
1164 // Block which routes exception to correct catch handler block
1165 llvm::BasicBlock
*exceptionRouteBlock
= llvm::BasicBlock::Create(context
,
1169 // Foreign exception handler
1170 llvm::BasicBlock
*externalExceptionBlock
= llvm::BasicBlock::Create(context
,
1171 "externalException",
1174 // Block which calls _Unwind_Resume
1175 llvm::BasicBlock
*unwindResumeBlock
= llvm::BasicBlock::Create(context
,
1179 // Clean up block which delete exception if needed
1180 llvm::BasicBlock
*endBlock
= llvm::BasicBlock::Create(context
, "end", ret
);
1182 std::string nextName
;
1183 std::vector
<llvm::BasicBlock
*> catchBlocks(numExceptionsToCatch
);
1184 llvm::Value
*exceptionCaughtFlag
= NULL
;
1185 llvm::Value
*exceptionStorage
= NULL
;
1186 llvm::Value
*caughtResultStorage
= NULL
;
1188 // Finally block which will branch to unwindResumeBlock if
1189 // exception is not caught. Initializes/allocates stack locations.
1190 llvm::BasicBlock
*finallyBlock
= createFinallyBlock(context
,
1194 nextName
= "finally",
1198 &exceptionCaughtFlag
,
1200 &caughtResultStorage
1203 for (unsigned i
= 0; i
< numExceptionsToCatch
; ++i
) {
1204 nextName
= ourTypeInfoNames
[exceptionTypesToCatch
[i
]];
1206 // One catch block per type info to be caught
1207 catchBlocks
[i
] = createCatchBlock(context
,
1214 *exceptionCaughtFlag
);
1219 builder
.SetInsertPoint(entryBlock
);
1221 std::vector
<llvm::Value
*> args
;
1222 args
.push_back(namedValues
["exceptTypeToThrow"]);
1223 builder
.CreateInvoke(&toInvoke
,
1230 builder
.SetInsertPoint(endBlock
);
1232 generateStringPrint(context
,
1235 "Gen: In end block: exiting in " + ourId
+ ".\n",
1236 USE_GLOBAL_STR_CONSTS
);
1237 llvm::Function
*deleteOurException
= module
.getFunction("deleteOurException");
1239 // Note: function handles NULL exceptions
1240 builder
.CreateCall(deleteOurException
,
1241 builder
.CreateLoad(exceptionStorage
));
1242 builder
.CreateRetVoid();
1246 builder
.SetInsertPoint(normalBlock
);
1248 generateStringPrint(context
,
1251 "Gen: No exception in " + ourId
+ "!\n",
1252 USE_GLOBAL_STR_CONSTS
);
1254 // Finally block is always called
1255 builder
.CreateBr(finallyBlock
);
1257 // Unwind Resume Block
1259 builder
.SetInsertPoint(unwindResumeBlock
);
1261 builder
.CreateResume(builder
.CreateLoad(caughtResultStorage
));
1265 builder
.SetInsertPoint(exceptionBlock
);
1267 llvm::Function
*personality
= module
.getFunction("ourPersonality");
1268 ret
->setPersonalityFn(personality
);
1270 llvm::LandingPadInst
*caughtResult
=
1271 builder
.CreateLandingPad(ourCaughtResultType
,
1272 numExceptionsToCatch
,
1275 caughtResult
->setCleanup(true);
1277 for (unsigned i
= 0; i
< numExceptionsToCatch
; ++i
) {
1278 // Set up type infos to be caught
1279 caughtResult
->addClause(module
.getGlobalVariable(
1280 ourTypeInfoNames
[exceptionTypesToCatch
[i
]]));
1283 llvm::Value
*unwindException
= builder
.CreateExtractValue(caughtResult
, 0);
1284 llvm::Value
*retTypeInfoIndex
= builder
.CreateExtractValue(caughtResult
, 1);
1286 // FIXME: Redundant storage which, beyond utilizing value of
1287 // caughtResultStore for unwindException storage, may be alleviated
1288 // altogether with a block rearrangement
1289 builder
.CreateStore(caughtResult
, caughtResultStorage
);
1290 builder
.CreateStore(unwindException
, exceptionStorage
);
1291 builder
.CreateStore(ourExceptionThrownState
, exceptionCaughtFlag
);
1293 // Retrieve exception_class member from thrown exception
1294 // (_Unwind_Exception instance). This member tells us whether or not
1295 // the exception is foreign.
1296 llvm::Value
*unwindExceptionClass
=
1297 builder
.CreateLoad(builder
.CreateStructGEP(
1298 ourUnwindExceptionType
,
1299 builder
.CreatePointerCast(unwindException
,
1300 ourUnwindExceptionType
->getPointerTo()),
1303 // Branch to the externalExceptionBlock if the exception is foreign or
1304 // to a catch router if not. Either way the finally block will be run.
1305 builder
.CreateCondBr(builder
.CreateICmpEQ(unwindExceptionClass
,
1306 llvm::ConstantInt::get(builder
.getInt64Ty(),
1307 ourBaseExceptionClass
)),
1308 exceptionRouteBlock
,
1309 externalExceptionBlock
);
1311 // External Exception Block
1313 builder
.SetInsertPoint(externalExceptionBlock
);
1315 generateStringPrint(context
,
1318 "Gen: Foreign exception received.\n",
1319 USE_GLOBAL_STR_CONSTS
);
1321 // Branch to the finally block
1322 builder
.CreateBr(finallyBlock
);
1324 // Exception Route Block
1326 builder
.SetInsertPoint(exceptionRouteBlock
);
1328 // Casts exception pointer (_Unwind_Exception instance) to parent
1329 // (OurException instance).
1331 // Note: ourBaseFromUnwindOffset is usually negative
1332 llvm::Value
*typeInfoThrown
= builder
.CreatePointerCast(
1333 builder
.CreateConstGEP1_64(unwindException
,
1334 ourBaseFromUnwindOffset
),
1335 ourExceptionType
->getPointerTo());
1337 // Retrieve thrown exception type info type
1339 // Note: Index is not relative to pointer but instead to structure
1340 // unlike a true getelementptr (GEP) instruction
1341 typeInfoThrown
= builder
.CreateStructGEP(ourExceptionType
, typeInfoThrown
, 0);
1343 llvm::Value
*typeInfoThrownType
=
1344 builder
.CreateStructGEP(builder
.getInt8PtrTy(), typeInfoThrown
, 0);
1346 generateIntegerPrint(context
,
1350 *(builder
.CreateLoad(typeInfoThrownType
)),
1351 "Gen: Exception type <%d> received (stack unwound) "
1355 USE_GLOBAL_STR_CONSTS
);
1357 // Route to matched type info catch block or run cleanup finally block
1358 llvm::SwitchInst
*switchToCatchBlock
= builder
.CreateSwitch(retTypeInfoIndex
,
1360 numExceptionsToCatch
);
1362 unsigned nextTypeToCatch
;
1364 for (unsigned i
= 1; i
<= numExceptionsToCatch
; ++i
) {
1365 nextTypeToCatch
= i
- 1;
1366 switchToCatchBlock
->addCase(llvm::ConstantInt::get(
1367 llvm::Type::getInt32Ty(context
), i
),
1368 catchBlocks
[nextTypeToCatch
]);
1371 llvm::verifyFunction(*ret
);
1378 /// Generates function which throws either an exception matched to a runtime
1379 /// determined type info type (argument to generated function), or if this
1380 /// runtime value matches nativeThrowType, throws a foreign exception by
1381 /// calling nativeThrowFunct.
1382 /// @param module code for module instance
1383 /// @param builder builder instance
1384 /// @param fpm a function pass manager holding optional IR to IR
1386 /// @param ourId id used to printing purposes
1387 /// @param nativeThrowType a runtime argument of this value results in
1388 /// nativeThrowFunct being called to generate/throw exception.
1389 /// @param nativeThrowFunct function which will throw a foreign exception
1390 /// if the above nativeThrowType matches generated function's arg.
1391 /// @returns generated function
1392 static llvm::Function
*
1393 createThrowExceptionFunction(llvm::Module
&module
, llvm::IRBuilder
<> &builder
,
1394 llvm::legacy::FunctionPassManager
&fpm
,
1395 std::string ourId
, int32_t nativeThrowType
,
1396 llvm::Function
&nativeThrowFunct
) {
1397 llvm::LLVMContext
&context
= module
.getContext();
1398 namedValues
.clear();
1399 ArgTypes unwindArgTypes
;
1400 unwindArgTypes
.push_back(builder
.getInt32Ty());
1401 ArgNames unwindArgNames
;
1402 unwindArgNames
.push_back("exceptTypeToThrow");
1404 llvm::Function
*ret
= createFunction(module
,
1405 builder
.getVoidTy(),
1409 llvm::Function::ExternalLinkage
,
1413 // Throws either one of our exception or a native C++ exception depending
1414 // on a runtime argument value containing a type info type.
1415 llvm::BasicBlock
*entryBlock
= llvm::BasicBlock::Create(context
,
1418 // Throws a foreign exception
1419 llvm::BasicBlock
*nativeThrowBlock
= llvm::BasicBlock::Create(context
,
1422 // Throws one of our Exceptions
1423 llvm::BasicBlock
*generatedThrowBlock
= llvm::BasicBlock::Create(context
,
1426 // Retrieved runtime type info type to throw
1427 llvm::Value
*exceptionType
= namedValues
["exceptTypeToThrow"];
1429 // nativeThrowBlock block
1431 builder
.SetInsertPoint(nativeThrowBlock
);
1433 // Throws foreign exception
1434 builder
.CreateCall(&nativeThrowFunct
, exceptionType
);
1435 builder
.CreateUnreachable();
1439 builder
.SetInsertPoint(entryBlock
);
1441 llvm::Function
*toPrint32Int
= module
.getFunction("print32Int");
1442 generateIntegerPrint(context
,
1447 "\nGen: About to throw exception type <%d> in " +
1450 USE_GLOBAL_STR_CONSTS
);
1452 // Switches on runtime type info type value to determine whether or not
1453 // a foreign exception is thrown. Defaults to throwing one of our
1454 // generated exceptions.
1455 llvm::SwitchInst
*theSwitch
= builder
.CreateSwitch(exceptionType
,
1456 generatedThrowBlock
,
1459 theSwitch
->addCase(llvm::ConstantInt::get(llvm::Type::getInt32Ty(context
),
1463 // generatedThrow block
1465 builder
.SetInsertPoint(generatedThrowBlock
);
1467 llvm::Function
*createOurException
= module
.getFunction("createOurException");
1468 llvm::Function
*raiseOurException
= module
.getFunction(
1469 "_Unwind_RaiseException");
1471 // Creates exception to throw with runtime type info type.
1472 llvm::Value
*exception
= builder
.CreateCall(createOurException
,
1473 namedValues
["exceptTypeToThrow"]);
1475 // Throw generated Exception
1476 builder
.CreateCall(raiseOurException
, exception
);
1477 builder
.CreateUnreachable();
1479 llvm::verifyFunction(*ret
);
1485 static void createStandardUtilityFunctions(unsigned numTypeInfos
,
1486 llvm::Module
&module
,
1487 llvm::IRBuilder
<> &builder
);
1489 /// Creates test code by generating and organizing these functions into the
1490 /// test case. The test case consists of an outer function setup to invoke
1491 /// an inner function within an environment having multiple catch and single
1492 /// finally blocks. This inner function is also setup to invoke a throw
1493 /// function within an evironment similar in nature to the outer function's
1494 /// catch and finally blocks. Each of these two functions catch mutually
1495 /// exclusive subsets (even or odd) of the type info types configured
1496 /// for this this. All generated functions have a runtime argument which
1497 /// holds a type info type to throw that each function takes and passes it
1498 /// to the inner one if such a inner function exists. This type info type is
1499 /// looked at by the generated throw function to see whether or not it should
1500 /// throw a generated exception with the same type info type, or instead call
1501 /// a supplied a function which in turn will throw a foreign exception.
1502 /// @param module code for module instance
1503 /// @param builder builder instance
1504 /// @param fpm a function pass manager holding optional IR to IR
1506 /// @param nativeThrowFunctName name of external function which will throw
1507 /// a foreign exception
1508 /// @returns outermost generated test function.
1510 createUnwindExceptionTest(llvm::Module
&module
, llvm::IRBuilder
<> &builder
,
1511 llvm::legacy::FunctionPassManager
&fpm
,
1512 std::string nativeThrowFunctName
) {
1513 // Number of type infos to generate
1514 unsigned numTypeInfos
= 6;
1516 // Initialze intrisics and external functions to use along with exception
1517 // and type info globals.
1518 createStandardUtilityFunctions(numTypeInfos
,
1521 llvm::Function
*nativeThrowFunct
= module
.getFunction(nativeThrowFunctName
);
1523 // Create exception throw function using the value ~0 to cause
1524 // foreign exceptions to be thrown.
1525 llvm::Function
*throwFunct
= createThrowExceptionFunction(module
,
1531 // Inner function will catch even type infos
1532 unsigned innerExceptionTypesToCatch
[] = {6, 2, 4};
1533 size_t numExceptionTypesToCatch
= sizeof(innerExceptionTypesToCatch
) /
1536 // Generate inner function.
1537 llvm::Function
*innerCatchFunct
= createCatchWrappedInvokeFunction(module
,
1542 numExceptionTypesToCatch
,
1543 innerExceptionTypesToCatch
);
1545 // Outer function will catch odd type infos
1546 unsigned outerExceptionTypesToCatch
[] = {3, 1, 5};
1547 numExceptionTypesToCatch
= sizeof(outerExceptionTypesToCatch
) /
1550 // Generate outer function
1551 llvm::Function
*outerCatchFunct
= createCatchWrappedInvokeFunction(module
,
1556 numExceptionTypesToCatch
,
1557 outerExceptionTypesToCatch
);
1559 // Return outer function to run
1560 return(outerCatchFunct
);
1564 /// Represents our foreign exceptions
1565 class OurCppRunException
: public std::runtime_error
{
1567 OurCppRunException(const std::string reason
) :
1568 std::runtime_error(reason
) {}
1570 OurCppRunException (const OurCppRunException
&toCopy
) :
1571 std::runtime_error(toCopy
) {}
1573 OurCppRunException
&operator = (const OurCppRunException
&toCopy
) {
1574 return(reinterpret_cast<OurCppRunException
&>(
1575 std::runtime_error::operator=(toCopy
)));
1578 ~OurCppRunException(void) throw() override
{}
1580 } // end anonymous namespace
1582 /// Throws foreign C++ exception.
1583 /// @param ignoreIt unused parameter that allows function to match implied
1584 /// generated function contract.
1586 void throwCppException (int32_t ignoreIt
) {
1587 throw(OurCppRunException("thrown by throwCppException(...)"));
1590 typedef void (*OurExceptionThrowFunctType
) (int32_t typeToThrow
);
1592 /// This is a test harness which runs test by executing generated
1593 /// function with a type info type to throw. Harness wraps the execution
1594 /// of generated function in a C++ try catch clause.
1595 /// @param engine execution engine to use for executing generated function.
1596 /// This demo program expects this to be a JIT instance for demo
1598 /// @param function generated test function to run
1599 /// @param typeToThrow type info type of generated exception to throw, or
1600 /// indicator to cause foreign exception to be thrown.
1602 void runExceptionThrow(llvm::ExecutionEngine
*engine
,
1603 llvm::Function
*function
,
1604 int32_t typeToThrow
) {
1606 // Find test's function pointer
1607 OurExceptionThrowFunctType functPtr
=
1608 reinterpret_cast<OurExceptionThrowFunctType
>(
1609 reinterpret_cast<intptr_t>(engine
->getPointerToFunction(function
)));
1613 (*functPtr
)(typeToThrow
);
1615 catch (OurCppRunException exc
) {
1616 // Catch foreign C++ exception
1618 "\nrunExceptionThrow(...):In C++ catch OurCppRunException "
1619 "with reason: %s.\n",
1623 // Catch all exceptions including our generated ones. This latter
1624 // functionality works according to the example in rules 1.6.4 of
1625 // http://mentorembedded.github.com/cxx-abi/abi-eh.html (v1.22),
1626 // given that these will be exceptions foreign to C++
1627 // (the _Unwind_Exception::exception_class should be different from
1628 // the one used by C++).
1630 "\nrunExceptionThrow(...):In C++ catch all.\n");
1635 // End test functions
1638 typedef llvm::ArrayRef
<llvm::Type
*> TypeArray
;
1640 /// This initialization routine creates type info globals and
1641 /// adds external function declarations to module.
1642 /// @param numTypeInfos number of linear type info associated type info types
1643 /// to create as GlobalVariable instances, starting with the value 1.
1644 /// @param module code for module instance
1645 /// @param builder builder instance
1646 static void createStandardUtilityFunctions(unsigned numTypeInfos
,
1647 llvm::Module
&module
,
1648 llvm::IRBuilder
<> &builder
) {
1650 llvm::LLVMContext
&context
= module
.getContext();
1652 // Exception initializations
1654 // Setup exception catch state
1655 ourExceptionNotThrownState
=
1656 llvm::ConstantInt::get(llvm::Type::getInt8Ty(context
), 0),
1657 ourExceptionThrownState
=
1658 llvm::ConstantInt::get(llvm::Type::getInt8Ty(context
), 1),
1659 ourExceptionCaughtState
=
1660 llvm::ConstantInt::get(llvm::Type::getInt8Ty(context
), 2),
1664 // Create our type info type
1665 ourTypeInfoType
= llvm::StructType::get(context
,
1666 TypeArray(builder
.getInt32Ty()));
1668 llvm::Type
*caughtResultFieldTypes
[] = {
1669 builder
.getInt8PtrTy(),
1670 builder
.getInt32Ty()
1673 // Create our landingpad result type
1674 ourCaughtResultType
= llvm::StructType::get(context
,
1675 TypeArray(caughtResultFieldTypes
));
1677 // Create OurException type
1678 ourExceptionType
= llvm::StructType::get(context
,
1679 TypeArray(ourTypeInfoType
));
1681 // Create portion of _Unwind_Exception type
1683 // Note: Declaring only a portion of the _Unwind_Exception struct.
1684 // Does this cause problems?
1685 ourUnwindExceptionType
=
1686 llvm::StructType::get(context
,
1687 TypeArray(builder
.getInt64Ty()));
1689 struct OurBaseException_t dummyException
;
1691 // Calculate offset of OurException::unwindException member.
1692 ourBaseFromUnwindOffset
= ((uintptr_t) &dummyException
) -
1693 ((uintptr_t) &(dummyException
.unwindException
));
1697 "createStandardUtilityFunctions(...):ourBaseFromUnwindOffset "
1698 "= %" PRIi64
", sizeof(struct OurBaseException_t) - "
1699 "sizeof(struct _Unwind_Exception) = %lu.\n",
1700 ourBaseFromUnwindOffset
,
1701 sizeof(struct OurBaseException_t
) -
1702 sizeof(struct _Unwind_Exception
));
1705 size_t numChars
= sizeof(ourBaseExcpClassChars
) / sizeof(char);
1707 // Create our _Unwind_Exception::exception_class value
1708 ourBaseExceptionClass
= genClass(ourBaseExcpClassChars
, numChars
);
1712 std::string baseStr
= "typeInfo", typeInfoName
;
1713 std::ostringstream typeInfoNameBuilder
;
1714 std::vector
<llvm::Constant
*> structVals
;
1716 llvm::Constant
*nextStruct
;
1718 // Generate each type info
1720 // Note: First type info is not used.
1721 for (unsigned i
= 0; i
<= numTypeInfos
; ++i
) {
1723 structVals
.push_back(llvm::ConstantInt::get(builder
.getInt32Ty(), i
));
1724 nextStruct
= llvm::ConstantStruct::get(ourTypeInfoType
, structVals
);
1726 typeInfoNameBuilder
.str("");
1727 typeInfoNameBuilder
<< baseStr
<< i
;
1728 typeInfoName
= typeInfoNameBuilder
.str();
1730 // Note: Does not seem to work without allocation
1731 new llvm::GlobalVariable(module
,
1734 llvm::GlobalValue::ExternalLinkage
,
1738 ourTypeInfoNames
.push_back(typeInfoName
);
1739 ourTypeInfoNamesIndex
[i
] = typeInfoName
;
1744 llvm::Function
*funct
= NULL
;
1748 llvm::Type
*retType
= builder
.getVoidTy();
1751 argTypes
.push_back(builder
.getInt32Ty());
1752 argTypes
.push_back(builder
.getInt8PtrTy());
1756 createFunction(module
,
1761 llvm::Function::ExternalLinkage
,
1767 retType
= builder
.getVoidTy();
1770 argTypes
.push_back(builder
.getInt64Ty());
1771 argTypes
.push_back(builder
.getInt8PtrTy());
1775 createFunction(module
,
1780 llvm::Function::ExternalLinkage
,
1786 retType
= builder
.getVoidTy();
1789 argTypes
.push_back(builder
.getInt8PtrTy());
1793 createFunction(module
,
1798 llvm::Function::ExternalLinkage
,
1802 // throwCppException
1804 retType
= builder
.getVoidTy();
1807 argTypes
.push_back(builder
.getInt32Ty());
1811 createFunction(module
,
1815 "throwCppException",
1816 llvm::Function::ExternalLinkage
,
1820 // deleteOurException
1822 retType
= builder
.getVoidTy();
1825 argTypes
.push_back(builder
.getInt8PtrTy());
1829 createFunction(module
,
1833 "deleteOurException",
1834 llvm::Function::ExternalLinkage
,
1838 // createOurException
1840 retType
= builder
.getInt8PtrTy();
1843 argTypes
.push_back(builder
.getInt32Ty());
1847 createFunction(module
,
1851 "createOurException",
1852 llvm::Function::ExternalLinkage
,
1856 // _Unwind_RaiseException
1858 retType
= builder
.getInt32Ty();
1861 argTypes
.push_back(builder
.getInt8PtrTy());
1865 funct
= createFunction(module
,
1869 "_Unwind_RaiseException",
1870 llvm::Function::ExternalLinkage
,
1874 funct
->setDoesNotReturn();
1878 retType
= builder
.getInt32Ty();
1881 argTypes
.push_back(builder
.getInt8PtrTy());
1885 funct
= createFunction(module
,
1890 llvm::Function::ExternalLinkage
,
1894 funct
->setDoesNotReturn();
1898 retType
= builder
.getInt32Ty();
1901 argTypes
.push_back(builder
.getInt32Ty());
1902 argTypes
.push_back(builder
.getInt32Ty());
1903 argTypes
.push_back(builder
.getInt64Ty());
1904 argTypes
.push_back(builder
.getInt8PtrTy());
1905 argTypes
.push_back(builder
.getInt8PtrTy());
1909 createFunction(module
,
1914 llvm::Function::ExternalLinkage
,
1918 // llvm.eh.typeid.for intrinsic
1920 getDeclaration(&module
, llvm::Intrinsic::eh_typeid_for
);
1924 //===----------------------------------------------------------------------===//
1925 // Main test driver code.
1926 //===----------------------------------------------------------------------===//
1928 /// Demo main routine which takes the type info types to throw. A test will
1929 /// be run for each given type info type. While type info types with the value
1930 /// of -1 will trigger a foreign C++ exception to be thrown; type info types
1931 /// <= 6 and >= 1 will be caught by test functions; and type info types > 6
1932 /// will result in exceptions which pass through to the test harness. All other
1933 /// type info types are not supported and could cause a crash.
1934 int main(int argc
, char *argv
[]) {
1937 "\nUsage: ExceptionDemo <exception type to throw> "
1938 "[<type 2>...<type n>].\n"
1939 " Each type must have the value of 1 - 6 for "
1940 "generated exceptions to be caught;\n"
1941 " the value -1 for foreign C++ exceptions to be "
1942 "generated and thrown;\n"
1943 " or the values > 6 for exceptions to be ignored.\n"
1944 "\nTry: ExceptionDemo 2 3 7 -1\n"
1945 " for a full test.\n\n");
1949 // If not set, exception handling will not be turned on
1950 llvm::TargetOptions Opts
;
1952 llvm::InitializeNativeTarget();
1953 llvm::InitializeNativeTargetAsmPrinter();
1954 llvm::LLVMContext Context
;
1955 llvm::IRBuilder
<> theBuilder(Context
);
1957 // Make the module, which holds all the code.
1958 std::unique_ptr
<llvm::Module
> Owner
=
1959 llvm::make_unique
<llvm::Module
>("my cool jit", Context
);
1960 llvm::Module
*module
= Owner
.get();
1962 std::unique_ptr
<llvm::RTDyldMemoryManager
> MemMgr(new llvm::SectionMemoryManager());
1964 // Build engine with JIT
1965 llvm::EngineBuilder
factory(std::move(Owner
));
1966 factory
.setEngineKind(llvm::EngineKind::JIT
);
1967 factory
.setTargetOptions(Opts
);
1968 factory
.setMCJITMemoryManager(std::move(MemMgr
));
1969 llvm::ExecutionEngine
*executionEngine
= factory
.create();
1972 llvm::legacy::FunctionPassManager
fpm(module
);
1974 // Set up the optimizer pipeline.
1975 // Start with registering info about how the
1976 // target lays out data structures.
1977 module
->setDataLayout(executionEngine
->getDataLayout());
1979 // Optimizations turned on
1980 #ifdef ADD_OPT_PASSES
1982 // Basic AliasAnslysis support for GVN.
1983 fpm
.add(llvm::createBasicAliasAnalysisPass());
1985 // Promote allocas to registers.
1986 fpm
.add(llvm::createPromoteMemoryToRegisterPass());
1988 // Do simple "peephole" optimizations and bit-twiddling optzns.
1989 fpm
.add(llvm::createInstructionCombiningPass());
1991 // Reassociate expressions.
1992 fpm
.add(llvm::createReassociatePass());
1994 // Eliminate Common SubExpressions.
1995 fpm
.add(llvm::createGVNPass());
1997 // Simplify the control flow graph (deleting unreachable
1999 fpm
.add(llvm::createCFGSimplificationPass());
2000 #endif // ADD_OPT_PASSES
2002 fpm
.doInitialization();
2004 // Generate test code using function throwCppException(...) as
2005 // the function which throws foreign exceptions.
2006 llvm::Function
*toRun
=
2007 createUnwindExceptionTest(*module
,
2010 "throwCppException");
2012 executionEngine
->finalizeObject();
2014 fprintf(stderr
, "\nBegin module dump:\n\n");
2018 fprintf(stderr
, "\nEnd module dump:\n");
2020 fprintf(stderr
, "\n\nBegin Test:\n");
2022 for (int i
= 1; i
< argc
; ++i
) {
2023 // Run test for each argument whose value is the exception
2025 runExceptionThrow(executionEngine
,
2027 (unsigned) strtoul(argv
[i
], NULL
, 10));
2030 fprintf(stderr
, "\nEnd Test:\n\n");
2033 delete executionEngine
;