PNaCl localmod mods in LLVM to 223109 (local files only)

tools/pnacl-llc/pnacl-llc.cpp

 //===-- pnacl-llc.cpp - PNaCl-specific llc: pexe ---> nexe  ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // pnacl-llc: the core of the PNaCl translator, compiling a pexe into a nexe.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/NaCl.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
-#include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Pass.h"
 #include "llvm/PassManager.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DataStream.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h"
-#include "llvm/Support/Mutex.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/StreamableMemoryObject.h"
+#include "llvm/Support/StreamingMemoryObject.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetLibraryInfo.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetSubtargetInfo.h"
 #include "llvm/Transforms/NaCl.h"
 
 #include "ThreadedFunctionQueue.h"
 #include "ThreadedStreamingCache.h"
 
 #include <pthread.h>
 #include <memory>
 
 using namespace llvm;
 
@@ skipping 162 matching lines @@
   switch (FileType) {
   case TargetMachine::CGFT_AssemblyFile:
     break;
   case TargetMachine::CGFT_ObjectFile:
   case TargetMachine::CGFT_Null:
     Binary = true;
     break;
   }
 
   // Open the file.
-  std::string error;
+  std::error_code EC;
   sys::fs::OpenFlags OpenFlags = sys::fs::F_None;
   if (!Binary)
     OpenFlags |= sys::fs::F_Text;
-  tool_output_file *FDOut =
-      new tool_output_file(Filename.c_str(), error, OpenFlags);
-  if (!error.empty()) {
-    errs() << error << '\n';
+  tool_output_file *FDOut = new tool_output_file(Filename, EC, OpenFlags);
+  if (EC) {
+    errs() << EC.message() << '\n';
     delete FDOut;
     return nullptr;
   }
 
   return FDOut;
 }
 #endif // !defined(PNACL_BROWSER_TRANSLATOR)
 
 // main - Entry point for the llc compiler.
 //
@@ skipping 65 matching lines @@
     os << Name << " is not valid PNaCl bitcode:\n";
     Reporter.printErrors(os);
     if (PNaClABIVerifyFatalErrors) {
       report_fatal_error(os.str());
     }
     errs() << os.str();
   }
   Reporter.reset();
 }
 
 static Module* getModule(StringRef ProgramName, LLVMContext &Context,

[JF, 2015/02/24 05:35:37]

This could now be a unique_ptr. One of the two uses is a bit weird (because of
the GlobalModule)?

[jvoung (off chromium), 2015/02/24 18:38:48]

Converted the function to return a unique_ptr.

The GlobalModule does make things a bit weird in one function where a reference
is borrowed. It's mainly used for thread 0 vs thread 1-n.

Maybe in a later CL we can try allocating all of the modules and contexts up
front before threads are created, and then every thread is uniform. I can't
imagine the extra parallelism in the allocation of module/context is that big?

[JF, 2015/02/24 19:32:55]

sgtm

                          StreamingMemoryObject *StreamingObject) {
-  Module *M = nullptr;
+  std::unique_ptr<Module> M;
   SMDiagnostic Err;
   std::string VerboseBuffer;
   raw_string_ostream VerboseStrm(VerboseBuffer);
   if (LazyBitcode) {
     std::string StrError;
     switch (InputFileFormat) {
     case PNaClFormat:
-      M = getNaClStreamedBitcodeModule(
+      M.reset(getNaClStreamedBitcodeModule(
           InputFilename,
           new ThreadedStreamingCache(StreamingObject), Context, &VerboseStrm,
-          &StrError);
+          &StrError));
       break;
     case LLVMFormat:
-      M = getStreamedBitcodeModule(
+      M.reset(getStreamedBitcodeModule(
           InputFilename,
-          new ThreadedStreamingCache(StreamingObject), Context, &StrError);
+          new ThreadedStreamingCache(StreamingObject), Context, &StrError));
       break;
     case AutodetectFileFormat:
       report_fatal_error("Command can't autodetect file format!");
     }
     if (!StrError.empty())
       Err = SMDiagnostic(InputFilename, SourceMgr::DK_Error, StrError);
   } else {
 #if defined(PNACL_BROWSER_TRANSLATOR)
     llvm_unreachable("native client SRPC only supports streaming");
 #else
     // Parses binary bitcode as well as textual assembly
     // (so pulls in more code into pnacl-llc).
     M = NaClParseIRFile(InputFilename, InputFileFormat, Err, &VerboseStrm,
                         Context);
 #endif
   }
   if (!M) {
 #if defined(PNACL_BROWSER_TRANSLATOR)
     report_fatal_error(VerboseStrm.str() + Err.getMessage());
 #else
     // Err.print is prettier, so use it for the non-sandboxed translator.
     Err.print(ProgramName.data(), errs());
     errs() << VerboseStrm.str();
     return nullptr;
 #endif
   }
-  return M;
+  return M.release();
 }
 
 static cl::opt<bool>
 ExternalizeAll("externalize",
                cl::desc("Externalize all symbols"),
                cl::init(false));
 
 static int runCompilePasses(Module *mod,
                             unsigned ModuleIndex,
                             ThreadedFunctionQueue *FuncQueue,
@@ skipping 51 matching lines @@
   }
 
   // Build up all of the passes that we want to do to the module.
   std::unique_ptr<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 DataLayout *DL = Target.getDataLayout())
+  if (const DataLayout *DL = Target.getSubtargetImpl()->getDataLayout())
     mod->setDataLayout(DL);
-  PM->add(new DataLayoutPass(mod));
+  PM->add(new DataLayoutPass());
 
   // For conformance with llc, we let the user disable LLVM IR verification with
   // -disable-verify. Unlike llc, when LLVM IR verification is enabled we only
   // run it once, before PNaCl ABI verification.
   if (!NoVerify)
     PM->add(createVerifierPass());
 
   // Add the ABI verifier pass before the analysis and code emission passes.
   if (PNaClABIVerify)
     PM->add(createPNaClABIVerifyFunctionsPass(&ABIErrorReporter));
@@ skipping 133 matching lines @@
     std::string N(OutputFilename);
     raw_string_ostream OutFileName(N);
     if (ModuleIndex > 0)
       OutFileName << ".module" << ModuleIndex;
     std::unique_ptr<tool_output_file> Out
         (GetOutputStream(TheTarget->getName(), TheTriple.getOS(),
                          OutFileName.str()));
     if (!Out) return 1;
     formatted_raw_ostream FOS(Out->os());
 #else
-    raw_fd_ostream ROS(getObjectFileFD(ModuleIndex), true, sys::fs::F_None);
+    raw_fd_ostream ROS(getObjectFileFD(ModuleIndex), /* ShouldClose */ true);
     ROS.SetBufferSize(1 << 20);
     formatted_raw_ostream FOS(ROS);
 #endif
     int ret = runCompilePasses(mod, ModuleIndex, FuncQueue,
                                TheTriple, Target, ProgramName,
                                FOS);
     if (ret)
       return ret;
 #if defined(PNACL_BROWSER_TRANSLATOR)
     FOS.flush();
@@ skipping 169 matching lines @@
   return 0;
 }
 
 int main(int argc, char **argv) {
 #if defined(PNACL_BROWSER_TRANSLATOR)
   return srpc_main(argc, argv);
 #else
   return llc_main(argc, argv);
 #endif // PNACL_BROWSER_TRANSLATOR
 }