unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp

   1 //===----------- CoreAPIsTest.cpp - Unit tests for Core ORC APIs ----------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "OrcTestCommon.h"
  10 #include "llvm/ExecutionEngine/Orc/Legacy.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14 using namespace llvm::orc;
  15
  16 class LegacyAPIsStandardTest : public CoreAPIsBasedStandardTest {};
  17
  18 namespace {
  19
  20 TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
  21   BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
  22
  23   cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
  24
  25   auto Resolver = createSymbolResolver(
  26       [&](const SymbolNameSet &Symbols) {
  27         auto FlagsMap = JD.lookupFlags(Symbols);
  28         SymbolNameSet Result;
  29         for (auto &KV : FlagsMap)
  30           if (!KV.second.isStrong())
  31             Result.insert(KV.first);
  32         return Result;
  33       },
  34       [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
  35         return JD.legacyLookup(std::move(Q), Symbols);
  36       });
  37
  38   auto RS = Resolver->getResponsibilitySet(SymbolNameSet({Bar, Baz}));
  39
  40   EXPECT_EQ(RS.size(), 1U)
  41       << "getResponsibilitySet returned the wrong number of results";
  42   EXPECT_EQ(RS.count(Bar), 1U)
  43       << "getResponsibilitySet result incorrect. Should be {'bar'}";
  44
  45   bool OnResolvedRun = false;
  46
  47   auto OnResolved = [&](Expected<SymbolMap> Result) {
  48     OnResolvedRun = true;
  49     EXPECT_TRUE(!!Result) << "Unexpected error";
  50     EXPECT_EQ(Result->size(), 2U) << "Unexpected number of resolved symbols";
  51     EXPECT_EQ(Result->count(Foo), 1U) << "Missing lookup result for foo";
  52     EXPECT_EQ(Result->count(Bar), 1U) << "Missing lookup result for bar";
  53     EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
  54         << "Incorrect address for foo";
  55     EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
  56         << "Incorrect address for bar";
  57   };
  58   auto OnReady = [&](Error Err) {
  59     EXPECT_FALSE(!!Err) << "Finalization should never fail in this test";
  60   };
  61
  62   auto Q = std::make_shared<AsynchronousSymbolQuery>(SymbolNameSet({Foo, Bar}),
  63                                                      OnResolved, OnReady);
  64   auto Unresolved =
  65       Resolver->lookup(std::move(Q), SymbolNameSet({Foo, Bar, Baz}));
  66
  67   EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
  68   EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to not be resolved";
  69   EXPECT_TRUE(OnResolvedRun) << "OnResolved was never run";
  70 }
  71
  72 TEST_F(LegacyAPIsStandardTest, LegacyLookupHelpersFn) {
  73   bool BarMaterialized = false;
  74   BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
  75
  76   auto LegacyLookup = [&](const std::string &Name) -> JITSymbol {
  77     if (Name == "foo")
  78       return FooSym;
  79
  80     if (Name == "bar") {
  81       auto BarMaterializer = [&]() -> Expected<JITTargetAddress> {
  82         BarMaterialized = true;
  83         return BarAddr;
  84       };
  85
  86       return {BarMaterializer, BarSym.getFlags()};
  87     }
  88
  89     return nullptr;
  90   };
  91
  92   auto RS =
  93       getResponsibilitySetWithLegacyFn(SymbolNameSet({Bar, Baz}), LegacyLookup);
  94
  95   EXPECT_TRUE(!!RS) << "Expected getResponsibilitySetWithLegacyFn to succeed";
  96   EXPECT_EQ(RS->size(), 1U) << "Wrong number of symbols returned";
  97   EXPECT_EQ(RS->count(Bar), 1U) << "Incorrect responsibility set returned";
  98   EXPECT_FALSE(BarMaterialized)
  99       << "lookupFlags should not have materialized bar";
 100
 101   bool OnResolvedRun = false;
 102   bool OnReadyRun = false;
 103   auto OnResolved = [&](Expected<SymbolMap> Result) {
 104     OnResolvedRun = true;
 105     EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
 106
 107     EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved";
 108     EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
 109     EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
 110     EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
 111     EXPECT_EQ((*Result)[Foo].getFlags(), FooSym.getFlags())
 112         << "Wrong flags for foo";
 113     EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
 114     EXPECT_EQ((*Result)[Bar].getFlags(), BarSym.getFlags())
 115         << "Wrong flags for bar";
 116   };
 117   auto OnReady = [&](Error Err) {
 118     EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
 119     OnReadyRun = true;
 120   };
 121
 122   AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady);
 123   auto Unresolved =
 124       lookupWithLegacyFn(ES, Q, SymbolNameSet({Foo, Bar, Baz}), LegacyLookup);
 125
 126   EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run";
 127   EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
 128   EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
 129   EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved";
 130 }
 131
 132 } // namespace