[ORC][C-API] Fix orc on platforms without indirection support.

[anarazel]

Summary

Previously this crashed because a nullptr (returned by
createLocalIndirectStubsManagerBuilder() on platforms without
indirection support) functor was unconditionally invoked.

Fix the tests so JIT and indirection support are treated as separate
capabilities. This should add coverage of basic ORC C-API JIT on a lot
of platforms, and also adds coverage for lazy JIT on AArch64. AArch64
was added in r310938, but the tests separate architecture filter
wasn't adjusted.

https://bugs.llvm.org/show_bug.cgi?id=36896

[lhames]

Thanks for working on this! Your patch looks good to me. Do you have commit
access? If so, please go ahead and commit. If not I can commit on your
behalf.

I'm working on some updates to ORC that will eliminate a lot of the
template types, so in the future we can do this a cleaner way and just have
createIndirectStubsManager() return null on platforms where indirection is
not supported.

• Lang.

[lhames]

Patch applied in r328687.

lib/ExecutionEngine/Orc/IndirectionUtils.cpp

switch (T.getArch()) {
     }
 
   }
 }
 
 std::function<std::unique_ptr<IndirectStubsManager>()>
 createLocalIndirectStubsManagerBuilder(const Triple &T) {
   switch (T.getArch()) {
-    default: return nullptr;
+    default:
+      return [](){
+        return llvm::make_unique<
+                       orc::LocalIndirectStubsManager<orc::OrcGenericABI>>();
+      };
 
     case Triple::aarch64:
       return [](){
         return llvm::make_unique<
                        orc::LocalIndirectStubsManager<orc::OrcAArch64>>();
       };
 
     case Triple::x86:

unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

static LLVMOrcTargetAddress myCompileCallback(LLVMOrcJITStackRef JITStack,
     LLVMOrcSetIndirectStubPointer(JITStack, "foo", MainAddr);
     return MainAddr;
   }
 };
 
 char *OrcCAPIExecutionTest::testFuncName = nullptr;
 
 TEST_F(OrcCAPIExecutionTest, TestEagerIRCompilation) {
-  if (!TM)
+  if (!SupportsJIT)
     return;
 
   LLVMOrcJITStackRef JIT =
     LLVMOrcCreateInstance(wrap(TM.get()));
 
   std::unique_ptr<Module> M = createTestModule(TM->getTargetTriple());
 
   LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
TEST_F(OrcCAPIExecutionTest, TestEagerIRCompilation) {
 
   LLVMOrcRemoveModule(JIT, H);
 
   LLVMOrcDisposeMangledSymbol(testFuncName);
   LLVMOrcDisposeInstance(JIT);
 }
 
 TEST_F(OrcCAPIExecutionTest, TestLazyIRCompilation) {
-  if (!TM)
+  if (!SupportsIndirection)
     return;
 
   LLVMOrcJITStackRef JIT =
     LLVMOrcCreateInstance(wrap(TM.get()));
 
   std::unique_ptr<Module> M = createTestModule(TM->getTargetTriple());
 
   LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
TEST_F(OrcCAPIExecutionTest, TestLazyIRCompilation) {
 
   LLVMOrcRemoveModule(JIT, H);
 
   LLVMOrcDisposeMangledSymbol(testFuncName);
   LLVMOrcDisposeInstance(JIT);
 }
 
 TEST_F(OrcCAPIExecutionTest, TestAddObjectFile) {
-  if (!TM)
+  if (!SupportsJIT)
     return;
 
   auto ObjBuffer = createTestObject();
 
   LLVMOrcJITStackRef JIT =
     LLVMOrcCreateInstance(wrap(TM.get()));
   LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
 
   LLVMOrcModuleHandle H;
   LLVMOrcAddObjectFile(JIT, &H, wrap(ObjBuffer.release()), myResolver, nullptr);
   LLVMOrcTargetAddress MainAddr;
   LLVMOrcGetSymbolAddress(JIT, &MainAddr, "main");
   MainFnTy MainFn = (MainFnTy)MainAddr;
   int Result = MainFn();
   EXPECT_EQ(Result, 42)
     << "Lazily JIT'd code did not return expected result";
 
   LLVMOrcRemoveModule(JIT, H);
 
   LLVMOrcDisposeMangledSymbol(testFuncName);
   LLVMOrcDisposeInstance(JIT);
 }
 
 TEST_F(OrcCAPIExecutionTest, TestDirectCallbacksAPI) {
-  if (!TM)
+  if (!SupportsIndirection)
     return;
 
   LLVMOrcJITStackRef JIT =
     LLVMOrcCreateInstance(wrap(TM.get()));
 
   LLVMOrcGetMangledSymbol(JIT, &testFuncName, "testFunc");
 
   CompileContext C;

unittests/ExecutionEngine/Orc/OrcTestCommon.h

 //===----------------------------------------------------------------------===//
 
 
 #ifndef LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H
 #define LLVM_UNITTESTS_EXECUTIONENGINE_ORC_ORCTESTCOMMON_H
 
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/TypeBuilder.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/TargetRegistry.h"
 #include <memory>
 
 namespace llvm {
 
 class OrcNativeTarget {
 public:
   static void initialize() {
     if (!NativeTargetInitialized) {
OrcExecutionTest() {
 
     // Try to select a TargetMachine for the host.
     TM.reset(EngineBuilder().selectTarget());
 
     if (TM) {
       // If we found a TargetMachine, check that it's one that Orc supports.
       const Triple& TT = TM->getTargetTriple();
 
-      if ((TT.getArch() != Triple::x86_64 && TT.getArch() != Triple::x86) ||
-          TT.isOSWindows())
-        TM = nullptr;
+      // Target can JIT?
+      SupportsJIT = TM->getTarget().hasJIT();
+      // Use ability to create callback manager to detect whether Orc
+      // has indirection support on this platform. This way the test
+      // and Orc code do not get out of sync.
+      SupportsIndirection = !!orc::createLocalCompileCallbackManager(TT, 0);
     }
   };
 
 protected:
   LLVMContext Context;
   std::unique_ptr<TargetMachine> TM;
+  bool SupportsJIT = false;
+  bool SupportsIndirection = false;
 };
 
 class ModuleBuilder {
 public:
   ModuleBuilder(LLVMContext &Context, StringRef Triple,
                 StringRef Name);
 
   template <typename FuncType>

unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp

auto Obj = SimpleCompiler(*TM)(*M);
     cantFail(ObjLayer.emitAndFinalize(K));
     EXPECT_EQ(DebugSectionSeen, true)
       << "Expected debug info section not seen";
     cantFail(ObjLayer.removeObject(K));
   }
 }
 
 TEST_F(RTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
-  if (!TM)
+  if (!SupportsJIT)
     return;
 
   SymbolStringPool SSP;
   ExecutionSession ES(SSP);
 
   auto MM = std::make_shared<SectionMemoryManagerWrapper>();
 
   std::map<orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>> Resolvers;
TEST_F(RTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
 
   // Finalization of module 2 should trigger finalization of module 1.
   // Verify that finalize on SMMW is only called once.
   EXPECT_EQ(MM->FinalizationCount, 1)
       << "Extra call to finalize";
 }
 
 TEST_F(RTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) {
-  if (!TM)
+  if (!SupportsJIT)
     return;
 
   SymbolStringPool SSP;
   ExecutionSession ES(SSP);
 
   auto MM = std::make_shared<SectionMemoryManagerWrapper>();
 
   RTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey K) {