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
TEST_F(CoreAPIsStandardTest,BasicSuccessfulLookup)25 TEST_F(CoreAPIsStandardTest, BasicSuccessfulLookup) {
26 bool OnResolutionRun = false;
27 bool OnReadyRun = false;
28
29 auto OnResolution = [&](Expected<SymbolMap> Result) {
30 EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
31 auto &Resolved = *Result;
32 auto I = Resolved.find(Foo);
33 EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
34 EXPECT_EQ(I->second.getAddress(), FooAddr)
35 << "Resolution returned incorrect result";
36 OnResolutionRun = true;
37 };
38 auto OnReady = [&](Error Err) {
39 cantFail(std::move(Err));
40 OnReadyRun = true;
41 };
42
43 std::shared_ptr<MaterializationResponsibility> FooMR;
44
45 cantFail(JD.define(llvm::make_unique<SimpleMaterializationUnit>(
46 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
47 [&](MaterializationResponsibility R) {
48 FooMR = std::make_shared<MaterializationResponsibility>(std::move(R));
49 })));
50
51 ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, OnResolution, OnReady,
52 NoDependenciesToRegister);
53
54 EXPECT_FALSE(OnResolutionRun) << "Should not have been resolved yet";
55 EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
56
57 FooMR->resolve({{Foo, FooSym}});
58
59 EXPECT_TRUE(OnResolutionRun) << "Should have been resolved";
60 EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
61
62 FooMR->emit();
63
64 EXPECT_TRUE(OnReadyRun) << "Should have been marked ready";
65 }
66
TEST_F(CoreAPIsStandardTest,ExecutionSessionFailQuery)67 TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
68 bool OnResolutionRun = false;
69 bool OnReadyRun = false;
70
71 auto OnResolution = [&](Expected<SymbolMap> Result) {
72 EXPECT_FALSE(!!Result) << "Resolution unexpectedly returned success";
73 auto Msg = toString(Result.takeError());
74 EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";
75 OnResolutionRun = true;
76 };
77 auto OnReady = [&](Error Err) {
78 cantFail(std::move(Err));
79 OnReadyRun = true;
80 };
81
82 AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);
83
84 ES.legacyFailQuery(Q,
85 make_error<StringError>("xyz", inconvertibleErrorCode()));
86
87 EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
88 EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";
89 }
90
TEST_F(CoreAPIsStandardTest,EmptyLookup)91 TEST_F(CoreAPIsStandardTest, EmptyLookup) {
92 bool OnResolvedRun = false;
93 bool OnReadyRun = false;
94
95 auto OnResolution = [&](Expected<SymbolMap> Result) {
96 cantFail(std::move(Result));
97 OnResolvedRun = true;
98 };
99
100 auto OnReady = [&](Error Err) {
101 cantFail(std::move(Err));
102 OnReadyRun = true;
103 };
104
105 ES.lookup(JITDylibSearchList({{&JD, false}}), {}, OnResolution, OnReady,
106 NoDependenciesToRegister);
107
108 EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
109 EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
110 }
111
TEST_F(CoreAPIsStandardTest,RemoveSymbolsTest)112 TEST_F(CoreAPIsStandardTest, RemoveSymbolsTest) {
113 // Test that:
114 // (1) Missing symbols generate a SymbolsNotFound error.
115 // (2) Materializing symbols generate a SymbolCouldNotBeRemoved error.
116 // (3) Removal of unmaterialized symbols triggers discard on the
117 // materialization unit.
118 // (4) Removal of symbols destroys empty materialization units.
119 // (5) Removal of materialized symbols works.
120
121 // Foo will be fully materialized.
122 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
123
124 // Bar will be unmaterialized.
125 bool BarDiscarded = false;
126 bool BarMaterializerDestructed = false;
127 cantFail(JD.define(llvm::make_unique<SimpleMaterializationUnit>(
128 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
129 [this](MaterializationResponsibility R) {
130 ADD_FAILURE() << "Unexpected materialization of \"Bar\"";
131 R.resolve({{Bar, BarSym}});
132 R.emit();
133 },
134 [&](const JITDylib &JD, const SymbolStringPtr &Name) {
135 EXPECT_EQ(Name, Bar) << "Expected \"Bar\" to be discarded";
136 if (Name == Bar)
137 BarDiscarded = true;
138 },
139 [&]() { BarMaterializerDestructed = true; })));
140
141 // Baz will be in the materializing state initially, then
142 // materialized for the final removal attempt.
143 Optional<MaterializationResponsibility> BazR;
144 cantFail(JD.define(llvm::make_unique<SimpleMaterializationUnit>(
145 SymbolFlagsMap({{Baz, BazSym.getFlags()}}),
146 [&](MaterializationResponsibility R) { BazR.emplace(std::move(R)); },
147 [](const JITDylib &JD, const SymbolStringPtr &Name) {
148 ADD_FAILURE() << "\"Baz\" discarded unexpectedly";
149 })));
150
151 bool OnResolvedRun = false;
152 bool OnReadyRun = false;
153 ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo, Baz},
154 [&](Expected<SymbolMap> Result) {
155 EXPECT_TRUE(!!Result) << "OnResolved failed unexpectedly";
156 consumeError(Result.takeError());
157 OnResolvedRun = true;
158 },
159 [&](Error Err) {
160 EXPECT_FALSE(!!Err) << "OnReady failed unexpectedly";
161 consumeError(std::move(Err));
162 OnReadyRun = true;
163 },
164 NoDependenciesToRegister);
165
166 {
167 // Attempt 1: Search for a missing symbol, Qux.
168 auto Err = JD.remove({Foo, Bar, Baz, Qux});
169 EXPECT_TRUE(!!Err) << "Expected failure";
170 EXPECT_TRUE(Err.isA<SymbolsNotFound>())
171 << "Expected a SymbolsNotFound error";
172 consumeError(std::move(Err));
173 }
174
175 {
176 // Attempt 2: Search for a symbol that is still materializing, Baz.
177 auto Err = JD.remove({Foo, Bar, Baz});
178 EXPECT_TRUE(!!Err) << "Expected failure";
179 EXPECT_TRUE(Err.isA<SymbolsCouldNotBeRemoved>())
180 << "Expected a SymbolsNotFound error";
181 consumeError(std::move(Err));
182 }
183
184 BazR->resolve({{Baz, BazSym}});
185 BazR->emit();
186 {
187 // Attempt 3: Search now that all symbols are fully materialized
188 // (Foo, Baz), or not yet materialized (Bar).
189 auto Err = JD.remove({Foo, Bar, Baz});
190 EXPECT_FALSE(!!Err) << "Expected failure";
191 }
192
193 EXPECT_TRUE(BarDiscarded) << "\"Bar\" should have been discarded";
194 EXPECT_TRUE(BarMaterializerDestructed)
195 << "\"Bar\"'s materializer should have been destructed";
196 EXPECT_TRUE(OnResolvedRun) << "OnResolved should have been run";
197 EXPECT_TRUE(OnReadyRun) << "OnReady should have been run";
198 }
199
TEST_F(CoreAPIsStandardTest,ChainedJITDylibLookup)200 TEST_F(CoreAPIsStandardTest, ChainedJITDylibLookup) {
201 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
202
203 auto &JD2 = ES.createJITDylib("JD2");
204
205 bool OnResolvedRun = false;
206 bool OnReadyRun = false;
207
208 auto Q = std::make_shared<AsynchronousSymbolQuery>(
209 SymbolNameSet({Foo}),
210 [&](Expected<SymbolMap> Result) {
211 cantFail(std::move(Result));
212 OnResolvedRun = true;
213 },
214 [&](Error Err) {
215 cantFail(std::move(Err));
216 OnReadyRun = true;
217 });
218
219 JD2.legacyLookup(Q, JD.legacyLookup(Q, {Foo}));
220
221 EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
222 EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
223 }
224
TEST_F(CoreAPIsStandardTest,LookupWithHiddenSymbols)225 TEST_F(CoreAPIsStandardTest, LookupWithHiddenSymbols) {
226 auto BarHiddenFlags = BarSym.getFlags() & ~JITSymbolFlags::Exported;
227 auto BarHiddenSym = JITEvaluatedSymbol(BarSym.getAddress(), BarHiddenFlags);
228
229 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarHiddenSym}})));
230
231 auto &JD2 = ES.createJITDylib("JD2");
232 cantFail(JD2.define(absoluteSymbols({{Bar, QuxSym}})));
233
234 /// Try a blocking lookup.
235 auto Result = cantFail(
236 ES.lookup(JITDylibSearchList({{&JD, false}, {&JD2, false}}), {Foo, Bar}));
237
238 EXPECT_EQ(Result.size(), 2U) << "Unexpected number of results";
239 EXPECT_EQ(Result.count(Foo), 1U) << "Missing result for \"Foo\"";
240 EXPECT_EQ(Result.count(Bar), 1U) << "Missing result for \"Bar\"";
241 EXPECT_EQ(Result[Bar].getAddress(), QuxSym.getAddress())
242 << "Wrong result for \"Bar\"";
243 }
244
TEST_F(CoreAPIsStandardTest,LookupFlagsTest)245 TEST_F(CoreAPIsStandardTest, LookupFlagsTest) {
246 // Test that lookupFlags works on a predefined symbol, and does not trigger
247 // materialization of a lazy symbol. Make the lazy symbol weak to test that
248 // the weak flag is propagated correctly.
249
250 BarSym.setFlags(static_cast<JITSymbolFlags::FlagNames>(
251 JITSymbolFlags::Exported | JITSymbolFlags::Weak));
252 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
253 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
254 [](MaterializationResponsibility R) {
255 llvm_unreachable("Symbol materialized on flags lookup");
256 });
257
258 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
259 cantFail(JD.define(std::move(MU)));
260
261 SymbolNameSet Names({Foo, Bar, Baz});
262
263 auto SymbolFlags = JD.lookupFlags(Names);
264
265 EXPECT_EQ(SymbolFlags.size(), 2U)
266 << "Returned symbol flags contains unexpected results";
267 EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Missing lookupFlags result for Foo";
268 EXPECT_EQ(SymbolFlags[Foo], FooSym.getFlags())
269 << "Incorrect flags returned for Foo";
270 EXPECT_EQ(SymbolFlags.count(Bar), 1U)
271 << "Missing lookupFlags result for Bar";
272 EXPECT_EQ(SymbolFlags[Bar], BarSym.getFlags())
273 << "Incorrect flags returned for Bar";
274 }
275
TEST_F(CoreAPIsStandardTest,TestBasicAliases)276 TEST_F(CoreAPIsStandardTest, TestBasicAliases) {
277 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
278 cantFail(JD.define(symbolAliases({{Baz, {Foo, JITSymbolFlags::Exported}},
279 {Qux, {Bar, JITSymbolFlags::Weak}}})));
280 cantFail(JD.define(absoluteSymbols({{Qux, QuxSym}})));
281
282 auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), {Baz, Qux});
283 EXPECT_TRUE(!!Result) << "Unexpected lookup failure";
284 EXPECT_EQ(Result->count(Baz), 1U) << "No result for \"baz\"";
285 EXPECT_EQ(Result->count(Qux), 1U) << "No result for \"qux\"";
286 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
287 << "\"Baz\"'s address should match \"Foo\"'s";
288 EXPECT_EQ((*Result)[Qux].getAddress(), QuxSym.getAddress())
289 << "The \"Qux\" alias should have been overriden";
290 }
291
TEST_F(CoreAPIsStandardTest,TestChainedAliases)292 TEST_F(CoreAPIsStandardTest, TestChainedAliases) {
293 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
294 cantFail(JD.define(symbolAliases(
295 {{Baz, {Bar, BazSym.getFlags()}}, {Bar, {Foo, BarSym.getFlags()}}})));
296
297 auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar, Baz});
298 EXPECT_TRUE(!!Result) << "Unexpected lookup failure";
299 EXPECT_EQ(Result->count(Bar), 1U) << "No result for \"bar\"";
300 EXPECT_EQ(Result->count(Baz), 1U) << "No result for \"baz\"";
301 EXPECT_EQ((*Result)[Bar].getAddress(), FooSym.getAddress())
302 << "\"Bar\"'s address should match \"Foo\"'s";
303 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
304 << "\"Baz\"'s address should match \"Foo\"'s";
305 }
306
TEST_F(CoreAPIsStandardTest,TestBasicReExports)307 TEST_F(CoreAPIsStandardTest, TestBasicReExports) {
308 // Test that the basic use case of re-exporting a single symbol from another
309 // JITDylib works.
310 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
311
312 auto &JD2 = ES.createJITDylib("JD2");
313
314 cantFail(JD2.define(reexports(JD, {{Bar, {Foo, BarSym.getFlags()}}})));
315
316 auto Result = cantFail(ES.lookup(JITDylibSearchList({{&JD2, false}}), Bar));
317 EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
318 << "Re-export Bar for symbol Foo should match FooSym's address";
319 }
320
TEST_F(CoreAPIsStandardTest,TestThatReExportsDontUnnecessarilyMaterialize)321 TEST_F(CoreAPIsStandardTest, TestThatReExportsDontUnnecessarilyMaterialize) {
322 // Test that re-exports do not materialize symbols that have not been queried
323 // for.
324 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
325
326 bool BarMaterialized = false;
327 auto BarMU = llvm::make_unique<SimpleMaterializationUnit>(
328 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
329 [&](MaterializationResponsibility R) {
330 BarMaterialized = true;
331 R.resolve({{Bar, BarSym}});
332 R.emit();
333 });
334
335 cantFail(JD.define(BarMU));
336
337 auto &JD2 = ES.createJITDylib("JD2");
338
339 cantFail(JD2.define(reexports(
340 JD, {{Baz, {Foo, BazSym.getFlags()}}, {Qux, {Bar, QuxSym.getFlags()}}})));
341
342 auto Result = cantFail(ES.lookup(JITDylibSearchList({{&JD2, false}}), Baz));
343 EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
344 << "Re-export Baz for symbol Foo should match FooSym's address";
345
346 EXPECT_FALSE(BarMaterialized) << "Bar should not have been materialized";
347 }
348
TEST_F(CoreAPIsStandardTest,TestReexportsGenerator)349 TEST_F(CoreAPIsStandardTest, TestReexportsGenerator) {
350 // Test that a re-exports generator can dynamically generate reexports.
351
352 auto &JD2 = ES.createJITDylib("JD2");
353 cantFail(JD2.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
354
355 auto Filter = [this](SymbolStringPtr Name) { return Name != Bar; };
356
357 JD.setGenerator(ReexportsGenerator(JD2, false, Filter));
358
359 auto Flags = JD.lookupFlags({Foo, Bar, Baz});
360 EXPECT_EQ(Flags.size(), 1U) << "Unexpected number of results";
361 EXPECT_EQ(Flags[Foo], FooSym.getFlags()) << "Unexpected flags for Foo";
362
363 auto Result = cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
364
365 EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
366 << "Incorrect reexported symbol address";
367 }
368
TEST_F(CoreAPIsStandardTest,TestTrivialCircularDependency)369 TEST_F(CoreAPIsStandardTest, TestTrivialCircularDependency) {
370 Optional<MaterializationResponsibility> FooR;
371 auto FooMU = llvm::make_unique<SimpleMaterializationUnit>(
372 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
373 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
374
375 cantFail(JD.define(FooMU));
376
377 bool FooReady = false;
378 auto OnResolution = [](Expected<SymbolMap> R) { cantFail(std::move(R)); };
379 auto OnReady = [&](Error Err) {
380 cantFail(std::move(Err));
381 FooReady = true;
382 };
383
384 ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, std::move(OnResolution),
385 std::move(OnReady), NoDependenciesToRegister);
386
387 FooR->resolve({{Foo, FooSym}});
388 FooR->emit();
389
390 EXPECT_TRUE(FooReady)
391 << "Self-dependency prevented symbol from being marked ready";
392 }
393
TEST_F(CoreAPIsStandardTest,TestCircularDependenceInOneJITDylib)394 TEST_F(CoreAPIsStandardTest, TestCircularDependenceInOneJITDylib) {
395 // Test that a circular symbol dependency between three symbols in a JITDylib
396 // does not prevent any symbol from becoming 'ready' once all symbols are
397 // emitted.
398
399 // Create three MaterializationResponsibility objects: one for each of Foo,
400 // Bar and Baz. These are optional because MaterializationResponsibility
401 // does not have a default constructor).
402 Optional<MaterializationResponsibility> FooR;
403 Optional<MaterializationResponsibility> BarR;
404 Optional<MaterializationResponsibility> BazR;
405
406 // Create a MaterializationUnit for each symbol that moves the
407 // MaterializationResponsibility into one of the locals above.
408 auto FooMU = llvm::make_unique<SimpleMaterializationUnit>(
409 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
410 [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
411
412 auto BarMU = llvm::make_unique<SimpleMaterializationUnit>(
413 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
414 [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
415
416 auto BazMU = llvm::make_unique<SimpleMaterializationUnit>(
417 SymbolFlagsMap({{Baz, BazSym.getFlags()}}),
418 [&](MaterializationResponsibility R) { BazR.emplace(std::move(R)); });
419
420 // Define the symbols.
421 cantFail(JD.define(FooMU));
422 cantFail(JD.define(BarMU));
423 cantFail(JD.define(BazMU));
424
425 // Query each of the symbols to trigger materialization.
426 bool FooResolved = false;
427 bool FooReady = false;
428
429 auto OnFooResolution = [&](Expected<SymbolMap> Result) {
430 cantFail(std::move(Result));
431 FooResolved = true;
432 };
433
434 auto OnFooReady = [&](Error Err) {
435 cantFail(std::move(Err));
436 FooReady = true;
437 };
438
439 // Issue a lookup for Foo. Use NoDependenciesToRegister: We're going to add
440 // the dependencies manually below.
441 ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo},
442 std::move(OnFooResolution), std::move(OnFooReady),
443 NoDependenciesToRegister);
444
445 bool BarResolved = false;
446 bool BarReady = false;
447 auto OnBarResolution = [&](Expected<SymbolMap> Result) {
448 cantFail(std::move(Result));
449 BarResolved = true;
450 };
451
452 auto OnBarReady = [&](Error Err) {
453 cantFail(std::move(Err));
454 BarReady = true;
455 };
456
457 ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar},
458 std::move(OnBarResolution), std::move(OnBarReady),
459 NoDependenciesToRegister);
460
461 bool BazResolved = false;
462 bool BazReady = false;
463
464 auto OnBazResolution = [&](Expected<SymbolMap> Result) {
465 cantFail(std::move(Result));
466 BazResolved = true;
467 };
468
469 auto OnBazReady = [&](Error Err) {
470 cantFail(std::move(Err));
471 BazReady = true;
472 };
473
474 ES.lookup(JITDylibSearchList({{&JD, false}}), {Baz},
475 std::move(OnBazResolution), std::move(OnBazReady),
476 NoDependenciesToRegister);
477
478 // Add a circular dependency: Foo -> Bar, Bar -> Baz, Baz -> Foo.
479 FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
480 BarR->addDependenciesForAll({{&JD, SymbolNameSet({Baz})}});
481 BazR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
482
483 // Add self-dependencies for good measure. This tests that the implementation
484 // of addDependencies filters these out.
485 FooR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
486 BarR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
487 BazR->addDependenciesForAll({{&JD, SymbolNameSet({Baz})}});
488
489 // Check that nothing has been resolved yet.
490 EXPECT_FALSE(FooResolved) << "\"Foo\" should not be resolved yet";
491 EXPECT_FALSE(BarResolved) << "\"Bar\" should not be resolved yet";
492 EXPECT_FALSE(BazResolved) << "\"Baz\" should not be resolved yet";
493
494 // Resolve the symbols (but do not emit them).
495 FooR->resolve({{Foo, FooSym}});
496 BarR->resolve({{Bar, BarSym}});
497 BazR->resolve({{Baz, BazSym}});
498
499 // Verify that the symbols have been resolved, but are not ready yet.
500 EXPECT_TRUE(FooResolved) << "\"Foo\" should be resolved now";
501 EXPECT_TRUE(BarResolved) << "\"Bar\" should be resolved now";
502 EXPECT_TRUE(BazResolved) << "\"Baz\" should be resolved now";
503
504 EXPECT_FALSE(FooReady) << "\"Foo\" should not be ready yet";
505 EXPECT_FALSE(BarReady) << "\"Bar\" should not be ready yet";
506 EXPECT_FALSE(BazReady) << "\"Baz\" should not be ready yet";
507
508 // Emit two of the symbols.
509 FooR->emit();
510 BarR->emit();
511
512 // Verify that nothing is ready until the circular dependence is resolved.
513 EXPECT_FALSE(FooReady) << "\"Foo\" still should not be ready";
514 EXPECT_FALSE(BarReady) << "\"Bar\" still should not be ready";
515 EXPECT_FALSE(BazReady) << "\"Baz\" still should not be ready";
516
517 // Emit the last symbol.
518 BazR->emit();
519
520 // Verify that everything becomes ready once the circular dependence resolved.
521 EXPECT_TRUE(FooReady) << "\"Foo\" should be ready now";
522 EXPECT_TRUE(BarReady) << "\"Bar\" should be ready now";
523 EXPECT_TRUE(BazReady) << "\"Baz\" should be ready now";
524 }
525
TEST_F(CoreAPIsStandardTest,DropMaterializerWhenEmpty)526 TEST_F(CoreAPIsStandardTest, DropMaterializerWhenEmpty) {
527 bool DestructorRun = false;
528
529 JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
530 WeakExported |= JITSymbolFlags::Weak;
531
532 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
533 SymbolFlagsMap({{Foo, WeakExported}, {Bar, WeakExported}}),
534 [](MaterializationResponsibility R) {
535 llvm_unreachable("Unexpected call to materialize");
536 },
537 [&](const JITDylib &JD, SymbolStringPtr Name) {
538 EXPECT_TRUE(Name == Foo || Name == Bar)
539 << "Discard of unexpected symbol?";
540 },
541 [&]() { DestructorRun = true; });
542
543 cantFail(JD.define(MU));
544
545 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
546
547 EXPECT_FALSE(DestructorRun)
548 << "MaterializationUnit should not have been destroyed yet";
549
550 cantFail(JD.define(absoluteSymbols({{Bar, BarSym}})));
551
552 EXPECT_TRUE(DestructorRun)
553 << "MaterializationUnit should have been destroyed";
554 }
555
TEST_F(CoreAPIsStandardTest,AddAndMaterializeLazySymbol)556 TEST_F(CoreAPIsStandardTest, AddAndMaterializeLazySymbol) {
557 bool FooMaterialized = false;
558 bool BarDiscarded = false;
559
560 JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
561 WeakExported |= JITSymbolFlags::Weak;
562
563 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
564 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}, {Bar, WeakExported}}),
565 [&](MaterializationResponsibility R) {
566 assert(BarDiscarded && "Bar should have been discarded by this point");
567 R.resolve(SymbolMap({{Foo, FooSym}}));
568 R.emit();
569 FooMaterialized = true;
570 },
571 [&](const JITDylib &JD, SymbolStringPtr Name) {
572 EXPECT_EQ(Name, Bar) << "Expected Name to be Bar";
573 BarDiscarded = true;
574 });
575
576 cantFail(JD.define(MU));
577 cantFail(JD.define(absoluteSymbols({{Bar, BarSym}})));
578
579 SymbolNameSet Names({Foo});
580
581 bool OnResolutionRun = false;
582 bool OnReadyRun = false;
583
584 auto OnResolution = [&](Expected<SymbolMap> Result) {
585 EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
586 auto I = Result->find(Foo);
587 EXPECT_NE(I, Result->end()) << "Could not find symbol definition";
588 EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
589 << "Resolution returned incorrect result";
590 OnResolutionRun = true;
591 };
592
593 auto OnReady = [&](Error Err) {
594 cantFail(std::move(Err));
595 OnReadyRun = true;
596 };
597
598 ES.lookup(JITDylibSearchList({{&JD, false}}), Names, std::move(OnResolution),
599 std::move(OnReady), NoDependenciesToRegister);
600
601 EXPECT_TRUE(FooMaterialized) << "Foo was not materialized";
602 EXPECT_TRUE(BarDiscarded) << "Bar was not discarded";
603 EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
604 EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
605 }
606
TEST_F(CoreAPIsStandardTest,TestBasicWeakSymbolMaterialization)607 TEST_F(CoreAPIsStandardTest, TestBasicWeakSymbolMaterialization) {
608 // Test that weak symbols are materialized correctly when we look them up.
609 BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
610
611 bool BarMaterialized = false;
612 auto MU1 = llvm::make_unique<SimpleMaterializationUnit>(
613 SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
614 [&](MaterializationResponsibility R) {
615 R.resolve(SymbolMap({{Foo, FooSym}, {Bar, BarSym}})), R.emit();
616 BarMaterialized = true;
617 });
618
619 bool DuplicateBarDiscarded = false;
620 auto MU2 = llvm::make_unique<SimpleMaterializationUnit>(
621 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
622 [&](MaterializationResponsibility R) {
623 ADD_FAILURE() << "Attempt to materialize Bar from the wrong unit";
624 R.failMaterialization();
625 },
626 [&](const JITDylib &JD, SymbolStringPtr Name) {
627 EXPECT_EQ(Name, Bar) << "Expected \"Bar\" to be discarded";
628 DuplicateBarDiscarded = true;
629 });
630
631 cantFail(JD.define(MU1));
632 cantFail(JD.define(MU2));
633
634 bool OnResolvedRun = false;
635 bool OnReadyRun = false;
636
637 auto OnResolution = [&](Expected<SymbolMap> Result) {
638 cantFail(std::move(Result));
639 OnResolvedRun = true;
640 };
641
642 auto OnReady = [&](Error Err) {
643 cantFail(std::move(Err));
644 OnReadyRun = true;
645 };
646
647 ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, std::move(OnResolution),
648 std::move(OnReady), NoDependenciesToRegister);
649
650 EXPECT_TRUE(OnResolvedRun) << "OnResolved not run";
651 EXPECT_TRUE(OnReadyRun) << "OnReady not run";
652 EXPECT_TRUE(BarMaterialized) << "Bar was not materialized at all";
653 EXPECT_TRUE(DuplicateBarDiscarded)
654 << "Duplicate bar definition not discarded";
655 }
656
TEST_F(CoreAPIsStandardTest,DefineMaterializingSymbol)657 TEST_F(CoreAPIsStandardTest, DefineMaterializingSymbol) {
658 bool ExpectNoMoreMaterialization = false;
659 ES.setDispatchMaterialization(
660 [&](JITDylib &JD, std::unique_ptr<MaterializationUnit> MU) {
661 if (ExpectNoMoreMaterialization)
662 ADD_FAILURE() << "Unexpected materialization";
663 MU->doMaterialize(JD);
664 });
665
666 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
667 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
668 [&](MaterializationResponsibility R) {
669 cantFail(
670 R.defineMaterializing(SymbolFlagsMap({{Bar, BarSym.getFlags()}})));
671 R.resolve(SymbolMap({{Foo, FooSym}, {Bar, BarSym}}));
672 R.emit();
673 });
674
675 cantFail(JD.define(MU));
676 cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
677
678 // Assert that materialization is complete by now.
679 ExpectNoMoreMaterialization = true;
680
681 // Look up bar to verify that no further materialization happens.
682 auto BarResult = cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Bar));
683 EXPECT_EQ(BarResult.getAddress(), BarSym.getAddress())
684 << "Expected Bar == BarSym";
685 }
686
TEST_F(CoreAPIsStandardTest,GeneratorTest)687 TEST_F(CoreAPIsStandardTest, GeneratorTest) {
688 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
689
690 JD.setGenerator([&](JITDylib &JD2, const SymbolNameSet &Names) {
691 cantFail(JD2.define(absoluteSymbols({{Bar, BarSym}})));
692 return SymbolNameSet({Bar});
693 });
694
695 auto Result =
696 cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo, Bar}));
697
698 EXPECT_EQ(Result.count(Bar), 1U) << "Expected to find fallback def for 'bar'";
699 EXPECT_EQ(Result[Bar].getAddress(), BarSym.getAddress())
700 << "Expected fallback def for Bar to be equal to BarSym";
701 }
702
TEST_F(CoreAPIsStandardTest,FailResolution)703 TEST_F(CoreAPIsStandardTest, FailResolution) {
704 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
705 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported | JITSymbolFlags::Weak},
706 {Bar, JITSymbolFlags::Exported | JITSymbolFlags::Weak}}),
707 [&](MaterializationResponsibility R) { R.failMaterialization(); });
708
709 cantFail(JD.define(MU));
710
711 SymbolNameSet Names({Foo, Bar});
712 auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), Names);
713
714 EXPECT_FALSE(!!Result) << "Expected failure";
715 if (!Result) {
716 handleAllErrors(Result.takeError(),
717 [&](FailedToMaterialize &F) {
718 EXPECT_EQ(F.getSymbols(), Names)
719 << "Expected to fail on symbols in Names";
720 },
721 [](ErrorInfoBase &EIB) {
722 std::string ErrMsg;
723 {
724 raw_string_ostream ErrOut(ErrMsg);
725 EIB.log(ErrOut);
726 }
727 ADD_FAILURE()
728 << "Expected a FailedToResolve error. Got:\n"
729 << ErrMsg;
730 });
731 }
732 }
733
TEST_F(CoreAPIsStandardTest,TestLookupWithUnthreadedMaterialization)734 TEST_F(CoreAPIsStandardTest, TestLookupWithUnthreadedMaterialization) {
735 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
736 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
737 [&](MaterializationResponsibility R) {
738 R.resolve({{Foo, FooSym}});
739 R.emit();
740 });
741
742 cantFail(JD.define(MU));
743
744 auto FooLookupResult =
745 cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
746
747 EXPECT_EQ(FooLookupResult.getAddress(), FooSym.getAddress())
748 << "lookup returned an incorrect address";
749 EXPECT_EQ(FooLookupResult.getFlags(), FooSym.getFlags())
750 << "lookup returned incorrect flags";
751 }
752
TEST_F(CoreAPIsStandardTest,TestLookupWithThreadedMaterialization)753 TEST_F(CoreAPIsStandardTest, TestLookupWithThreadedMaterialization) {
754 #if LLVM_ENABLE_THREADS
755
756 std::thread MaterializationThread;
757 ES.setDispatchMaterialization(
758 [&](JITDylib &JD, std::unique_ptr<MaterializationUnit> MU) {
759 auto SharedMU = std::shared_ptr<MaterializationUnit>(std::move(MU));
760 MaterializationThread =
761 std::thread([SharedMU, &JD]() { SharedMU->doMaterialize(JD); });
762 });
763
764 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
765
766 auto FooLookupResult =
767 cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
768
769 EXPECT_EQ(FooLookupResult.getAddress(), FooSym.getAddress())
770 << "lookup returned an incorrect address";
771 EXPECT_EQ(FooLookupResult.getFlags(), FooSym.getFlags())
772 << "lookup returned incorrect flags";
773 MaterializationThread.join();
774 #endif
775 }
776
TEST_F(CoreAPIsStandardTest,TestGetRequestedSymbolsAndReplace)777 TEST_F(CoreAPIsStandardTest, TestGetRequestedSymbolsAndReplace) {
778 // Test that GetRequestedSymbols returns the set of symbols that currently
779 // have pending queries, and test that MaterializationResponsibility's
780 // replace method can be used to return definitions to the JITDylib in a new
781 // MaterializationUnit.
782 SymbolNameSet Names({Foo, Bar});
783
784 bool FooMaterialized = false;
785 bool BarMaterialized = false;
786
787 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
788 SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
789 [&](MaterializationResponsibility R) {
790 auto Requested = R.getRequestedSymbols();
791 EXPECT_EQ(Requested.size(), 1U) << "Expected one symbol requested";
792 EXPECT_EQ(*Requested.begin(), Foo) << "Expected \"Foo\" requested";
793
794 auto NewMU = llvm::make_unique<SimpleMaterializationUnit>(
795 SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
796 [&](MaterializationResponsibility R2) {
797 R2.resolve(SymbolMap({{Bar, BarSym}}));
798 R2.emit();
799 BarMaterialized = true;
800 });
801
802 R.replace(std::move(NewMU));
803
804 R.resolve(SymbolMap({{Foo, FooSym}}));
805 R.emit();
806
807 FooMaterialized = true;
808 });
809
810 cantFail(JD.define(MU));
811
812 EXPECT_FALSE(FooMaterialized) << "Foo should not be materialized yet";
813 EXPECT_FALSE(BarMaterialized) << "Bar should not be materialized yet";
814
815 auto FooSymResult =
816 cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
817 EXPECT_EQ(FooSymResult.getAddress(), FooSym.getAddress())
818 << "Address mismatch for Foo";
819
820 EXPECT_TRUE(FooMaterialized) << "Foo should be materialized now";
821 EXPECT_FALSE(BarMaterialized) << "Bar still should not be materialized";
822
823 auto BarSymResult =
824 cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Bar));
825 EXPECT_EQ(BarSymResult.getAddress(), BarSym.getAddress())
826 << "Address mismatch for Bar";
827 EXPECT_TRUE(BarMaterialized) << "Bar should be materialized now";
828 }
829
TEST_F(CoreAPIsStandardTest,TestMaterializationResponsibilityDelegation)830 TEST_F(CoreAPIsStandardTest, TestMaterializationResponsibilityDelegation) {
831 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
832 SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
833 [&](MaterializationResponsibility R) {
834 auto R2 = R.delegate({Bar});
835
836 R.resolve({{Foo, FooSym}});
837 R.emit();
838 R2.resolve({{Bar, BarSym}});
839 R2.emit();
840 });
841
842 cantFail(JD.define(MU));
843
844 auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo, Bar});
845
846 EXPECT_TRUE(!!Result) << "Result should be a success value";
847 EXPECT_EQ(Result->count(Foo), 1U) << "\"Foo\" entry missing";
848 EXPECT_EQ(Result->count(Bar), 1U) << "\"Bar\" entry missing";
849 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
850 << "Address mismatch for \"Foo\"";
851 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
852 << "Address mismatch for \"Bar\"";
853 }
854
TEST_F(CoreAPIsStandardTest,TestMaterializeWeakSymbol)855 TEST_F(CoreAPIsStandardTest, TestMaterializeWeakSymbol) {
856 // Confirm that once a weak definition is selected for materialization it is
857 // treated as strong.
858 JITSymbolFlags WeakExported = JITSymbolFlags::Exported;
859 WeakExported &= JITSymbolFlags::Weak;
860
861 std::unique_ptr<MaterializationResponsibility> FooResponsibility;
862 auto MU = llvm::make_unique<SimpleMaterializationUnit>(
863 SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
864 [&](MaterializationResponsibility R) {
865 FooResponsibility =
866 llvm::make_unique<MaterializationResponsibility>(std::move(R));
867 });
868
869 cantFail(JD.define(MU));
870 auto OnResolution = [](Expected<SymbolMap> Result) {
871 cantFail(std::move(Result));
872 };
873
874 auto OnReady = [](Error Err) { cantFail(std::move(Err)); };
875
876 ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, std::move(OnResolution),
877 std::move(OnReady), NoDependenciesToRegister);
878
879 auto MU2 = llvm::make_unique<SimpleMaterializationUnit>(
880 SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
881 [](MaterializationResponsibility R) {
882 llvm_unreachable("This unit should never be materialized");
883 });
884
885 auto Err = JD.define(MU2);
886 EXPECT_TRUE(!!Err) << "Expected failure value";
887 EXPECT_TRUE(Err.isA<DuplicateDefinition>())
888 << "Expected a duplicate definition error";
889 consumeError(std::move(Err));
890
891 FooResponsibility->resolve(SymbolMap({{Foo, FooSym}}));
892 FooResponsibility->emit();
893 }
894
895 } // namespace
896