[llvm] r230542 - [Orc][Kaleidoscope] Clean up the Orc/Kaleidoscope tutorials to minimize the diffs
Lang Hames
lhames at gmail.com
Wed Feb 25 12:58:28 PST 2015
Author: lhames
Date: Wed Feb 25 14:58:28 2015
New Revision: 230542
URL: http://llvm.org/viewvc/llvm-project?rev=230542&view=rev
Log:
[Orc][Kaleidoscope] Clean up the Orc/Kaleidoscope tutorials to minimize the diffs
between them.
Modified:
llvm/trunk/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp
llvm/trunk/examples/Kaleidoscope/Orc/initial/toy.cpp
llvm/trunk/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp
llvm/trunk/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp
Modified: llvm/trunk/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp?rev=230542&r1=230541&r2=230542&view=diff
==============================================================================
--- llvm/trunk/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp (original)
+++ llvm/trunk/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp Wed Feb 25 14:58:28 2015
@@ -682,13 +682,18 @@ std::string MakeLegalFunctionName(std::s
class SessionContext {
public:
- SessionContext(LLVMContext &C) : Context(C) {}
+ SessionContext(LLVMContext &C)
+ : Context(C), TM(EngineBuilder().selectTarget()) {}
LLVMContext& getLLVMContext() const { return Context; }
+ TargetMachine& getTarget() { return *TM; }
void addPrototypeAST(std::unique_ptr<PrototypeAST> P);
PrototypeAST* getPrototypeAST(const std::string &Name);
private:
typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
+
LLVMContext &Context;
+ std::unique_ptr<TargetMachine> TM;
+
PrototypeMap Prototypes;
};
@@ -710,7 +715,9 @@ public:
: Session(S),
M(new Module(GenerateUniqueName("jit_module_"),
Session.getLLVMContext())),
- Builder(Session.getLLVMContext()) {}
+ Builder(Session.getLLVMContext()) {
+ M->setDataLayout(Session.getTarget().getDataLayout());
+ }
SessionContext& getSession() { return Session; }
Module& getM() const { return *M; }
@@ -1139,6 +1146,12 @@ static std::unique_ptr<llvm::Module> IRG
return C.takeM();
}
+template <typename T>
+static std::vector<T> singletonSet(T t) {
+ std::vector<T> Vec;
+ Vec.push_back(std::move(t));
+ return Vec;
+}
static void EarthShatteringKaboom() {
fprintf(stderr, "Earth shattering kaboom.");
@@ -1150,44 +1163,40 @@ public:
typedef ObjectLinkingLayer<> ObjLayerT;
typedef IRCompileLayer<ObjLayerT> CompileLayerT;
typedef LazyEmittingLayer<CompileLayerT> LazyEmitLayerT;
-
typedef LazyEmitLayerT::ModuleSetHandleT ModuleHandleT;
- std::string Mangle(const std::string &Name) {
- std::string MangledName;
- {
- raw_string_ostream MangledNameStream(MangledName);
- Mang.getNameWithPrefix(MangledNameStream, Name);
- }
- return MangledName;
- }
-
KaleidoscopeJIT(SessionContext &Session)
- : TM(EngineBuilder().selectTarget()),
- Mang(TM->getDataLayout()), Session(Session),
+ : Session(Session),
+ Mang(Session.getTarget().getDataLayout()),
ObjectLayer(
[](){ return llvm::make_unique<SectionMemoryManager>(); }),
- CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
+ CompileLayer(ObjectLayer, SimpleCompiler(Session.getTarget())),
LazyEmitLayer(CompileLayer),
CompileCallbacks(LazyEmitLayer, Session.getLLVMContext(),
reinterpret_cast<uintptr_t>(EarthShatteringKaboom),
64) {}
- ModuleHandleT addModule(std::unique_ptr<Module> M) {
- if (!M->getDataLayout())
- M->setDataLayout(TM->getDataLayout());
+ std::string mangle(const std::string &Name) {
+ std::string MangledName;
+ {
+ raw_string_ostream MangledNameStream(MangledName);
+ Mang.getNameWithPrefix(MangledNameStream, Name);
+ }
+ return MangledName;
+ }
- // The LazyEmitLayer takes lists of modules, rather than single modules, so
- // we'll just build a single-element list.
- std::vector<std::unique_ptr<Module>> S;
- S.push_back(std::move(M));
+ void addFunctionDefinition(std::unique_ptr<FunctionAST> FnAST) {
+ FunctionDefs[mangle(FnAST->Proto->Name)] = std::move(FnAST);
+ }
+ ModuleHandleT addModule(std::unique_ptr<Module> M) {
// We need a memory manager to allocate memory and resolve symbols for this
- // new module. Create one that resolves symbols by looking back into the JIT.
+ // new module. Create one that resolves symbols by looking back into the
+ // JIT.
auto MM = createLookasideRTDyldMM<SectionMemoryManager>(
[&](const std::string &Name) {
// First try to find 'Name' within the JIT.
- if (auto Symbol = findMangledSymbol(Name))
+ if (auto Symbol = findSymbol(Name))
return Symbol.getAddress();
// If we don't already have a definition of 'Name' then search
@@ -1196,29 +1205,22 @@ public:
},
[](const std::string &S) { return 0; } );
- return LazyEmitLayer.addModuleSet(std::move(S), std::move(MM));
+ return LazyEmitLayer.addModuleSet(singletonSet(std::move(M)),
+ std::move(MM));
}
void removeModule(ModuleHandleT H) { LazyEmitLayer.removeModuleSet(H); }
- JITSymbol findMangledSymbol(const std::string &Name) {
- return LazyEmitLayer.findSymbol(Name, true);
- }
-
- JITSymbol findMangledSymbolIn(ModuleHandleT H, const std::string &Name) {
- return LazyEmitLayer.findSymbolIn(H, Name, true);
- }
-
JITSymbol findSymbol(const std::string &Name) {
- return findMangledSymbol(Mangle(Name));
+ return LazyEmitLayer.findSymbol(Name, true);
}
JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
- return findMangledSymbolIn(H, Mangle(Name));
+ return LazyEmitLayer.findSymbolIn(H, Name, true);
}
- void addFunctionDefinition(std::unique_ptr<FunctionAST> FnAST) {
- FunctionDefs[Mangle(FnAST->Proto->Name)] = std::move(FnAST);
+ JITSymbol findUnmangledSymbol(const std::string &Name) {
+ return findSymbol(mangle(Name));
}
private:
@@ -1239,7 +1241,7 @@ private:
FunctionDefs.erase(DefI);
// Return the address of the stub.
- return findMangledSymbolIn(H, Name).getAddress();
+ return findSymbolIn(H, Name).getAddress();
}
// This method will take the AST for a function definition and IR-gen a stub
@@ -1250,7 +1252,6 @@ private:
// the function.
IRGenContext C(Session);
Function *F = FnAST->Proto->IRGen(C);
- C.getM().setDataLayout(TM->getDataLayout());
// Step 2) Get a compile callback that can be used to compile the body of
// the function. The resulting CallbackInfo type will let us set the
@@ -1286,15 +1287,13 @@ private:
return findSymbolIn(H, Fn->Proto->Name).getAddress();
});
CallbackInfo.setUpdateAction(
- CompileCallbacks.getLocalFPUpdater(H, Mangle(BodyPtrName)));
+ CompileCallbacks.getLocalFPUpdater(H, mangle(BodyPtrName)));
return H;
}
- std::unique_ptr<TargetMachine> TM;
- Mangler Mang;
SessionContext &Session;
-
+ Mangler Mang;
ObjLayerT ObjectLayer;
CompileLayerT CompileLayer;
LazyEmitLayerT LazyEmitLayer;
@@ -1337,7 +1336,7 @@ static void HandleTopLevelExpression(Ses
auto H = J.addModule(C.takeM());
// Get the address of the JIT'd function in memory.
- auto ExprSymbol = J.findSymbol("__anon_expr");
+ auto ExprSymbol = J.findUnmangledSymbol("__anon_expr");
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
Modified: llvm/trunk/examples/Kaleidoscope/Orc/initial/toy.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kaleidoscope/Orc/initial/toy.cpp?rev=230542&r1=230541&r2=230542&view=diff
==============================================================================
--- llvm/trunk/examples/Kaleidoscope/Orc/initial/toy.cpp (original)
+++ llvm/trunk/examples/Kaleidoscope/Orc/initial/toy.cpp Wed Feb 25 14:58:28 2015
@@ -1,4 +1,3 @@
-
#include "llvm/Analysis/Passes.h"
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
@@ -7,8 +6,8 @@
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Support/TargetSelect.h"
@@ -682,13 +681,18 @@ std::string MakeLegalFunctionName(std::s
class SessionContext {
public:
- SessionContext(LLVMContext &C) : Context(C) {}
+ SessionContext(LLVMContext &C)
+ : Context(C), TM(EngineBuilder().selectTarget()) {}
LLVMContext& getLLVMContext() const { return Context; }
+ TargetMachine& getTarget() { return *TM; }
void addPrototypeAST(std::unique_ptr<PrototypeAST> P);
PrototypeAST* getPrototypeAST(const std::string &Name);
private:
typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
+
LLVMContext &Context;
+ std::unique_ptr<TargetMachine> TM;
+
PrototypeMap Prototypes;
};
@@ -710,7 +714,9 @@ public:
: Session(S),
M(new Module(GenerateUniqueName("jit_module_"),
Session.getLLVMContext())),
- Builder(Session.getLLVMContext()) {}
+ Builder(Session.getLLVMContext()) {
+ M->setDataLayout(Session.getTarget().getDataLayout());
+ }
SessionContext& getSession() { return Session; }
Module& getM() const { return *M; }
@@ -1126,75 +1132,75 @@ Function *FunctionAST::IRGen(IRGenContex
// Top-Level parsing and JIT Driver
//===----------------------------------------------------------------------===//
+static std::unique_ptr<llvm::Module> IRGen(SessionContext &S,
+ const FunctionAST &F) {
+ IRGenContext C(S);
+ auto LF = F.IRGen(C);
+ if (!LF)
+ return nullptr;
+#ifndef MINIMAL_STDERR_OUTPUT
+ fprintf(stderr, "Read function definition:");
+ LF->dump();
+#endif
+ return C.takeM();
+}
+
+template <typename T>
+static std::vector<T> singletonSet(T t) {
+ std::vector<T> Vec;
+ Vec.push_back(std::move(t));
+ return Vec;
+}
+
class KaleidoscopeJIT {
public:
typedef ObjectLinkingLayer<> ObjLayerT;
typedef IRCompileLayer<ObjLayerT> CompileLayerT;
-
typedef CompileLayerT::ModuleSetHandleT ModuleHandleT;
- KaleidoscopeJIT()
- : TM(EngineBuilder().selectTarget()),
- Mang(TM->getDataLayout()),
- CompileLayer(ObjectLayer, SimpleCompiler(*TM)) {}
+ KaleidoscopeJIT(SessionContext &Session)
+ : Mang(Session.getTarget().getDataLayout()),
+ CompileLayer(ObjectLayer, SimpleCompiler(Session.getTarget())) {}
- ModuleHandleT addModule(std::unique_ptr<Module> M) {
- if (!M->getDataLayout())
- M->setDataLayout(TM->getDataLayout());
-
- // The LazyEmitLayer takes lists of modules, rather than single modules, so
- // we'll just build a single-element list.
- std::vector<std::unique_ptr<Module>> S;
- S.push_back(std::move(M));
+ std::string mangle(const std::string &Name) {
+ std::string MangledName;
+ {
+ raw_string_ostream MangledNameStream(MangledName);
+ Mang.getNameWithPrefix(MangledNameStream, Name);
+ }
+ return MangledName;
+ }
+ ModuleHandleT addModule(std::unique_ptr<Module> M) {
// We need a memory manager to allocate memory and resolve symbols for this
- // new module. Create one that resolves symbols by looking back into the JIT.
+ // new module. Create one that resolves symbols by looking back into the
+ // JIT.
auto MM = createLookasideRTDyldMM<SectionMemoryManager>(
[&](const std::string &S) {
- return findMangledSymbol(S).getAddress();
+ return findSymbol(S).getAddress();
},
[](const std::string &S) { return 0; } );
- return CompileLayer.addModuleSet(std::move(S), std::move(MM));
+ return CompileLayer.addModuleSet(singletonSet(std::move(M)), std::move(MM));
}
void removeModule(ModuleHandleT H) { CompileLayer.removeModuleSet(H); }
- JITSymbol findMangledSymbol(const std::string &Name) {
- return CompileLayer.findSymbol(Name, false);
+ JITSymbol findSymbol(const std::string &Name) {
+ return CompileLayer.findSymbol(Name, true);
}
- JITSymbol findSymbol(const std::string Name) {
- std::string MangledName;
- {
- raw_string_ostream MangledNameStream(MangledName);
- Mang.getNameWithPrefix(MangledNameStream, Name);
- }
- return findMangledSymbol(MangledName);
+ JITSymbol findUnmangledSymbol(const std::string Name) {
+ return findSymbol(mangle(Name));
}
private:
- std::unique_ptr<TargetMachine> TM;
Mangler Mang;
-
ObjLayerT ObjectLayer;
CompileLayerT CompileLayer;
};
-static std::unique_ptr<llvm::Module> IRGen(SessionContext &S,
- const FunctionAST &F) {
- IRGenContext C(S);
- auto LF = F.IRGen(C);
- if (!LF)
- return nullptr;
-#ifndef MINIMAL_STDERR_OUTPUT
- fprintf(stderr, "Read function definition:");
- LF->dump();
-#endif
- return C.takeM();
-}
-
static void HandleDefinition(SessionContext &S, KaleidoscopeJIT &J) {
if (auto F = ParseDefinition()) {
if (auto M = IRGen(S, *F)) {
@@ -1230,7 +1236,7 @@ static void HandleTopLevelExpression(Ses
auto H = J.addModule(C.takeM());
// Get the address of the JIT'd function in memory.
- auto ExprSymbol = J.findSymbol("__anon_expr");
+ auto ExprSymbol = J.findUnmangledSymbol("__anon_expr");
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
@@ -1252,8 +1258,8 @@ static void HandleTopLevelExpression(Ses
/// top ::= definition | external | expression | ';'
static void MainLoop() {
- KaleidoscopeJIT J;
SessionContext S(getGlobalContext());
+ KaleidoscopeJIT J(S);
while (1) {
switch (CurTok) {
Modified: llvm/trunk/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp?rev=230542&r1=230541&r2=230542&view=diff
==============================================================================
--- llvm/trunk/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp (original)
+++ llvm/trunk/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp Wed Feb 25 14:58:28 2015
@@ -6,8 +6,8 @@
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Support/TargetSelect.h"
@@ -681,13 +681,18 @@ std::string MakeLegalFunctionName(std::s
class SessionContext {
public:
- SessionContext(LLVMContext &C) : Context(C) {}
+ SessionContext(LLVMContext &C)
+ : Context(C), TM(EngineBuilder().selectTarget()) {}
LLVMContext& getLLVMContext() const { return Context; }
+ TargetMachine& getTarget() { return *TM; }
void addPrototypeAST(std::unique_ptr<PrototypeAST> P);
PrototypeAST* getPrototypeAST(const std::string &Name);
private:
typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
+
LLVMContext &Context;
+ std::unique_ptr<TargetMachine> TM;
+
PrototypeMap Prototypes;
};
@@ -709,7 +714,9 @@ public:
: Session(S),
M(new Module(GenerateUniqueName("jit_module_"),
Session.getLLVMContext())),
- Builder(Session.getLLVMContext()) {}
+ Builder(Session.getLLVMContext()) {
+ M->setDataLayout(Session.getTarget().getDataLayout());
+ }
SessionContext& getSession() { return Session; }
Module& getM() const { return *M; }
@@ -1125,6 +1132,26 @@ Function *FunctionAST::IRGen(IRGenContex
// Top-Level parsing and JIT Driver
//===----------------------------------------------------------------------===//
+static std::unique_ptr<llvm::Module> IRGen(SessionContext &S,
+ const FunctionAST &F) {
+ IRGenContext C(S);
+ auto LF = F.IRGen(C);
+ if (!LF)
+ return nullptr;
+#ifndef MINIMAL_STDERR_OUTPUT
+ fprintf(stderr, "Read function definition:");
+ LF->dump();
+#endif
+ return C.takeM();
+}
+
+template <typename T>
+static std::vector<T> singletonSet(T t) {
+ std::vector<T> Vec;
+ Vec.push_back(std::move(t));
+ return Vec;
+}
+
class KaleidoscopeJIT {
public:
typedef ObjectLinkingLayer<> ObjLayerT;
@@ -1133,70 +1160,52 @@ public:
typedef LazyEmitLayerT::ModuleSetHandleT ModuleHandleT;
- KaleidoscopeJIT()
- : TM(EngineBuilder().selectTarget()),
- Mang(TM->getDataLayout()),
- CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
+ KaleidoscopeJIT(SessionContext &Session)
+ : Mang(Session.getTarget().getDataLayout()),
+ CompileLayer(ObjectLayer, SimpleCompiler(Session.getTarget())),
LazyEmitLayer(CompileLayer) {}
- ModuleHandleT addModule(std::unique_ptr<Module> M) {
- if (!M->getDataLayout())
- M->setDataLayout(TM->getDataLayout());
-
- // The LazyEmitLayer takes lists of modules, rather than single modules, so
- // we'll just build a single-element list.
- std::vector<std::unique_ptr<Module>> S;
- S.push_back(std::move(M));
+ std::string mangle(const std::string &Name) {
+ std::string MangledName;
+ {
+ raw_string_ostream MangledNameStream(MangledName);
+ Mang.getNameWithPrefix(MangledNameStream, Name);
+ }
+ return MangledName;
+ }
+ ModuleHandleT addModule(std::unique_ptr<Module> M) {
// We need a memory manager to allocate memory and resolve symbols for this
- // new module. Create one that resolves symbols by looking back into the JIT.
+ // new module. Create one that resolves symbols by looking back into the
+ // JIT.
auto MM = createLookasideRTDyldMM<SectionMemoryManager>(
- [&](const std::string &S) {
- return findMangledSymbol(S).getAddress();
+ [&](const std::string &Name) {
+ return findSymbol(Name).getAddress();
},
[](const std::string &S) { return 0; } );
- return LazyEmitLayer.addModuleSet(std::move(S), std::move(MM));
+ return LazyEmitLayer.addModuleSet(singletonSet(std::move(M)),
+ std::move(MM));
}
void removeModule(ModuleHandleT H) { LazyEmitLayer.removeModuleSet(H); }
- JITSymbol findMangledSymbol(const std::string &Name) {
- return LazyEmitLayer.findSymbol(Name, false);
+ JITSymbol findSymbol(const std::string &Name) {
+ return LazyEmitLayer.findSymbol(Name, true);
}
- JITSymbol findSymbol(const std::string Name) {
- std::string MangledName;
- {
- raw_string_ostream MangledNameStream(MangledName);
- Mang.getNameWithPrefix(MangledNameStream, Name);
- }
- return findMangledSymbol(MangledName);
+ JITSymbol findUnmangledSymbol(const std::string Name) {
+ return findSymbol(mangle(Name));
}
private:
- std::unique_ptr<TargetMachine> TM;
Mangler Mang;
-
ObjLayerT ObjectLayer;
CompileLayerT CompileLayer;
LazyEmitLayerT LazyEmitLayer;
};
-static std::unique_ptr<llvm::Module> IRGen(SessionContext &S,
- const FunctionAST &F) {
- IRGenContext C(S);
- auto LF = F.IRGen(C);
- if (!LF)
- return nullptr;
-#ifndef MINIMAL_STDERR_OUTPUT
- fprintf(stderr, "Read function definition:");
- LF->dump();
-#endif
- return C.takeM();
-}
-
static void HandleDefinition(SessionContext &S, KaleidoscopeJIT &J) {
if (auto F = ParseDefinition()) {
if (auto M = IRGen(S, *F)) {
@@ -1232,7 +1241,7 @@ static void HandleTopLevelExpression(Ses
auto H = J.addModule(C.takeM());
// Get the address of the JIT'd function in memory.
- auto ExprSymbol = J.findSymbol("__anon_expr");
+ auto ExprSymbol = J.findUnmangledSymbol("__anon_expr");
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
@@ -1254,8 +1263,8 @@ static void HandleTopLevelExpression(Ses
/// top ::= definition | external | expression | ';'
static void MainLoop() {
- KaleidoscopeJIT J;
SessionContext S(getGlobalContext());
+ KaleidoscopeJIT J(S);
while (1) {
switch (CurTok) {
Modified: llvm/trunk/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp?rev=230542&r1=230541&r2=230542&view=diff
==============================================================================
--- llvm/trunk/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp (original)
+++ llvm/trunk/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp Wed Feb 25 14:58:28 2015
@@ -681,13 +681,18 @@ std::string MakeLegalFunctionName(std::s
class SessionContext {
public:
- SessionContext(LLVMContext &C) : Context(C) {}
+ SessionContext(LLVMContext &C)
+ : Context(C), TM(EngineBuilder().selectTarget()) {}
LLVMContext& getLLVMContext() const { return Context; }
+ TargetMachine& getTarget() { return *TM; }
void addPrototypeAST(std::unique_ptr<PrototypeAST> P);
PrototypeAST* getPrototypeAST(const std::string &Name);
private:
typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
+
LLVMContext &Context;
+ std::unique_ptr<TargetMachine> TM;
+
PrototypeMap Prototypes;
};
@@ -709,7 +714,9 @@ public:
: Session(S),
M(new Module(GenerateUniqueName("jit_module_"),
Session.getLLVMContext())),
- Builder(Session.getLLVMContext()) {}
+ Builder(Session.getLLVMContext()) {
+ M->setDataLayout(Session.getTarget().getDataLayout());
+ }
SessionContext& getSession() { return Session; }
Module& getM() const { return *M; }
@@ -1138,15 +1145,27 @@ static std::unique_ptr<llvm::Module> IRG
return C.takeM();
}
+template <typename T>
+static std::vector<T> singletonSet(T t) {
+ std::vector<T> Vec;
+ Vec.push_back(std::move(t));
+ return Vec;
+}
+
class KaleidoscopeJIT {
public:
typedef ObjectLinkingLayer<> ObjLayerT;
typedef IRCompileLayer<ObjLayerT> CompileLayerT;
typedef LazyEmittingLayer<CompileLayerT> LazyEmitLayerT;
-
typedef LazyEmitLayerT::ModuleSetHandleT ModuleHandleT;
- std::string Mangle(const std::string &Name) {
+ KaleidoscopeJIT(SessionContext &Session)
+ : Session(Session),
+ Mang(Session.getTarget().getDataLayout()),
+ CompileLayer(ObjectLayer, SimpleCompiler(Session.getTarget())),
+ LazyEmitLayer(CompileLayer) {}
+
+ std::string mangle(const std::string &Name) {
std::string MangledName;
{
raw_string_ostream MangledNameStream(MangledName);
@@ -1155,27 +1174,18 @@ public:
return MangledName;
}
- KaleidoscopeJIT(SessionContext &Session)
- : TM(EngineBuilder().selectTarget()),
- Mang(TM->getDataLayout()), Session(Session),
- CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
- LazyEmitLayer(CompileLayer) {}
+ void addFunctionDefinition(std::unique_ptr<FunctionAST> FnAST) {
+ FunctionDefs[mangle(FnAST->Proto->Name)] = std::move(FnAST);
+ }
ModuleHandleT addModule(std::unique_ptr<Module> M) {
- if (!M->getDataLayout())
- M->setDataLayout(TM->getDataLayout());
-
- // The LazyEmitLayer takes lists of modules, rather than single modules, so
- // we'll just build a single-element list.
- std::vector<std::unique_ptr<Module>> S;
- S.push_back(std::move(M));
-
// We need a memory manager to allocate memory and resolve symbols for this
- // new module. Create one that resolves symbols by looking back into the JIT.
+ // new module. Create one that resolves symbols by looking back into the
+ // JIT.
auto MM = createLookasideRTDyldMM<SectionMemoryManager>(
[&](const std::string &Name) {
// First try to find 'Name' within the JIT.
- if (auto Symbol = findMangledSymbol(Name))
+ if (auto Symbol = findSymbol(Name))
return Symbol.getAddress();
// If we don't already have a definition of 'Name' then search
@@ -1184,25 +1194,22 @@ public:
},
[](const std::string &S) { return 0; } );
- return LazyEmitLayer.addModuleSet(std::move(S), std::move(MM));
+ return LazyEmitLayer.addModuleSet(singletonSet(std::move(M)),
+ std::move(MM));
}
void removeModule(ModuleHandleT H) { LazyEmitLayer.removeModuleSet(H); }
- JITSymbol findMangledSymbol(const std::string &Name) {
+ JITSymbol findSymbol(const std::string &Name) {
return LazyEmitLayer.findSymbol(Name, true);
}
- JITSymbol findMangledSymbolIn(ModuleHandleT H, const std::string &Name) {
+ JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
return LazyEmitLayer.findSymbolIn(H, Name, true);
}
- JITSymbol findSymbol(const std::string &Name) {
- return findMangledSymbol(Mangle(Name));
- }
-
- void addFunctionDefinition(std::unique_ptr<FunctionAST> FnAST) {
- FunctionDefs[Mangle(FnAST->Proto->Name)] = std::move(FnAST);
+ JITSymbol findUnmangledSymbol(const std::string &Name) {
+ return findSymbol(mangle(Name));
}
private:
@@ -1224,13 +1231,11 @@ private:
FunctionDefs.erase(DefI);
// Return the address of the function.
- return findMangledSymbolIn(H, Name).getAddress();
+ return findSymbolIn(H, Name).getAddress();
}
- std::unique_ptr<TargetMachine> TM;
- Mangler Mang;
SessionContext &Session;
-
+ Mangler Mang;
ObjLayerT ObjectLayer;
CompileLayerT CompileLayer;
LazyEmitLayerT LazyEmitLayer;
@@ -1271,7 +1276,7 @@ static void HandleTopLevelExpression(Ses
auto H = J.addModule(C.takeM());
// Get the address of the JIT'd function in memory.
- auto ExprSymbol = J.findSymbol("__anon_expr");
+ auto ExprSymbol = J.findUnmangledSymbol("__anon_expr");
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
More information about the llvm-commits
mailing list