X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Flli%2FOrcLazyJIT.cpp;h=718b3903822215cd2f942e988768a439b0841d11;hb=15e1e7f179e9740321df5cd9af21db5777044d9f;hp=8771a91be7d3ac9168da691eddd78fd487f57f96;hpb=0d982b840e7726e6589f1d1130c5dc322967e6d7;p=oota-llvm.git

diff --git a/tools/lli/OrcLazyJIT.cpp b/tools/lli/OrcLazyJIT.cpp
index 8771a91be7d..718b3903822 100644
--- a/tools/lli/OrcLazyJIT.cpp
+++ b/tools/lli/OrcLazyJIT.cpp
@@ -11,13 +11,14 @@
 #include "llvm/ExecutionEngine/Orc/OrcTargetSupport.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/DynamicLibrary.h"
+#include <cstdio>
 #include <system_error>
 
 using namespace llvm;
 
 namespace {
 
-  enum class DumpKind { NoDump, DumpFuncsToStdErr, DumpModsToStdErr,
+  enum class DumpKind { NoDump, DumpFuncsToStdOut, DumpModsToStdErr,
                         DumpModsToDisk };
 
   cl::opt<DumpKind> OrcDumpKind("orc-lazy-debug",
@@ -26,9 +27,9 @@ namespace {
                                 cl::values(
                                   clEnumValN(DumpKind::NoDump, "no-dump",
                                              "Don't dump anything."),
-                                  clEnumValN(DumpKind::DumpFuncsToStdErr,
-                                             "funcs-to-stderr",
-                                             "Dump function names to stderr."),
+                                  clEnumValN(DumpKind::DumpFuncsToStdOut,
+                                             "funcs-to-stdout",
+                                             "Dump function names to stdout."),
                                   clEnumValN(DumpKind::DumpModsToStdErr,
                                              "mods-to-stderr",
                                              "Dump modules to stderr."),
@@ -61,24 +62,25 @@ OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
 
   switch (OrcDumpKind) {
   case DumpKind::NoDump:
-    return [](std::unique_ptr<Module> M) { return std::move(M); };
+    return [](std::unique_ptr<Module> M) { return M; };
 
-  case DumpKind::DumpFuncsToStdErr:
+  case DumpKind::DumpFuncsToStdOut:
     return [](std::unique_ptr<Module> M) {
-      dbgs() << "[ ";
+      printf("[ ");
 
       for (const auto &F : *M) {
         if (F.isDeclaration())
           continue;
 
-        if (F.hasName())
-          dbgs() << F.getName() << " ";
-        else
-          dbgs() << "<anon> ";
+        if (F.hasName()) {
+          std::string Name(F.getName());
+          printf("%s ", Name.c_str());
+        } else
+          printf("<anon> ");
       }
 
-      dbgs() << "]\n";
-      return std::move(M);
+      printf("]\n");
+      return M;
     };
 
   case DumpKind::DumpModsToStdErr:
@@ -86,7 +88,7 @@ OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
              dbgs() << "----- Module Start -----\n" << *M
                     << "----- Module End -----\n";
 
-             return std::move(M);
+             return M;
            };
 
   case DumpKind::DumpModsToDisk:
@@ -100,11 +102,15 @@ OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
                exit(1);
              }
              Out << *M;
-             return std::move(M);
+             return M;
            };
   }
+  llvm_unreachable("Unknown DumpKind");
 }
 
+// Defined in lli.cpp.
+CodeGenOpt::Level getOptLevel();
+
 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)) {
@@ -114,7 +120,9 @@ int llvm::runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]) {
 
   // Grab a target machine and try to build a factory function for the
   // target-specific Orc callback manager.
-  auto TM = std::unique_ptr<TargetMachine>(EngineBuilder().selectTarget());
+  EngineBuilder EB;
+  EB.setOptLevel(getOptLevel());
+  auto TM = std::unique_ptr<TargetMachine>(EB.selectTarget());
   auto &Context = getGlobalContext();
   auto CallbackMgrBuilder =
     OrcLazyJIT::createCallbackManagerBuilder(Triple(TM->getTargetTriple()));
@@ -123,12 +131,13 @@ int llvm::runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]) {
   // manager for this target. Bail out.
   if (!CallbackMgrBuilder) {
     errs() << "No callback manager available for target '"
-           << TM->getTargetTriple() << "'.\n";
+           << TM->getTargetTriple().str() << "'.\n";
     return 1;
   }
 
   // Everything looks good. Build the JIT.
-  OrcLazyJIT J(std::move(TM), Context, CallbackMgrBuilder);
+  auto &DL = M->getDataLayout();
+  OrcLazyJIT J(std::move(TM), DL, Context, CallbackMgrBuilder);
 
   // Add the module, look up main and run it.
   auto MainHandle = J.addModule(std::move(M));