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/Bitcode/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"
 #if !defined(__native_client__)
@@ skipping 291 matching lines @@
   std::auto_ptr<Module> M;
 
   // In the NACL_SRPC case, fake a memory mapped file
   // TODO(jvoung): revert changes in MemoryBuffer.cpp which are no longer needed
 #if defined(__native_client__) && defined(NACL_SRPC)
   M.reset(ParseIR(NaClGetMemoryBufferForFile(InputFilename.c_str()),
                   Err,
                   Context));
   M->setModuleIdentifier(InputFilename);
 #else
-  M.reset(ParseIRFile(InputFilename, Err, Context));
+  //M.reset(ParseIRFile(InputFilename, Err, Context));
+  StreamChunkCallback cb = GetBitcodeFileStream(InputFilename, Err);
+  if (cb) {
+    M.reset(getLazyIRStreamModule(InputFilename, Err, Context, cb));
+  }
 #endif // defined(__native_client__) && defined(NACL_SRPC)
   if (M.get() == 0) {
     Err.print(argv[0], errs());
     return 1;
   }
   Module &mod = *M.get();
 
   // @LOCALMOD-BEGIN
   if (!DumpMetadata.empty()) {
     bool success = WriteMetadata(DumpMetadata.c_str(), mod);
@@ skipping 95 matching lines @@
     errs() << argv[0] << ": invalid optimization level.\n";
     return 1;
   case ' ': break;
   case '0': OLvl = CodeGenOpt::None; break;
   case '1': OLvl = CodeGenOpt::Less; break;
   case '2': OLvl = CodeGenOpt::Default; break;
   case '3': OLvl = CodeGenOpt::Aggressive; break;
   }
   
   // Build up all of the passes that we want to do to the module.
-  PassManager PM;
+  FunctionPassManager PM(&mod);
 
   // 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));
   else
     PM.add(new TargetData(&mod));
 
   // Override default to generate verbose assembly.
   Target.setAsmVerbosityDefault(true);
 
@@ skipping 32 matching lines @@
     // Ask the target to add backend passes as necessary.
     if (Target.addPassesToEmitFile(PM, FOS, FileType, OLvl, 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);

[jasonwkim, 2011/10/25 21:34:12]

Why did you expand this?

[(google.com) Derek Schuff, 2011/10/25 22:23:22]

Because the module-level pass manager caused the whole bitcode file to be
materialized at startup (i think it was just so it could use the iterator over
the functions but now I can't find exactly where that was; i'll look again
later).

+    PM.doInitialization();
+    for (Module::iterator I = mod.begin(), E = mod.end(); I != E; ++I) {
+      PM.run(*I);
+    }
+    PM.doFinalization();
   }
 
   // Declare success.
   Out->keep();
 #endif
 
   return 0;
 }
 
 #if !defined(NACL_SRPC)
 int
 main (int argc, char **argv) {
   return llc_main(argc, argv);
 }
 #else
 // main() is in nacl_file.cpp.
 #endif