1 //===--- RTDyldObjectLinkingLayerTest.cpp - RTDyld linking layer tests ---===//
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/ExecutionEngine.h"
11 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
12 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
13 #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
14 #include "llvm/ExecutionEngine/Orc/Legacy.h"
15 #include "llvm/ExecutionEngine/Orc/NullResolver.h"
16 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
17 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "gtest/gtest.h"
21 
22 using namespace llvm;
23 using namespace llvm::orc;
24 
25 namespace {
26 
27 class RTDyldObjectLinkingLayerExecutionTest : public testing::Test,
28                                                public OrcExecutionTest {};
29 
30 // Adds an object with a debug section to RuntimeDyld and then returns whether
31 // the debug section was passed to the memory manager.
32 static bool testSetProcessAllSections(std::unique_ptr<MemoryBuffer> Obj,
33                                       bool ProcessAllSections) {
34   class MemoryManagerWrapper : public SectionMemoryManager {
35   public:
36     MemoryManagerWrapper(bool &DebugSeen) : DebugSeen(DebugSeen) {}
37     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
38                                  unsigned SectionID, StringRef SectionName,
39                                  bool IsReadOnly) override {
40       if (SectionName == ".debug_str")
41         DebugSeen = true;
42       return SectionMemoryManager::allocateDataSection(
43           Size, Alignment, SectionID, SectionName, IsReadOnly);
44     }
45 
46   private:
47     bool &DebugSeen;
48   };
49 
50   bool DebugSectionSeen = false;
51 
52   ExecutionSession ES;
53   auto &JD = ES.createJITDylib("main");
54   auto Foo = ES.intern("foo");
55 
56   RTDyldObjectLinkingLayer ObjLayer(ES, [&DebugSectionSeen]() {
57     return std::make_unique<MemoryManagerWrapper>(DebugSectionSeen);
58   });
59 
60   auto OnResolveDoNothing = [](Expected<SymbolMap> R) {
61     cantFail(std::move(R));
62   };
63 
64   ObjLayer.setProcessAllSections(ProcessAllSections);
65   cantFail(ObjLayer.add(JD, std::move(Obj), ES.allocateVModule()));
66   ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
67             SymbolLookupSet(Foo), SymbolState::Resolved, OnResolveDoNothing,
68             NoDependenciesToRegister);
69 
70   return DebugSectionSeen;
71 }
72 
73 TEST(RTDyldObjectLinkingLayerTest, TestSetProcessAllSections) {
74   LLVMContext Context;
75   auto M = std::make_unique<Module>("", Context);
76   M->setTargetTriple("x86_64-unknown-linux-gnu");
77   Type *Int32Ty = IntegerType::get(Context, 32);
78   GlobalVariable *GV =
79       new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
80                          ConstantInt::get(Int32Ty, 42), "foo");
81 
82   GV->setSection(".debug_str");
83 
84   // Initialize the native target in case this is the first unit test
85   // to try to build a TM.
86   OrcNativeTarget::initialize();
87   std::unique_ptr<TargetMachine> TM(EngineBuilder().selectTarget(
88       Triple(M->getTargetTriple()), "", "", SmallVector<std::string, 1>()));
89   if (!TM)
90     return;
91 
92   auto Obj = SimpleCompiler(*TM)(*M);
93 
94   EXPECT_FALSE(testSetProcessAllSections(
95       MemoryBuffer::getMemBufferCopy(Obj->getBuffer()), false))
96       << "Debug section seen despite ProcessAllSections being false";
97   EXPECT_TRUE(testSetProcessAllSections(std::move(Obj), true))
98       << "Expected to see debug section when ProcessAllSections is true";
99 }
100 
101 TEST(RTDyldObjectLinkingLayerTest, TestOverrideObjectFlags) {
102 
103   OrcNativeTarget::initialize();
104 
105   std::unique_ptr<TargetMachine> TM(
106       EngineBuilder().selectTarget(Triple("x86_64-unknown-linux-gnu"), "", "",
107                                    SmallVector<std::string, 1>()));
108 
109   if (!TM)
110     return;
111 
112   // Our compiler is going to modify symbol visibility settings without telling
113   // ORC. This will test our ability to override the flags later.
114   class FunkySimpleCompiler : public SimpleCompiler {
115   public:
116     FunkySimpleCompiler(TargetMachine &TM) : SimpleCompiler(TM) {}
117 
118     CompileResult operator()(Module &M) {
119       auto *Foo = M.getFunction("foo");
120       assert(Foo && "Expected function Foo not found");
121       Foo->setVisibility(GlobalValue::HiddenVisibility);
122       return SimpleCompiler::operator()(M);
123     }
124   };
125 
126   // Create a module with two void() functions: foo and bar.
127   ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
128   ThreadSafeModule M;
129   {
130     ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy");
131     MB.getModule()->setDataLayout(TM->createDataLayout());
132 
133     Function *FooImpl = MB.createFunctionDecl(
134         FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
135         "foo");
136     BasicBlock *FooEntry =
137         BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
138     IRBuilder<> B1(FooEntry);
139     B1.CreateRetVoid();
140 
141     Function *BarImpl = MB.createFunctionDecl(
142         FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
143         "bar");
144     BasicBlock *BarEntry =
145         BasicBlock::Create(*TSCtx.getContext(), "entry", BarImpl);
146     IRBuilder<> B2(BarEntry);
147     B2.CreateRetVoid();
148 
149     M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
150   }
151 
152   // Create a simple stack and set the override flags option.
153   ExecutionSession ES;
154   auto &JD = ES.createJITDylib("main");
155   auto Foo = ES.intern("foo");
156   RTDyldObjectLinkingLayer ObjLayer(
157       ES, []() { return std::make_unique<SectionMemoryManager>(); });
158   IRCompileLayer CompileLayer(ES, ObjLayer, FunkySimpleCompiler(*TM));
159 
160   ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
161 
162   cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
163   ES.lookup(
164       LookupKind::Static, makeJITDylibSearchOrder(&JD), SymbolLookupSet(Foo),
165       SymbolState::Resolved,
166       [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
167       NoDependenciesToRegister);
168 }
169 
170 TEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) {
171 
172   OrcNativeTarget::initialize();
173 
174   std::unique_ptr<TargetMachine> TM(
175       EngineBuilder().selectTarget(Triple("x86_64-unknown-linux-gnu"), "", "",
176                                    SmallVector<std::string, 1>()));
177 
178   if (!TM)
179     return;
180 
181   // Our compiler is going to add a new symbol without telling ORC.
182   // This will test our ability to auto-claim responsibility later.
183   class FunkySimpleCompiler : public SimpleCompiler {
184   public:
185     FunkySimpleCompiler(TargetMachine &TM) : SimpleCompiler(TM) {}
186 
187     CompileResult operator()(Module &M) {
188       Function *BarImpl = Function::Create(
189           FunctionType::get(Type::getVoidTy(M.getContext()), {}, false),
190           GlobalValue::ExternalLinkage, "bar", &M);
191       BasicBlock *BarEntry =
192           BasicBlock::Create(M.getContext(), "entry", BarImpl);
193       IRBuilder<> B(BarEntry);
194       B.CreateRetVoid();
195 
196       return SimpleCompiler::operator()(M);
197     }
198   };
199 
200   // Create a module with two void() functions: foo and bar.
201   ThreadSafeContext TSCtx(std::make_unique<LLVMContext>());
202   ThreadSafeModule M;
203   {
204     ModuleBuilder MB(*TSCtx.getContext(), TM->getTargetTriple().str(), "dummy");
205     MB.getModule()->setDataLayout(TM->createDataLayout());
206 
207     Function *FooImpl = MB.createFunctionDecl(
208         FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
209         "foo");
210     BasicBlock *FooEntry =
211         BasicBlock::Create(*TSCtx.getContext(), "entry", FooImpl);
212     IRBuilder<> B(FooEntry);
213     B.CreateRetVoid();
214 
215     M = ThreadSafeModule(MB.takeModule(), std::move(TSCtx));
216   }
217 
218   // Create a simple stack and set the override flags option.
219   ExecutionSession ES;
220   auto &JD = ES.createJITDylib("main");
221   auto Foo = ES.intern("foo");
222   RTDyldObjectLinkingLayer ObjLayer(
223       ES, []() { return std::make_unique<SectionMemoryManager>(); });
224   IRCompileLayer CompileLayer(ES, ObjLayer, FunkySimpleCompiler(*TM));
225 
226   ObjLayer.setAutoClaimResponsibilityForObjectSymbols(true);
227 
228   cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
229   ES.lookup(
230       LookupKind::Static, makeJITDylibSearchOrder(&JD), SymbolLookupSet(Foo),
231       SymbolState::Resolved,
232       [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
233       NoDependenciesToRegister);
234 }
235 
236 } // end anonymous namespace
237