Bitcode streaming

tools/llc/llc.cpp

 //===-- llc.cpp - Implement the LLVM Native Code Generator ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the llc code generator driver. It provides a convenient
 // command-line interface for generating native assembly-language code
 // or C code, given LLVM bitcode.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/LLVMContext.h"
 #include "llvm/Module.h"
 #include "llvm/PassManager.h"
 #include "llvm/Pass.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Support/BitcodeStream.h"
 #include "llvm/Support/IRReader.h"
 #include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
 #include "llvm/Config/config.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PluginLoader.h"
@@ skipping 103 matching lines @@
                          cl::desc("Do not use .cfi_* directives"));
 
 cl::opt<bool> EnableDwarfDirectory("enable-dwarf-directory", cl::Hidden,
     cl::desc("Use .file directives with an explicit directory."));
 
 static cl::opt<bool>
 DisableRedZone("disable-red-zone",
   cl::desc("Do not emit code that uses the red zone."),
   cl::init(false));
 
+// Using bitcode streaming has a couple of ramifications. Primarily it means
+// that the module in the file will be compiled one function at a time rather
+// than the whole module. This allows earlier functions to be compiled before
+// later functions are read from the bitcode but of course means no whole-module
+// optimizations. For now, streaming is only supported for files and stdin.
+static cl::opt<bool>
+LazyBitcode("streaming-bitcode",
+  cl::desc("Use lazy bitcode streaming for file inputs"),
+  cl::init(false));
+
 // GetFileNameRoot - Helper function to get the basename of a filename.
 static inline std::string
 GetFileNameRoot(const std::string &InputFilename) {
   std::string IFN = InputFilename;
   std::string outputFilename;
   int Len = IFN.length();
   if ((Len > 2) &&
       IFN[Len-3] == '.' &&
       ((IFN[Len-2] == 'b' && IFN[Len-1] == 'c') ||
        (IFN[Len-2] == 'l' && IFN[Len-1] == 'l'))) {
@@ skipping 87 matching lines @@
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
 
   // Load the module to be compiled...
   SMDiagnostic Err;
   std::auto_ptr<Module> M;
 
-  M.reset(ParseIRFile(InputFilename, Err, Context));
+  if (LazyBitcode) {
+    std::string StrError;
+    BitcodeStreamer *streamer = getBitcodeFileStreamer(InputFilename,&StrError);
+    if (streamer) {
+      M.reset(getStreamedBitcodeModule(InputFilename, streamer, Context,
+                                       &StrError));
+    }
+    if (!StrError.empty()) {
+      Err = SMDiagnostic(InputFilename, SourceMgr::DK_Error, StrError);
+    }
+  } else {
+    M.reset(ParseIRFile(InputFilename, Err, Context));
+  }
   if (M.get() == 0) {
     Err.print(argv[0], errs());
     return 1;
   }
   Module &mod = *M.get();
 
   // If we are supposed to override the target triple, do so now.
   if (!TargetTriple.empty())
     mod.setTargetTriple(Triple::normalize(TargetTriple));
 
@@ skipping 76 matching lines @@
   if (TheTriple.isMacOSX() &&
       TheTriple.isMacOSXVersionLT(10, 6))
     Target.setMCUseLoc(false);
 
   // Figure out where we are going to send the output...
   OwningPtr<tool_output_file> Out
     (GetOutputStream(TheTarget->getName(), TheTriple.getOS(), argv[0]));
   if (!Out) return 1;
 
   // Build up all of the passes that we want to do to the module.
-  PassManager PM;
+  OwningPtr<PassManagerBase> PM;
+  if (LazyBitcode)
+    PM.reset(new FunctionPassManager(&mod));
+  else
+    PM.reset(new PassManager());
+
 
   // Add the target data from the target machine, if it exists, or the module.
   if (const TargetData *TD = Target.getTargetData())
-    PM.add(new TargetData(*TD));
+    PM->add(new TargetData(*TD));
   else
-    PM.add(new TargetData(&mod));
+    PM->add(new TargetData(&mod));
 
   // Override default to generate verbose assembly.
   Target.setAsmVerbosityDefault(true);
 
   if (RelaxAll) {
     if (FileType != TargetMachine::CGFT_ObjectFile)
       errs() << argv[0]
              << ": warning: ignoring -mc-relax-all because filetype != obj";
     else
       Target.setMCRelaxAll(true);
   }
 
   {
     formatted_raw_ostream FOS(Out->os());
 
     // Ask the target to add backend passes as necessary.
-    if (Target.addPassesToEmitFile(PM, FOS, FileType, NoVerify)) {
+    if (Target.addPassesToEmitFile(*PM, FOS, FileType, NoVerify)) {
       errs() << argv[0] << ": target does not support generation of this"
              << " file type!\n";
       return 1;
     }
 
     // Before executing passes, print the final values of the LLVM options.
     cl::PrintOptionValues();
 
-    PM.run(mod);
+    if (LazyBitcode) {
+      FunctionPassManager *P = static_cast<FunctionPassManager*>(PM.get());
+      P->doInitialization();
+      for (Module::iterator I = mod.begin(), E = mod.end(); I != E; ++I) {
+        P->run(*I);
+      }
+      P->doFinalization();
+    } else {
+      static_cast<PassManager*>(PM.get())->run(mod);
+    }
   }
 
   // Declare success.
   Out->keep();
 
   return 0;
 }