1 //===- LookupAndRecordAddrsTest.cpp - Unit tests for LookupAndRecordAddrs -===// 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 "llvm/ExecutionEngine/Orc/LookupAndRecordAddrs.h" 10 #include "OrcTestCommon.h" 11 #include "llvm/ExecutionEngine/Orc/AbsoluteSymbols.h" 12 #include "llvm/Support/MSVCErrorWorkarounds.h" 13 #include "llvm/Testing/Support/Error.h" 14 15 #include <future> 16 17 using namespace llvm; 18 using namespace llvm::orc; 19 20 class LookupAndRecordAddrsTest : public CoreAPIsBasedStandardTest {}; 21 22 namespace { 23 24 TEST_F(LookupAndRecordAddrsTest, AsyncRequiredSuccess) { 25 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}}))); 26 27 ExecutorAddr ReturnedFooAddr, ReturnedBarAddr; 28 std::promise<MSVCPError> ErrP; 29 30 lookupAndRecordAddrs([&](Error Err) { ErrP.set_value(std::move(Err)); }, ES, 31 LookupKind::Static, makeJITDylibSearchOrder(&JD), 32 {{Foo, &ReturnedFooAddr}, {Bar, &ReturnedBarAddr}}); 33 34 Error Err = ErrP.get_future().get(); 35 36 EXPECT_THAT_ERROR(std::move(Err), Succeeded()); 37 EXPECT_EQ(ReturnedFooAddr, FooAddr); 38 EXPECT_EQ(ReturnedBarAddr, BarAddr); 39 } 40 41 TEST_F(LookupAndRecordAddrsTest, AsyncRequiredFailure) { 42 ExecutorAddr RecordedFooAddr, RecordedBarAddr; 43 std::promise<MSVCPError> ErrP; 44 45 lookupAndRecordAddrs([&](Error Err) { ErrP.set_value(std::move(Err)); }, ES, 46 LookupKind::Static, makeJITDylibSearchOrder(&JD), 47 {{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}}); 48 49 Error Err = ErrP.get_future().get(); 50 51 EXPECT_THAT_ERROR(std::move(Err), Failed()); 52 } 53 54 TEST_F(LookupAndRecordAddrsTest, AsyncWeakReference) { 55 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}}))); 56 57 ExecutorAddr RecordedFooAddr, RecordedBarAddr; 58 std::promise<MSVCPError> ErrP; 59 60 lookupAndRecordAddrs([&](Error Err) { ErrP.set_value(std::move(Err)); }, ES, 61 LookupKind::Static, makeJITDylibSearchOrder(&JD), 62 {{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}}, 63 SymbolLookupFlags::WeaklyReferencedSymbol); 64 65 Error Err = ErrP.get_future().get(); 66 67 EXPECT_THAT_ERROR(std::move(Err), Succeeded()); 68 EXPECT_EQ(RecordedFooAddr, FooAddr); 69 EXPECT_EQ(RecordedBarAddr, ExecutorAddr()); 70 } 71 72 TEST_F(LookupAndRecordAddrsTest, BlockingRequiredSuccess) { 73 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}}))); 74 75 ExecutorAddr RecordedFooAddr, RecordedBarAddr; 76 auto Err = 77 lookupAndRecordAddrs(ES, LookupKind::Static, makeJITDylibSearchOrder(&JD), 78 {{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}}); 79 80 EXPECT_THAT_ERROR(std::move(Err), Succeeded()); 81 EXPECT_EQ(RecordedFooAddr, FooAddr); 82 EXPECT_EQ(RecordedBarAddr, BarAddr); 83 } 84 85 TEST_F(LookupAndRecordAddrsTest, BlockingRequiredFailure) { 86 ExecutorAddr RecordedFooAddr, RecordedBarAddr; 87 auto Err = 88 lookupAndRecordAddrs(ES, LookupKind::Static, makeJITDylibSearchOrder(&JD), 89 {{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}}); 90 91 EXPECT_THAT_ERROR(std::move(Err), Failed()); 92 } 93 94 TEST_F(LookupAndRecordAddrsTest, BlockingWeakReference) { 95 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}}))); 96 97 ExecutorAddr RecordedFooAddr, RecordedBarAddr; 98 auto Err = 99 lookupAndRecordAddrs(ES, LookupKind::Static, makeJITDylibSearchOrder(&JD), 100 {{Foo, &RecordedFooAddr}, {Bar, &RecordedBarAddr}}, 101 SymbolLookupFlags::WeaklyReferencedSymbol); 102 103 EXPECT_THAT_ERROR(std::move(Err), Succeeded()); 104 EXPECT_EQ(RecordedFooAddr, FooAddr); 105 EXPECT_EQ(RecordedBarAddr, ExecutorAddr()); 106 } 107 108 } // namespace 109