[Orc][Kaleidoscope] Clean up the Orc/Kaleidoscope tutorials to minimize the diffs
between them.
llvm-svn: 230542
diff --git a/llvm/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp b/llvm/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp
index ee42d79..1ed267d 100644
--- a/llvm/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp
+++ b/llvm/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp
@@ -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 @@
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 @@
: 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,65 +1132,6 @@
// Top-Level parsing and JIT Driver
//===----------------------------------------------------------------------===//
-class KaleidoscopeJIT {
-public:
- typedef ObjectLinkingLayer<> ObjLayerT;
- typedef IRCompileLayer<ObjLayerT> CompileLayerT;
- typedef LazyEmittingLayer<CompileLayerT> LazyEmitLayerT;
-
- typedef LazyEmitLayerT::ModuleSetHandleT ModuleHandleT;
-
- KaleidoscopeJIT()
- : TM(EngineBuilder().selectTarget()),
- Mang(TM->getDataLayout()),
- CompileLayer(ObjectLayer, SimpleCompiler(*TM)),
- 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));
-
- // 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.
- auto MM = createLookasideRTDyldMM<SectionMemoryManager>(
- [&](const std::string &S) {
- return findMangledSymbol(S).getAddress();
- },
- [](const std::string &S) { return 0; } );
-
- return LazyEmitLayer.addModuleSet(std::move(S), 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) {
- std::string MangledName;
- {
- raw_string_ostream MangledNameStream(MangledName);
- Mang.getNameWithPrefix(MangledNameStream, Name);
- }
- return findMangledSymbol(MangledName);
- }
-
-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);
@@ -1197,6 +1145,67 @@
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;
+
+ KaleidoscopeJIT(SessionContext &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);
+ 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.
+ auto MM = createLookasideRTDyldMM<SectionMemoryManager>(
+ [&](const std::string &Name) {
+ return findSymbol(Name).getAddress();
+ },
+ [](const std::string &S) { return 0; } );
+
+ return LazyEmitLayer.addModuleSet(singletonSet(std::move(M)),
+ std::move(MM));
+ }
+
+ void removeModule(ModuleHandleT H) { LazyEmitLayer.removeModuleSet(H); }
+
+ JITSymbol findSymbol(const std::string &Name) {
+ return LazyEmitLayer.findSymbol(Name, true);
+ }
+
+ JITSymbol findUnmangledSymbol(const std::string Name) {
+ return findSymbol(mangle(Name));
+ }
+
+private:
+
+ Mangler Mang;
+ ObjLayerT ObjectLayer;
+ CompileLayerT CompileLayer;
+ LazyEmitLayerT LazyEmitLayer;
+};
+
static void HandleDefinition(SessionContext &S, KaleidoscopeJIT &J) {
if (auto F = ParseDefinition()) {
if (auto M = IRGen(S, *F)) {
@@ -1232,7 +1241,7 @@
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 @@
/// top ::= definition | external | expression | ';'
static void MainLoop() {
- KaleidoscopeJIT J;
SessionContext S(getGlobalContext());
+ KaleidoscopeJIT J(S);
while (1) {
switch (CurTok) {