[ExceptionDemo] Correct and update example ExceptionDemo (llvm#69485)

The ExceptionDemo example was no longer compiling (since llvm 14 at
least). The PR makes the example work with the current API and also
transition from MCJIT to ORC.
Fixes llvm#63702

Author: epitavy

llvm/examples/ExceptionDemo/CMakeLists.txt

@@ -1,9 +1,7 @@
 set(LLVM_LINK_COMPONENTS
   Core
   ExecutionEngine
-  MC
-  MCJIT
-  RuntimeDyld
+  ORCJIT
   Support
   Target
   nativecodegen

llvm/examples/ExceptionDemo/ExceptionDemo.cpp

@@ -49,8 +49,9 @@
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/Dwarf.h"
-#include "llvm/ExecutionEngine/MCJIT.h"
-#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
+#include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"
@@ -84,6 +85,8 @@
 #define USE_GLOBAL_STR_CONSTS true
 #endif
 
+llvm::ExitOnError ExitOnErr;
+
 //
 // Example types
 //
@@ -142,6 +145,7 @@ static llvm::ConstantInt *ourExceptionCaughtState;
 
 typedef std::vector<std::string> ArgNames;
 typedef std::vector<llvm::Type*> ArgTypes;
+typedef llvm::ArrayRef<llvm::Type *> TypeArray;
 
 //
 // Code Generation Utilities
@@ -892,13 +896,10 @@ void generateStringPrint(llvm::LLVMContext &context,
 ///        generated, and is used to hold the constant string. A value of
 ///        false indicates that the constant string will be stored on the
 ///        stack.
-void generateIntegerPrint(llvm::LLVMContext &context,
-                          llvm::Module &module,
+void generateIntegerPrint(llvm::LLVMContext &context, llvm::Module &module,
                           llvm::IRBuilder<> &builder,
-                          llvm::Function &printFunct,
-                          llvm::Value &toPrint,
-                          std::string format,
-                          bool useGlobal = true) {
+                          llvm::Function &printFunct, llvm::Value *toPrint,
+                          std::string format, bool useGlobal = true) {
   llvm::Constant *stringConstant =
     llvm::ConstantDataArray::getString(context, format);
   llvm::Value *stringVar;
@@ -920,10 +921,9 @@ void generateIntegerPrint(llvm::LLVMContext &context,
 
   llvm::Value *cast = builder.CreateBitCast(stringVar,
                                             builder.getPtrTy());
-  builder.CreateCall(&printFunct, {&toPrint, cast});
+  builder.CreateCall(&printFunct, {toPrint, cast});
 }
 
-
 /// Generates code to handle finally block type semantics: always runs
 /// regardless of whether a thrown exception is passing through or the
 /// parent function is simply exiting. In addition to printing some state
@@ -997,10 +997,10 @@ static llvm::BasicBlock *createFinallyBlock(llvm::LLVMContext &context,
                       bufferToPrint.str(),
                       USE_GLOBAL_STR_CONSTS);
 
-  llvm::SwitchInst *theSwitch = builder.CreateSwitch(builder.CreateLoad(
-                                                       *exceptionCaughtFlag),
-                                                     &terminatorBlock,
-                                                     2);
+  llvm::SwitchInst *theSwitch = builder.CreateSwitch(
+      builder.CreateLoad(ourExceptionNotThrownState->getType(),
+                         *exceptionCaughtFlag),
+      &terminatorBlock, 2);
   theSwitch->addCase(ourExceptionCaughtState, &terminatorBlock);
   theSwitch->addCase(ourExceptionThrownState, &unwindResumeBlock);
 
@@ -1186,7 +1186,7 @@ static llvm::Function *createCatchWrappedInvokeFunction(
 
   // Note: function handles NULL exceptions
   builder.CreateCall(deleteOurException,
-                     builder.CreateLoad(exceptionStorage));
+                     builder.CreateLoad(builder.getPtrTy(), exceptionStorage));
   builder.CreateRetVoid();
 
   // Normal Block
@@ -1206,7 +1206,8 @@ static llvm::Function *createCatchWrappedInvokeFunction(
 
   builder.SetInsertPoint(unwindResumeBlock);
 
-  builder.CreateResume(builder.CreateLoad(caughtResultStorage));
+  builder.CreateResume(
+      builder.CreateLoad(ourCaughtResultType, caughtResultStorage));
 
   // Exception Block
 
@@ -1241,8 +1242,9 @@ static llvm::Function *createCatchWrappedInvokeFunction(
   // Retrieve exception_class member from thrown exception
   // (_Unwind_Exception instance). This member tells us whether or not
   // the exception is foreign.
-  llvm::Value *unwindExceptionClass =
-      builder.CreateLoad(builder.CreateStructGEP(
+  llvm::Value *unwindExceptionClass = builder.CreateLoad(
+      builder.getInt64Ty(),
+      builder.CreateStructGEP(
           ourUnwindExceptionType,
           builder.CreatePointerCast(unwindException,
                                     ourUnwindExceptionType->getPointerTo()),
@@ -1278,9 +1280,9 @@ static llvm::Function *createCatchWrappedInvokeFunction(
   //
   // Note: ourBaseFromUnwindOffset is usually negative
   llvm::Value *typeInfoThrown = builder.CreatePointerCast(
-                                  builder.CreateConstGEP1_64(unwindException,
-                                                       ourBaseFromUnwindOffset),
-                                  ourExceptionType->getPointerTo());
+      builder.CreateConstGEP1_64(builder.getPtrTy(), unwindException,
+                                 ourBaseFromUnwindOffset),
+      ourExceptionType->getPointerTo());
 
   // Retrieve thrown exception type info type
   //
@@ -1289,17 +1291,15 @@ static llvm::Function *createCatchWrappedInvokeFunction(
   typeInfoThrown = builder.CreateStructGEP(ourExceptionType, typeInfoThrown, 0);
 
   llvm::Value *typeInfoThrownType =
-      builder.CreateStructGEP(builder.getPtrTy(), typeInfoThrown, 0);
+      builder.CreateStructGEP(ourTypeInfoType, typeInfoThrown, 0);
 
-  generateIntegerPrint(context,
-                       module,
-                       builder,
-                       *toPrint32Int,
-                       *(builder.CreateLoad(typeInfoThrownType)),
+  llvm::Value *ti8 =
+      builder.CreateLoad(builder.getInt8Ty(), typeInfoThrownType);
+  generateIntegerPrint(context, module, builder, *toPrint32Int,
+                       builder.CreateZExt(ti8, builder.getInt32Ty()),
                        "Gen: Exception type <%d> received (stack unwound) "
                        " in " +
-                       ourId +
-                       ".\n",
+                           ourId + ".\n",
                        USE_GLOBAL_STR_CONSTS);
 
   // Route to matched type info catch block or run cleanup finally block
@@ -1311,8 +1311,7 @@ static llvm::Function *createCatchWrappedInvokeFunction(
 
   for (unsigned i = 1; i <= numExceptionsToCatch; ++i) {
     nextTypeToCatch = i - 1;
-    switchToCatchBlock->addCase(llvm::ConstantInt::get(
-                                   llvm::Type::getInt32Ty(context), i),
+    switchToCatchBlock->addCase(llvm::ConstantInt::get(builder.getInt32Ty(), i),
                                 catchBlocks[nextTypeToCatch]);
   }
 
@@ -1387,14 +1386,10 @@ createThrowExceptionFunction(llvm::Module &module, llvm::IRBuilder<> &builder,
   builder.SetInsertPoint(entryBlock);
 
   llvm::Function *toPrint32Int = module.getFunction("print32Int");
-  generateIntegerPrint(context,
-                       module,
-                       builder,
-                       *toPrint32Int,
-                       *exceptionType,
-                       "\nGen: About to throw exception type <%d> in " +
-                       ourId +
-                       ".\n",
+  generateIntegerPrint(context, module, builder, *toPrint32Int,
+                       builder.CreateZExt(exceptionType, builder.getInt32Ty()),
+                       "\nGen: About to throw exception type <%d> in " + ourId +
+                           ".\n",
                        USE_GLOBAL_STR_CONSTS);
 
   // Switches on runtime type info type value to determine whether or not
@@ -1546,15 +1541,13 @@ typedef void (*OurExceptionThrowFunctType) (int32_t typeToThrow);
 /// @param function generated test function to run
 /// @param typeToThrow type info type of generated exception to throw, or
 ///        indicator to cause foreign exception to be thrown.
-static
-void runExceptionThrow(llvm::ExecutionEngine *engine,
-                       llvm::Function *function,
-                       int32_t typeToThrow) {
+static void runExceptionThrow(llvm::orc::LLJIT *JIT, std::string function,
+                              int32_t typeToThrow) {
 
   // Find test's function pointer
   OurExceptionThrowFunctType functPtr =
-    reinterpret_cast<OurExceptionThrowFunctType>(
-       reinterpret_cast<intptr_t>(engine->getPointerToFunction(function)));
+      reinterpret_cast<OurExceptionThrowFunctType>(reinterpret_cast<uintptr_t>(
+          ExitOnErr(JIT->lookup(function)).getValue()));
 
   try {
     // Run test
@@ -1583,8 +1576,6 @@ void runExceptionThrow(llvm::ExecutionEngine *engine,
 // End test functions
 //
 
-typedef llvm::ArrayRef<llvm::Type*> TypeArray;
-
 /// This initialization routine creates type info globals and
 /// adds external function declarations to module.
 /// @param numTypeInfos number of linear type info associated type info types
@@ -1894,93 +1885,73 @@ int main(int argc, char *argv[]) {
     return(0);
   }
 
-  // If not set, exception handling will not be turned on
-  llvm::TargetOptions Opts;
-
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
-  llvm::LLVMContext Context;
-  llvm::IRBuilder<> theBuilder(Context);
+  auto Context = std::make_unique<llvm::LLVMContext>();
+  llvm::IRBuilder<> theBuilder(*Context);
 
   // Make the module, which holds all the code.
   std::unique_ptr<llvm::Module> Owner =
-      std::make_unique<llvm::Module>("my cool jit", Context);
+      std::make_unique<llvm::Module>("my cool jit", *Context);
   llvm::Module *module = Owner.get();
 
-  std::unique_ptr<llvm::RTDyldMemoryManager> MemMgr(new llvm::SectionMemoryManager());
+  // Build LLJIT
+  std::unique_ptr<llvm::orc::LLJIT> JIT =
+      ExitOnErr(llvm::orc::LLJITBuilder().create());
 
-  // Build engine with JIT
-  llvm::EngineBuilder factory(std::move(Owner));
-  factory.setEngineKind(llvm::EngineKind::JIT);
-  factory.setTargetOptions(Opts);
-  factory.setMCJITMemoryManager(std::move(MemMgr));
-  llvm::ExecutionEngine *executionEngine = factory.create();
+  // Set up the optimizer pipeline.
+  llvm::legacy::FunctionPassManager fpm(module);
 
-  {
-    llvm::legacy::FunctionPassManager fpm(module);
-
-    // Set up the optimizer pipeline.
-    // Start with registering info about how the
-    // target lays out data structures.
-    module->setDataLayout(executionEngine->getDataLayout());
-
-    // Optimizations turned on
+  // Optimizations turned on
 #ifdef ADD_OPT_PASSES
 
-    // Basic AliasAnslysis support for GVN.
-    fpm.add(llvm::createBasicAliasAnalysisPass());
+  // Basic AliasAnslysis support for GVN.
+  fpm.add(llvm::createBasicAliasAnalysisPass());
 
-    // Promote allocas to registers.
-    fpm.add(llvm::createPromoteMemoryToRegisterPass());
+  // Promote allocas to registers.
+  fpm.add(llvm::createPromoteMemoryToRegisterPass());
 
-    // Do simple "peephole" optimizations and bit-twiddling optzns.
-    fpm.add(llvm::createInstructionCombiningPass());
+  // Do simple "peephole" optimizations and bit-twiddling optzns.
+  fpm.add(llvm::createInstructionCombiningPass());
 
-    // Reassociate expressions.
-    fpm.add(llvm::createReassociatePass());
+  // Reassociate expressions.
+  fpm.add(llvm::createReassociatePass());
 
-    // Eliminate Common SubExpressions.
-    fpm.add(llvm::createGVNPass());
+  // Eliminate Common SubExpressions.
+  fpm.add(llvm::createGVNPass());
 
-    // Simplify the control flow graph (deleting unreachable
-    // blocks, etc).
-    fpm.add(llvm::createCFGSimplificationPass());
+  // Simplify the control flow graph (deleting unreachable
+  // blocks, etc).
+  fpm.add(llvm::createCFGSimplificationPass());
 #endif  // ADD_OPT_PASSES
 
-    fpm.doInitialization();
+  fpm.doInitialization();
 
-    // Generate test code using function throwCppException(...) as
-    // the function which throws foreign exceptions.
-    llvm::Function *toRun =
-    createUnwindExceptionTest(*module,
-                              theBuilder,
-                              fpm,
-                              "throwCppException");
+  // Generate test code using function throwCppException(...) as
+  // the function which throws foreign exceptions.
+  createUnwindExceptionTest(*module, theBuilder, fpm, "throwCppException");
 
-    executionEngine->finalizeObject();
+  ExitOnErr(JIT->addIRModule(
+      llvm::orc::ThreadSafeModule(std::move(Owner), std::move(Context))));
 
 #ifndef NDEBUG
-    fprintf(stderr, "\nBegin module dump:\n\n");
+  fprintf(stderr, "\nBegin module dump:\n\n");
 
-    module->dump();
+  module->print(llvm::errs(), nullptr);
 
-    fprintf(stderr, "\nEnd module dump:\n");
+  fprintf(stderr, "\nEnd module dump:\n");
 #endif
 
-    fprintf(stderr, "\n\nBegin Test:\n");
-
-    for (int i = 1; i < argc; ++i) {
-      // Run test for each argument whose value is the exception
-      // type to throw.
-      runExceptionThrow(executionEngine,
-                        toRun,
-                        (unsigned) strtoul(argv[i], NULL, 10));
-    }
+  fprintf(stderr, "\n\nBegin Test:\n");
+  std::string toRun = "outerCatchFunct";
 
-    fprintf(stderr, "\nEnd Test:\n\n");
+  for (int i = 1; i < argc; ++i) {
+    // Run test for each argument whose value is the exception
+    // type to throw.
+    runExceptionThrow(JIT.get(), toRun, (unsigned)strtoul(argv[i], NULL, 10));
   }
 
-  delete executionEngine;
+  fprintf(stderr, "\nEnd Test:\n\n");
 
   return 0;
 }