1 //===----------- CoreAPIsTest.cpp - Unit tests for Core ORC APIs ----------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "OrcTestCommon.h"
11 #include "llvm/Config/llvm-config.h"
12 #include "llvm/ExecutionEngine/Orc/Core.h"
13 #include "llvm/ExecutionEngine/Orc/OrcError.h"
14
15 #include <set>
16 #include <thread>
17
18 using namespace llvm;
19 using namespace llvm::orc;
20
21 class CoreAPIsStandardTest : public CoreAPIsBasedStandardTest {};
22
23 namespace {
24
25 class SimpleMaterializationUnit : public MaterializationUnit {
26 public:
27 using MaterializeFunction =
28 std::function<void(MaterializationResponsibility)>;
29 using DiscardFunction = std::function<void(const VSO &, SymbolStringPtr)>;
30 using DestructorFunction = std::function<void()>;
31
SimpleMaterializationUnit(SymbolFlagsMap SymbolFlags,MaterializeFunction Materialize,DiscardFunction Discard=DiscardFunction (),DestructorFunction Destructor=DestructorFunction ())32 SimpleMaterializationUnit(
33 SymbolFlagsMap SymbolFlags, MaterializeFunction Materialize,
34 DiscardFunction Discard = DiscardFunction(),
35 DestructorFunction Destructor = DestructorFunction())
36 : MaterializationUnit(std::move(SymbolFlags)),
37 Materialize(std::move(Materialize)), Discard(std::move(Discard)),
38 Destructor(std::move(Destructor)) {}
39
~SimpleMaterializationUnit()40 ~SimpleMaterializationUnit() override {
41 if (Destructor)
42 Destructor();
43 }
44
materialize(MaterializationResponsibility R)45 void materialize(MaterializationResponsibility R) override {
46 Materialize(std::move(R));
47 }
48
discard(const VSO & V,SymbolStringPtr Name)49 void discard(const VSO &V, SymbolStringPtr Name) override {
50 if (Discard)
51 Discard(V, std::move(Name));
52 else
53 llvm_unreachable("Discard not supported");
54 }
55
56 private:
57 MaterializeFunction Materialize;
58 DiscardFunction Discard;
59 DestructorFunction Destructor;
60 };
61
TEST_F(CoreAPIsStandardTest,BasicSuccessfulLookup)62 TEST_F(CoreAPIsStandardTest, BasicSuccessfulLookup) {
63 bool OnResolutionRun = false;
64 bool OnReadyRun = false;
65
66 auto OnResolution = [&](Expected<SymbolMap> Result) {
67 EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
68 auto &Resolved = *Result;
69 auto I = Resolved.find(Foo);
70 EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
71 EXPECT_EQ(I->second.getAddress(), FooAddr)
72 << "Resolution returned incorrect result";
73 OnResolutionRun = true;
74 };
75 auto OnReady = [&](Error Err) {
76 cantFail(std::move(Err));
77 OnReadyRun = true;
78 };
79
80 std::shared_ptr<MaterializationResponsibility> FooMR;
81
82 cantFail(V.define(llvm::make_unique<SimpleMaterializationUnit>(
83 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
84 [&](MaterializationResponsibility R) {
85 FooMR = std::make_shared<MaterializationResponsibility>(std::move(R));
86 })));
87
88 ES.lookup({&V}, {Foo}, OnResolution, OnReady, NoDependenciesToRegister);
89
90 EXPECT_FALSE(OnResolutionRun) << "Should not have been resolved yet";
91 EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
92
93 FooMR->resolve({{Foo, FooSym}});
94
95 EXPECT_TRUE(OnResolutionRun) << "Should have been resolved";
96 EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
97
98 FooMR->finalize();
99
100 EXPECT_TRUE(OnReadyRun) << "Should have been marked ready";
101 }
102
TEST_F(CoreAPIsStandardTest,ExecutionSessionFailQuery)103 TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
104 bool OnResolutionRun = false;
105 bool OnReadyRun = false;
106
107 auto OnResolution = [&](Expected<SymbolMap> Result) {
108 EXPECT_FALSE(!!Result) << "Resolution unexpectedly returned success";
109 auto Msg = toString(Result.takeError());
110 EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";
111 OnResolutionRun = true;
112 };
113 auto OnReady = [&](Error Err) {
114 cantFail(std::move(Err));
115 OnReadyRun = true;
116 };
117
118 AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);
119
120 ES.legacyFailQuery(Q,
121 make_error<StringError>("xyz", inconvertibleErrorCode()));
122
123 EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
124 EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";
125 }
126
TEST_F(CoreAPIsStandardTest,EmptyLookup)127 TEST_F(CoreAPIsStandardTest, EmptyLookup) {
128 bool OnResolvedRun = false;
129 bool OnReadyRun = false;
130
131 auto OnResolution = [&](Expected<SymbolMap> Result) {
132 cantFail(std::move(Result));
133 OnResolvedRun = true;
134 };
135
136 auto OnReady = [&](Error Err) {
137 cantFail(std::move(Err));
138 OnReadyRun = true;
139 };
140
141 ES.lookup({&V}, {}, OnResolution, OnReady, NoDependenciesToRegister);
142
143 EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
144 EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
145 }
146
TEST_F(CoreAPIsStandardTest,ChainedVSOLookup)147 TEST_F(CoreAPIsStandardTest, ChainedVSOLookup) {
148 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
149
150 auto &V2 = ES.createVSO("V2");
151
152 bool OnResolvedRun = false;
153 bool OnReadyRun = false;
154
155 auto Q = std::make_shared<AsynchronousSymbolQuery>(
156 SymbolNameSet({Foo}),
157 [&](Expected<SymbolMap> Result) {
158 cantFail(std::move(Result));
159 OnResolvedRun = true;
160 },
161 [&](Error Err) {
162 cantFail(std::move(Err));
163 OnReadyRun = true;
164 });
165
166 V2.legacyLookup(Q, V.legacyLookup(Q, {Foo}));
167
168 EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
169 EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
170 }
171
TEST_F(CoreAPIsStandardTest,LookupFlagsTest)172 TEST_F(CoreAPIsStandardTest, LookupFlagsTest) {
173 // Test that lookupFlags works on a predefined symbol, and does not trigger
174 // materialization of a lazy symbol. Make the lazy symbol weak to test that
175 // the weak flag is propagated correctly.
176
177 BarSym.setFlags(static_cast<JITSymbolFlags::FlagNames>(
178 JITSymbolFlags::Exported | JITSymbolFlags::Weak));
179 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
180 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
181 [](MaterializationResponsibility R) {
182 llvm_unreachable("Symbol materialized on flags lookup");
183 });
184
185 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
186 cantFail(V.define(std::move(MU)));
187
188 SymbolNameSet Names({Foo, Bar, Baz});
189
190 auto SymbolFlags = V.lookupFlags(Names);
191
192 EXPECT_EQ(SymbolFlags.size(), 2U)
193 << "Returned symbol flags contains unexpected results";
194 EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Missing lookupFlags result for Foo";
195 EXPECT_EQ(SymbolFlags[Foo], FooSym.getFlags())
196 << "Incorrect flags returned for Foo";
197 EXPECT_EQ(SymbolFlags.count(Bar), 1U)
198 << "Missing lookupFlags result for Bar";
199 EXPECT_EQ(SymbolFlags[Bar], BarSym.getFlags())
200 << "Incorrect flags returned for Bar";
201 }
202
TEST_F(CoreAPIsStandardTest,TestBasicAliases)203 TEST_F(CoreAPIsStandardTest, TestBasicAliases) {
204 cantFail(V.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
205 cantFail(V.define(symbolAliases({{Baz, {Foo, JITSymbolFlags::Exported}},
206 {Qux, {Bar, JITSymbolFlags::Weak}}})));
207 cantFail(V.define(absoluteSymbols({{Qux, QuxSym}})));
208
209 auto Result = lookup({&V}, {Baz, Qux});
210 EXPECT_TRUE(!!Result) << "Unexpected lookup failure";
211 EXPECT_EQ(Result->count(Baz), 1U) << "No result for \"baz\"";
212 EXPECT_EQ(Result->count(Qux), 1U) << "No result for \"qux\"";
213 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
214 << "\"Baz\"'s address should match \"Foo\"'s";
215 EXPECT_EQ((*Result)[Qux].getAddress(), QuxSym.getAddress())
216 << "The \"Qux\" alias should have been overriden";
217 }
218
TEST_F(CoreAPIsStandardTest,TestChainedAliases)219 TEST_F(CoreAPIsStandardTest, TestChainedAliases) {
220 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
221 cantFail(V.define(symbolAliases(
222 {{Baz, {Bar, BazSym.getFlags()}}, {Bar, {Foo, BarSym.getFlags()}}})));
223
224 auto Result = lookup({&V}, {Bar, Baz});
225 EXPECT_TRUE(!!Result) << "Unexpected lookup failure";
226 EXPECT_EQ(Result->count(Bar), 1U) << "No result for \"bar\"";
227 EXPECT_EQ(Result->count(Baz), 1U) << "No result for \"baz\"";
228 EXPECT_EQ((*Result)[Bar].getAddress(), FooSym.getAddress())
229 << "\"Bar\"'s address should match \"Foo\"'s";
230 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
231 << "\"Baz\"'s address should match \"Foo\"'s";
232 }
233
TEST_F(CoreAPIsStandardTest,TestBasicReExports)234 TEST_F(CoreAPIsStandardTest, TestBasicReExports) {
235 // Test that the basic use case of re-exporting a single symbol from another
236 // VSO works.
237 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
238
239 auto &V2 = ES.createVSO("V2");
240
241 cantFail(V2.define(reexports(V, {{Bar, {Foo, BarSym.getFlags()}}})));
242
243 auto Result = cantFail(lookup({&V2}, Bar));
244 EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
245 << "Re-export Bar for symbol Foo should match FooSym's address";
246 }
247
TEST_F(CoreAPIsStandardTest,TestThatReExportsDontUnnecessarilyMaterialize)248 TEST_F(CoreAPIsStandardTest, TestThatReExportsDontUnnecessarilyMaterialize) {
249 // Test that re-exports do not materialize symbols that have not been queried
250 // for.
251 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
252
253 bool BarMaterialized = false;
254 auto BarMU = llvm::make_unique<SimpleMaterializationUnit>(
255 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
256 [&](MaterializationResponsibility R) {
257 BarMaterialized = true;
258 R.resolve({{Bar, BarSym}});
259 R.finalize();
260 });
261
262 cantFail(V.define(BarMU));
263
264 auto &V2 = ES.createVSO("V2");
265
266 cantFail(V2.define(reexports(
267 V, {{Baz, {Foo, BazSym.getFlags()}}, {Qux, {Bar, QuxSym.getFlags()}}})));
268
269 auto Result = cantFail(lookup({&V2}, Baz));
270 EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
271 << "Re-export Baz for symbol Foo should match FooSym's address";
272
273 EXPECT_FALSE(BarMaterialized) << "Bar should not have been materialized";
274 }
275
TEST_F(CoreAPIsStandardTest,TestTrivialCircularDependency)276 TEST_F(CoreAPIsStandardTest, TestTrivialCircularDependency) {
277 Optional<MaterializationResponsibility> FooR;
278 auto FooMU = llvm::make_unique<SimpleMaterializationUnit>(
279 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
280 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
281
282 cantFail(V.define(FooMU));
283
284 bool FooReady = false;
285 auto OnResolution = [](Expected<SymbolMap> R) { cantFail(std::move(R)); };
286 auto OnReady = [&](Error Err) {
287 cantFail(std::move(Err));
288 FooReady = true;
289 };
290
291 ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),
292 NoDependenciesToRegister);
293
294 FooR->resolve({{Foo, FooSym}});
295 FooR->finalize();
296
297 EXPECT_TRUE(FooReady)
298 << "Self-dependency prevented symbol from being marked ready";
299 }
300
TEST_F(CoreAPIsStandardTest,TestCircularDependenceInOneVSO)301 TEST_F(CoreAPIsStandardTest, TestCircularDependenceInOneVSO) {
302 // Test that a circular symbol dependency between three symbols in a VSO does
303 // not prevent any symbol from becoming 'ready' once all symbols are
304 // finalized.
305
306 // Create three MaterializationResponsibility objects: one for each of Foo,
307 // Bar and Baz. These are optional because MaterializationResponsibility
308 // does not have a default constructor).
309 Optional<MaterializationResponsibility> FooR;
310 Optional<MaterializationResponsibility> BarR;
311 Optional<MaterializationResponsibility> BazR;
312
313 // Create a MaterializationUnit for each symbol that moves the
314 // MaterializationResponsibility into one of the locals above.
315 auto FooMU = llvm::make_unique<SimpleMaterializationUnit>(
316 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
317 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
318
319 auto BarMU = llvm::make_unique<SimpleMaterializationUnit>(
320 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
321 [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
322
323 auto BazMU = llvm::make_unique<SimpleMaterializationUnit>(
324 SymbolFlagsMap({{Baz, BazSym.getFlags()}}),
325 [&](MaterializationResponsibility R) { BazR.emplace(std::move(R)); });
326
327 // Define the symbols.
328 cantFail(V.define(FooMU));
329 cantFail(V.define(BarMU));
330 cantFail(V.define(BazMU));
331
332 // Query each of the symbols to trigger materialization.
333 bool FooResolved = false;
334 bool FooReady = false;
335
336 auto OnFooResolution = [&](Expected<SymbolMap> Result) {
337 cantFail(std::move(Result));
338 FooResolved = true;
339 };
340
341 auto OnFooReady = [&](Error Err) {
342 cantFail(std::move(Err));
343 FooReady = true;
344 };
345
346 // Issue a lookup for Foo. Use NoDependenciesToRegister: We're going to add
347 // the dependencies manually below.
348 ES.lookup({&V}, {Foo}, std::move(OnFooResolution), std::move(OnFooReady),
349 NoDependenciesToRegister);
350
351 bool BarResolved = false;
352 bool BarReady = false;
353 auto OnBarResolution = [&](Expected<SymbolMap> Result) {
354 cantFail(std::move(Result));
355 BarResolved = true;
356 };
357
358 auto OnBarReady = [&](Error Err) {
359 cantFail(std::move(Err));
360 BarReady = true;
361 };
362
363 ES.lookup({&V}, {Bar}, std::move(OnBarResolution), std::move(OnBarReady),
364 NoDependenciesToRegister);
365
366 bool BazResolved = false;
367 bool BazReady = false;
368
369 auto OnBazResolution = [&](Expected<SymbolMap> Result) {
370 cantFail(std::move(Result));
371 BazResolved = true;
372 };
373
374 auto OnBazReady = [&](Error Err) {
375 cantFail(std::move(Err));
376 BazReady = true;
377 };
378
379 ES.lookup({&V}, {Baz}, std::move(OnBazResolution), std::move(OnBazReady),
380 NoDependenciesToRegister);
381
382 // Add a circular dependency: Foo -> Bar, Bar -> Baz, Baz -> Foo.
383 FooR->addDependenciesForAll({{&V, SymbolNameSet({Bar})}});
384 BarR->addDependenciesForAll({{&V, SymbolNameSet({Baz})}});
385 BazR->addDependenciesForAll({{&V, SymbolNameSet({Foo})}});
386
387 // Add self-dependencies for good measure. This tests that the implementation
388 // of addDependencies filters these out.
389 FooR->addDependenciesForAll({{&V, SymbolNameSet({Foo})}});
390 BarR->addDependenciesForAll({{&V, SymbolNameSet({Bar})}});
391 BazR->addDependenciesForAll({{&V, SymbolNameSet({Baz})}});
392
393 // Check that nothing has been resolved yet.
394 EXPECT_FALSE(FooResolved) << "\"Foo\" should not be resolved yet";
395 EXPECT_FALSE(BarResolved) << "\"Bar\" should not be resolved yet";
396 EXPECT_FALSE(BazResolved) << "\"Baz\" should not be resolved yet";
397
398 // Resolve the symbols (but do not finalized them).
399 FooR->resolve({{Foo, FooSym}});
400 BarR->resolve({{Bar, BarSym}});
401 BazR->resolve({{Baz, BazSym}});
402
403 // Verify that the symbols have been resolved, but are not ready yet.
404 EXPECT_TRUE(FooResolved) << "\"Foo\" should be resolved now";
405 EXPECT_TRUE(BarResolved) << "\"Bar\" should be resolved now";
406 EXPECT_TRUE(BazResolved) << "\"Baz\" should be resolved now";
407
408 EXPECT_FALSE(FooReady) << "\"Foo\" should not be ready yet";
409 EXPECT_FALSE(BarReady) << "\"Bar\" should not be ready yet";
410 EXPECT_FALSE(BazReady) << "\"Baz\" should not be ready yet";
411
412 // Finalize two of the symbols.
413 FooR->finalize();
414 BarR->finalize();
415
416 // Verify that nothing is ready until the circular dependence is resolved.
417 EXPECT_FALSE(FooReady) << "\"Foo\" still should not be ready";
418 EXPECT_FALSE(BarReady) << "\"Bar\" still should not be ready";
419 EXPECT_FALSE(BazReady) << "\"Baz\" still should not be ready";
420
421 // Finalize the last symbol.
422 BazR->finalize();
423
424 // Verify that everything becomes ready once the circular dependence resolved.
425 EXPECT_TRUE(FooReady) << "\"Foo\" should be ready now";
426 EXPECT_TRUE(BarReady) << "\"Bar\" should be ready now";
427 EXPECT_TRUE(BazReady) << "\"Baz\" should be ready now";
428 }
429
TEST_F(CoreAPIsStandardTest,DropMaterializerWhenEmpty)430 TEST_F(CoreAPIsStandardTest, DropMaterializerWhenEmpty) {
431 bool DestructorRun = false;
432
433 JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
434 WeakExported |= JITSymbolFlags::Weak;
435
436 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
437 SymbolFlagsMap({{Foo, WeakExported}, {Bar, WeakExported}}),
438 [](MaterializationResponsibility R) {
439 llvm_unreachable("Unexpected call to materialize");
440 },
441 [&](const VSO &V, SymbolStringPtr Name) {
442 EXPECT_TRUE(Name == Foo || Name == Bar)
443 << "Discard of unexpected symbol?";
444 },
445 [&]() { DestructorRun = true; });
446
447 cantFail(V.define(MU));
448
449 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
450
451 EXPECT_FALSE(DestructorRun)
452 << "MaterializationUnit should not have been destroyed yet";
453
454 cantFail(V.define(absoluteSymbols({{Bar, BarSym}})));
455
456 EXPECT_TRUE(DestructorRun)
457 << "MaterializationUnit should have been destroyed";
458 }
459
TEST_F(CoreAPIsStandardTest,AddAndMaterializeLazySymbol)460 TEST_F(CoreAPIsStandardTest, AddAndMaterializeLazySymbol) {
461 bool FooMaterialized = false;
462 bool BarDiscarded = false;
463
464 JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
465 WeakExported |= JITSymbolFlags::Weak;
466
467 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
468 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}, {Bar, WeakExported}}),
469 [&](MaterializationResponsibility R) {
470 assert(BarDiscarded && "Bar should have been discarded by this point");
471 R.resolve(SymbolMap({{Foo, FooSym}}));
472 R.finalize();
473 FooMaterialized = true;
474 },
475 [&](const VSO &V, SymbolStringPtr Name) {
476 EXPECT_EQ(Name, Bar) << "Expected Name to be Bar";
477 BarDiscarded = true;
478 });
479
480 cantFail(V.define(MU));
481 cantFail(V.define(absoluteSymbols({{Bar, BarSym}})));
482
483 SymbolNameSet Names({Foo});
484
485 bool OnResolutionRun = false;
486 bool OnReadyRun = false;
487
488 auto OnResolution = [&](Expected<SymbolMap> Result) {
489 EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
490 auto I = Result->find(Foo);
491 EXPECT_NE(I, Result->end()) << "Could not find symbol definition";
492 EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
493 << "Resolution returned incorrect result";
494 OnResolutionRun = true;
495 };
496
497 auto OnReady = [&](Error Err) {
498 cantFail(std::move(Err));
499 OnReadyRun = true;
500 };
501
502 ES.lookup({&V}, Names, std::move(OnResolution), std::move(OnReady),
503 NoDependenciesToRegister);
504
505 EXPECT_TRUE(FooMaterialized) << "Foo was not materialized";
506 EXPECT_TRUE(BarDiscarded) << "Bar was not discarded";
507 EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
508 EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
509 }
510
TEST_F(CoreAPIsStandardTest,DefineMaterializingSymbol)511 TEST_F(CoreAPIsStandardTest, DefineMaterializingSymbol) {
512 bool ExpectNoMoreMaterialization = false;
513 ES.setDispatchMaterialization(
514 [&](VSO &V, std::unique_ptr<MaterializationUnit> MU) {
515 if (ExpectNoMoreMaterialization)
516 ADD_FAILURE() << "Unexpected materialization";
517 MU->doMaterialize(V);
518 });
519
520 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
521 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
522 [&](MaterializationResponsibility R) {
523 cantFail(
524 R.defineMaterializing(SymbolFlagsMap({{Bar, BarSym.getFlags()}})));
525 R.resolve(SymbolMap({{Foo, FooSym}, {Bar, BarSym}}));
526 R.finalize();
527 });
528
529 cantFail(V.define(MU));
530 cantFail(lookup({&V}, Foo));
531
532 // Assert that materialization is complete by now.
533 ExpectNoMoreMaterialization = true;
534
535 // Look up bar to verify that no further materialization happens.
536 auto BarResult = cantFail(lookup({&V}, Bar));
537 EXPECT_EQ(BarResult.getAddress(), BarSym.getAddress())
538 << "Expected Bar == BarSym";
539 }
540
TEST_F(CoreAPIsStandardTest,FallbackDefinitionGeneratorTest)541 TEST_F(CoreAPIsStandardTest, FallbackDefinitionGeneratorTest) {
542 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
543
544 V.setFallbackDefinitionGenerator([&](VSO &W, const SymbolNameSet &Names) {
545 cantFail(W.define(absoluteSymbols({{Bar, BarSym}})));
546 return SymbolNameSet({Bar});
547 });
548
549 auto Result = cantFail(lookup({&V}, {Foo, Bar}));
550
551 EXPECT_EQ(Result.count(Bar), 1U) << "Expected to find fallback def for 'bar'";
552 EXPECT_EQ(Result[Bar].getAddress(), BarSym.getAddress())
553 << "Expected fallback def for Bar to be equal to BarSym";
554 }
555
TEST_F(CoreAPIsStandardTest,FailResolution)556 TEST_F(CoreAPIsStandardTest, FailResolution) {
557 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
558 SymbolFlagsMap(
559 {{Foo, JITSymbolFlags::Weak}, {Bar, JITSymbolFlags::Weak}}),
560 [&](MaterializationResponsibility R) { R.failMaterialization(); });
561
562 cantFail(V.define(MU));
563
564 SymbolNameSet Names({Foo, Bar});
565 auto Result = lookup({&V}, Names);
566
567 EXPECT_FALSE(!!Result) << "Expected failure";
568 if (!Result) {
569 handleAllErrors(Result.takeError(),
570 [&](FailedToMaterialize &F) {
571 EXPECT_EQ(F.getSymbols(), Names)
572 << "Expected to fail on symbols in Names";
573 },
574 [](ErrorInfoBase &EIB) {
575 std::string ErrMsg;
576 {
577 raw_string_ostream ErrOut(ErrMsg);
578 EIB.log(ErrOut);
579 }
580 ADD_FAILURE()
581 << "Expected a FailedToResolve error. Got:\n"
582 << ErrMsg;
583 });
584 }
585 }
586
TEST_F(CoreAPIsStandardTest,TestLookupWithUnthreadedMaterialization)587 TEST_F(CoreAPIsStandardTest, TestLookupWithUnthreadedMaterialization) {
588 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
589 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
590 [&](MaterializationResponsibility R) {
591 R.resolve({{Foo, FooSym}});
592 R.finalize();
593 });
594
595 cantFail(V.define(MU));
596
597 auto FooLookupResult = cantFail(lookup({&V}, Foo));
598
599 EXPECT_EQ(FooLookupResult.getAddress(), FooSym.getAddress())
600 << "lookup returned an incorrect address";
601 EXPECT_EQ(FooLookupResult.getFlags(), FooSym.getFlags())
602 << "lookup returned incorrect flags";
603 }
604
TEST_F(CoreAPIsStandardTest,TestLookupWithThreadedMaterialization)605 TEST_F(CoreAPIsStandardTest, TestLookupWithThreadedMaterialization) {
606 #if LLVM_ENABLE_THREADS
607
608 std::thread MaterializationThread;
609 ES.setDispatchMaterialization(
610 [&](VSO &V, std::unique_ptr<MaterializationUnit> MU) {
611 auto SharedMU = std::shared_ptr<MaterializationUnit>(std::move(MU));
612 MaterializationThread =
613 std::thread([SharedMU, &V]() { SharedMU->doMaterialize(V); });
614 });
615
616 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
617
618 auto FooLookupResult = cantFail(lookup({&V}, Foo));
619
620 EXPECT_EQ(FooLookupResult.getAddress(), FooSym.getAddress())
621 << "lookup returned an incorrect address";
622 EXPECT_EQ(FooLookupResult.getFlags(), FooSym.getFlags())
623 << "lookup returned incorrect flags";
624 MaterializationThread.join();
625 #endif
626 }
627
TEST_F(CoreAPIsStandardTest,TestGetRequestedSymbolsAndReplace)628 TEST_F(CoreAPIsStandardTest, TestGetRequestedSymbolsAndReplace) {
629 // Test that GetRequestedSymbols returns the set of symbols that currently
630 // have pending queries, and test that MaterializationResponsibility's
631 // replace method can be used to return definitions to the VSO in a new
632 // MaterializationUnit.
633 SymbolNameSet Names({Foo, Bar});
634
635 bool FooMaterialized = false;
636 bool BarMaterialized = false;
637
638 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
639 SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
640 [&](MaterializationResponsibility R) {
641 auto Requested = R.getRequestedSymbols();
642 EXPECT_EQ(Requested.size(), 1U) << "Expected one symbol requested";
643 EXPECT_EQ(*Requested.begin(), Foo) << "Expected \"Foo\" requested";
644
645 auto NewMU = llvm::make_unique<SimpleMaterializationUnit>(
646 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
647 [&](MaterializationResponsibility R2) {
648 R2.resolve(SymbolMap({{Bar, BarSym}}));
649 R2.finalize();
650 BarMaterialized = true;
651 });
652
653 R.replace(std::move(NewMU));
654
655 R.resolve(SymbolMap({{Foo, FooSym}}));
656 R.finalize();
657
658 FooMaterialized = true;
659 });
660
661 cantFail(V.define(MU));
662
663 EXPECT_FALSE(FooMaterialized) << "Foo should not be materialized yet";
664 EXPECT_FALSE(BarMaterialized) << "Bar should not be materialized yet";
665
666 auto FooSymResult = cantFail(lookup({&V}, Foo));
667 EXPECT_EQ(FooSymResult.getAddress(), FooSym.getAddress())
668 << "Address mismatch for Foo";
669
670 EXPECT_TRUE(FooMaterialized) << "Foo should be materialized now";
671 EXPECT_FALSE(BarMaterialized) << "Bar still should not be materialized";
672
673 auto BarSymResult = cantFail(lookup({&V}, Bar));
674 EXPECT_EQ(BarSymResult.getAddress(), BarSym.getAddress())
675 << "Address mismatch for Bar";
676 EXPECT_TRUE(BarMaterialized) << "Bar should be materialized now";
677 }
678
TEST_F(CoreAPIsStandardTest,TestMaterializationResponsibilityDelegation)679 TEST_F(CoreAPIsStandardTest, TestMaterializationResponsibilityDelegation) {
680 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
681 SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
682 [&](MaterializationResponsibility R) {
683 auto R2 = R.delegate({Bar});
684
685 R.resolve({{Foo, FooSym}});
686 R.finalize();
687 R2.resolve({{Bar, BarSym}});
688 R2.finalize();
689 });
690
691 cantFail(V.define(MU));
692
693 auto Result = lookup({&V}, {Foo, Bar});
694
695 EXPECT_TRUE(!!Result) << "Result should be a success value";
696 EXPECT_EQ(Result->count(Foo), 1U) << "\"Foo\" entry missing";
697 EXPECT_EQ(Result->count(Bar), 1U) << "\"Bar\" entry missing";
698 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
699 << "Address mismatch for \"Foo\"";
700 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
701 << "Address mismatch for \"Bar\"";
702 }
703
TEST_F(CoreAPIsStandardTest,TestMaterializeWeakSymbol)704 TEST_F(CoreAPIsStandardTest, TestMaterializeWeakSymbol) {
705 // Confirm that once a weak definition is selected for materialization it is
706 // treated as strong.
707 JITSymbolFlags WeakExported = JITSymbolFlags::Exported;
708 WeakExported &= JITSymbolFlags::Weak;
709
710 std::unique_ptr<MaterializationResponsibility> FooResponsibility;
711 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
712 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
713 [&](MaterializationResponsibility R) {
714 FooResponsibility =
715 llvm::make_unique<MaterializationResponsibility>(std::move(R));
716 });
717
718 cantFail(V.define(MU));
719 auto OnResolution = [](Expected<SymbolMap> Result) {
720 cantFail(std::move(Result));
721 };
722
723 auto OnReady = [](Error Err) { cantFail(std::move(Err)); };
724
725 ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),
726 NoDependenciesToRegister);
727
728 auto MU2 = llvm::make_unique<SimpleMaterializationUnit>(
729 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
730 [](MaterializationResponsibility R) {
731 llvm_unreachable("This unit should never be materialized");
732 });
733
734 auto Err = V.define(MU2);
735 EXPECT_TRUE(!!Err) << "Expected failure value";
736 EXPECT_TRUE(Err.isA<DuplicateDefinition>())
737 << "Expected a duplicate definition error";
738 consumeError(std::move(Err));
739
740 FooResponsibility->resolve(SymbolMap({{Foo, FooSym}}));
741 FooResponsibility->finalize();
742 }
743
744 } // namespace
745