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