[Orc] Add an Orc layer for applying arbitrary transforms to IR, use it to add

debugging output to the LLI orc-lazy JIT, and update the orc-lazy "hello.ll"
test to actually test for lazy compilation.

llvm-svn: 234805

2 files changed, 90 insertions, 7 deletions

diff --git a/llvm/tools/lli/OrcLazyJIT.cpp b/llvm/tools/lli/OrcLazyJIT.cpp
index 236de7c31d2..519bd72ccd4 100644
--- a/llvm/tools/lli/OrcLazyJIT.cpp
+++ b/llvm/tools/lli/OrcLazyJIT.cpp
@@ -9,26 +9,101 @@
 
 #include "OrcLazyJIT.h"
 #include "llvm/ExecutionEngine/Orc/OrcTargetSupport.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/DynamicLibrary.h"
+#include <system_error>
 
 using namespace llvm;
 
+namespace {
+
+  enum class DumpKind { NoDump, DumpFuncsToStdErr, DumpModsToStdErr,
+                        DumpModsToDisk };
+
+  cl::opt<DumpKind> OrcDumpKind("orc-lazy-debug",
+                                cl::desc("Debug dumping for the orc-lazy JIT."),
+                                cl::init(DumpKind::NoDump),
+                                cl::values(
+                                  clEnumValN(DumpKind::NoDump, "no-dump",
+                                             "Don't dump anything."),
+                                  clEnumValN(DumpKind::DumpFuncsToStdErr,
+                                             "funcs-to-stderr",
+                                             "Dump function names to stderr."),
+                                  clEnumValN(DumpKind::DumpModsToStdErr,
+                                             "mods-to-stderr",
+                                             "Dump modules to stderr."),
+                                  clEnumValN(DumpKind::DumpModsToDisk,
+                                             "mods-to-disk",
+                                             "Dump modules to the current "
+                                             "working directory. (WARNING: "
+                                             "will overwrite existing files)."),
+                                  clEnumValEnd));
+}
+
 OrcLazyJIT::CallbackManagerBuilder
 OrcLazyJIT::createCallbackManagerBuilder(Triple T) {
   switch (T.getArch()) {
     default: return nullptr;
 
     case Triple::x86_64: {
-      typedef orc::JITCompileCallbackManager<CompileLayerT,
+      typedef orc::JITCompileCallbackManager<IRDumpLayerT,
                                              orc::OrcX86_64> CCMgrT;
-      return [](CompileLayerT &CompileLayer, RuntimeDyld::MemoryManager &MemMgr,
+      return [](IRDumpLayerT &IRDumpLayer, RuntimeDyld::MemoryManager &MemMgr,
                 LLVMContext &Context) {
-               return make_unique<CCMgrT>(CompileLayer, MemMgr, Context, 0, 64);
+               return make_unique<CCMgrT>(IRDumpLayer, MemMgr, Context, 0, 64);
              };
     }
   }
 }
 
+OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
+
+  switch (OrcDumpKind) {
+  case DumpKind::NoDump:
+    return [](std::unique_ptr<Module> M) { return std::move(M); };
+
+  case DumpKind::DumpFuncsToStdErr:
+    return [](std::unique_ptr<Module> M) {
+      dbgs() << "[ ";
+
+      for (const auto &F : *M) {
+        if (F.isDeclaration())
+          continue;
+
+        if (F.hasName())
+          dbgs() << F.getName() << " ";
+        else
+          dbgs() << "<anon> ";
+      }
+
+      dbgs() << "]\n";
+      return std::move(M);
+    };
+
+  case DumpKind::DumpModsToStdErr:
+    return [](std::unique_ptr<Module> M) {
+             dbgs() << "----- Module Start -----\n" << *M
+                    << "----- Module End -----\n";
+
+             return std::move(M);
+           };
+
+  case DumpKind::DumpModsToDisk:
+    return [](std::unique_ptr<Module> M) {
+             std::error_code EC;
+             raw_fd_ostream Out(M->getModuleIdentifier() + ".ll", EC,
+                                sys::fs::F_Text);
+             if (EC) {
+               errs() << "Couldn't open " << M->getModuleIdentifier()
+                      << " for dumping.\nError:" << EC.message() << "\n";
+               exit(1);
+             }
+             Out << *M;
+             return std::move(M);
+           };
+  }
+}
+
 int llvm::runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]) {
   // Add the program's symbols into the JIT's search space.
   if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr)) {
diff --git a/llvm/tools/lli/OrcLazyJIT.h b/llvm/tools/lli/OrcLazyJIT.h
index 8e6f400f0c5..3f89f6a5168 100644
--- a/llvm/tools/lli/OrcLazyJIT.h
+++ b/llvm/tools/lli/OrcLazyJIT.h
@@ -20,6 +20,7 @@
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+#include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/LazyEmittingLayer.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
@@ -33,13 +34,16 @@ public:
   typedef orc::JITCompileCallbackManagerBase CompileCallbackMgr;
   typedef orc::ObjectLinkingLayer<> ObjLayerT;
   typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
-  typedef orc::LazyEmittingLayer<CompileLayerT> LazyEmitLayerT;
+  typedef std::function<std::unique_ptr<Module>(std::unique_ptr<Module>)>
+    TransformFtor;
+  typedef orc::IRTransformLayer<CompileLayerT, TransformFtor> IRDumpLayerT;
+  typedef orc::LazyEmittingLayer<IRDumpLayerT> LazyEmitLayerT;
   typedef orc::CompileOnDemandLayer<LazyEmitLayerT,
                                     CompileCallbackMgr> CODLayerT;
   typedef CODLayerT::ModuleSetHandleT ModuleHandleT;
 
   typedef std::function<
-            std::unique_ptr<CompileCallbackMgr>(CompileLayerT&,
+            std::unique_ptr<CompileCallbackMgr>(IRDumpLayerT&,
                                                 RuntimeDyld::MemoryManager&,
                                                 LLVMContext&)>
     CallbackManagerBuilder;
@@ -52,8 +56,9 @@ public:
       Mang(this->TM->getDataLayout()),
       ObjectLayer(),
       CompileLayer(ObjectLayer, orc::SimpleCompiler(*this->TM)),
-      LazyEmitLayer(CompileLayer),
-      CCMgr(BuildCallbackMgr(CompileLayer, CCMgrMemMgr, Context)),
+      IRDumpLayer(CompileLayer, createDebugDumper()),
+      LazyEmitLayer(IRDumpLayer),
+      CCMgr(BuildCallbackMgr(IRDumpLayer, CCMgrMemMgr, Context)),
       CODLayer(LazyEmitLayer, *CCMgr),
       CXXRuntimeOverrides([this](const std::string &S) { return mangle(S); }) {}
 
@@ -137,12 +142,15 @@ private:
     return MangledName;
   }
 
+  static TransformFtor createDebugDumper();
+
   std::unique_ptr<TargetMachine> TM;
   Mangler Mang;
   SectionMemoryManager CCMgrMemMgr;
 
   ObjLayerT ObjectLayer;
   CompileLayerT CompileLayer;
+  IRDumpLayerT IRDumpLayer;
   LazyEmitLayerT LazyEmitLayer;
   std::unique_ptr<CompileCallbackMgr> CCMgr;
   CODLayerT CODLayer;