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,
-                         StreamingMemoryObject *StreamingObject) {
-  Module *M = nullptr;
+static std::unique_ptr<Module> getModule(
+    StringRef ProgramName, LLVMContext &Context,
+    StreamingMemoryObject *StreamingObject) {
+  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 std::move(M);
 }
 
 static cl::opt<bool>
 ExternalizeAll("externalize",
                cl::desc("Externalize all symbols"),
                cl::init(false));
 
-static int runCompilePasses(Module *mod,
+static int runCompilePasses(Module *ModuleRef,

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

Went ahead and capitalized the variable name for consistency.

                             unsigned ModuleIndex,
                             ThreadedFunctionQueue *FuncQueue,
                             const Triple &TheTriple,
                             TargetMachine &Target,
                             StringRef ProgramName,
                             formatted_raw_ostream &FOS){
   PNaClABIErrorReporter ABIErrorReporter;
 
   if (SplitModuleCount > 1 || ExternalizeAll) {
     // Add function and global names, and give them external linkage.
     // This relies on LLVM's consistent auto-generation of names, we could
     // maybe do our own in case something changes there.
-    for (Module::iterator I = mod->begin(), E = mod->end(); I != E; ++I) {
-      if (!I->hasName())
-        I->setName("Function");
-      if (I->hasInternalLinkage())
-        I->setLinkage(GlobalValue::ExternalLinkage);
+    for (Function &F : *ModuleRef) {
+      if (!F.hasName())
+        F.setName("Function");
+      if (F.hasInternalLinkage())
+        F.setLinkage(GlobalValue::ExternalLinkage);
     }
-    for (Module::global_iterator GI = mod->global_begin(),
-         GE = mod->global_end();
+    for (Module::global_iterator GI = ModuleRef->global_begin(),
+         GE = ModuleRef->global_end();
          GI != GE; ++GI) {
       if (!GI->hasName())
         GI->setName("Global");
       if (GI->hasInternalLinkage())
         GI->setLinkage(GlobalValue::ExternalLinkage);
     }
     if (ModuleIndex > 0) {
       // Remove the initializers for all global variables, turning them into
       // declarations.
-      for (Module::global_iterator GI = mod->global_begin(),
-          GE = mod->global_end();
+      for (Module::global_iterator GI = ModuleRef->global_begin(),
+          GE = ModuleRef->global_end();
           GI != GE; ++GI) {
         assert(GI->hasInitializer() && "Global variable missing initializer");
         Constant *Init = GI->getInitializer();
         GI->setInitializer(nullptr);
         if (Init->getNumUses() == 0)
           Init->destroyConstant();
       }
     }
   }
 
   // Make all non-weak symbols hidden for better code. We cannot do
   // this for weak symbols. The linker complains when some weak
   // symbols are not resolved.
-  for (Module::iterator I = mod->begin(), E = mod->end(); I != E; ++I) {
-    if (!I->isWeakForLinker() && !I->hasLocalLinkage())
-      I->setVisibility(GlobalValue::HiddenVisibility);
+  for (Function &F : *ModuleRef) {
+    if (!F.isWeakForLinker() && !F.hasLocalLinkage())
+      F.setVisibility(GlobalValue::HiddenVisibility);
   }
-  for (Module::global_iterator GI = mod->global_begin(),
-           GE = mod->global_end();
+  for (Module::global_iterator GI = ModuleRef->global_begin(),
+           GE = ModuleRef->global_end();
        GI != GE; ++GI) {
     if (!GI->isWeakForLinker() && !GI->hasLocalLinkage())
       GI->setVisibility(GlobalValue::HiddenVisibility);
   }
 
   // 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));
+    PM.reset(new FunctionPassManager(ModuleRef));
   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())
-    mod->setDataLayout(DL);
-  PM->add(new DataLayoutPass(mod));
+  if (const DataLayout *DL = Target.getSubtargetImpl()->getDataLayout())
+    ModuleRef->setDataLayout(DL);
+  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 23 matching lines @@
     << ": target does not support generation of this file type!\n";
     return 1;
   }
 
   if (LazyBitcode) {
     auto FPM = static_cast<FunctionPassManager *>(PM.get());
     FPM->doInitialization();
     unsigned FuncIndex = 0;
     switch (SplitModuleSched) {
     case SplitModuleStatic:
-      for (Module::iterator I = mod->begin(), E = mod->end(); I != E; ++I) {
+      for (Function &F : *ModuleRef) {
         if (FuncQueue->GrabFunctionStatic(FuncIndex, ModuleIndex)) {
-          FPM->run(*I);
-          CheckABIVerifyErrors(ABIErrorReporter, "Function " + I->getName());
-          I->Dematerialize();
+          FPM->run(F);
+          CheckABIVerifyErrors(ABIErrorReporter, "Function " + F.getName());
+          F.Dematerialize();
         }
         ++FuncIndex;
       }
       break;
     case SplitModuleDynamic:
       unsigned ChunkSize = 0;
       unsigned NumFunctions = FuncQueue->Size();
-      Module::iterator I = mod->begin();
+      Module::iterator I = ModuleRef->begin();
       while (FuncIndex < NumFunctions) {
         ChunkSize = FuncQueue->RecommendedChunkSize();
         unsigned NextIndex;
         bool grabbed = FuncQueue->GrabFunctionDynamic(FuncIndex, ChunkSize,
                                                       NextIndex);
         if (grabbed) {
           while (FuncIndex < NextIndex) {
             if (!I->isMaterializable() && I->isDeclaration()) {
               ++I;
               continue;
@@ skipping 12 matching lines @@
             }
             ++FuncIndex;
             ++I;
           }
         }
       }
       break;
     }
     FPM->doFinalization();
   } else
-    static_cast<PassManager *>(PM.get())->run(*mod);
+    static_cast<PassManager *>(PM.get())->run(*ModuleRef);
 
   return 0;
 }
 
 static int compileSplitModule(const TargetOptions &Options,
                               const Triple &TheTriple,
                               const Target *TheTarget,
                               const std::string &FeaturesStr,
                               CodeGenOpt::Level OLvl,
                               const StringRef &ProgramName,
-                              Module *GlobalModule,
+                              Module *GlobalModuleRef,
                               StreamingMemoryObject *StreamingObject,
                               unsigned ModuleIndex,
                               ThreadedFunctionQueue *FuncQueue) {
   std::auto_ptr<TargetMachine>
     target(TheTarget->createTargetMachine(TheTriple.getTriple(),
                                           MCPU, FeaturesStr, Options,
                                           RelocModel, CMModel, OLvl));
   assert(target.get() && "Could not allocate target machine!");
   TargetMachine &Target = *target.get();
   // Override default to generate verbose assembly.
   Target.setAsmVerbosityDefault(true);
   if (RelaxAll.getNumOccurrences() > 0 &&
       FileType != TargetMachine::CGFT_ObjectFile)
     errs() << ProgramName
              << ": warning: ignoring -mc-relax-all because filetype != obj";
   // The OwningPtrs are only used if we are not the primary module.
   std::unique_ptr<LLVMContext> C;
   std::unique_ptr<Module> M;
-  Module *mod(nullptr);
+  Module *ModuleRef = nullptr;
 
   if (ModuleIndex == 0) {
-    mod = GlobalModule;
+    ModuleRef = GlobalModuleRef;
   } else {
     C.reset(new LLVMContext());
-    mod = getModule(ProgramName, *C, StreamingObject);
-    if (!mod)
+    M = getModule(ProgramName, *C, StreamingObject);
+    if (!M)
       return 1;
-    M.reset(mod);
+    // M owns the temporary module, but use a reference through ModuleRef
+    // to also work in the case we are using GlobalModuleRef.
+    ModuleRef = M.get();
 
     // Add declarations for external functions required by PNaCl. The
     // ResolvePNaClIntrinsics function pass running during streaming
     // depends on these declarations being in the module.
     std::unique_ptr<ModulePass> AddPNaClExternalDeclsPass(
         createAddPNaClExternalDeclsPass());
-    AddPNaClExternalDeclsPass->runOnModule(*M);
+    AddPNaClExternalDeclsPass->runOnModule(*ModuleRef);
     AddPNaClExternalDeclsPass.reset();
   }
 
-  mod->setTargetTriple(Triple::normalize(UserDefinedTriple));
+  ModuleRef->setTargetTriple(Triple::normalize(UserDefinedTriple));
 
   {
 #if !defined(PNACL_BROWSER_TRANSLATOR)
       // Figure out where we are going to send the output.
     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,
+    int ret = runCompilePasses(ModuleRef, ModuleIndex, FuncQueue,
                                TheTriple, Target, ProgramName,
                                FOS);
     if (ret)
       return ret;
 #if defined(PNACL_BROWSER_TRANSLATOR)
     FOS.flush();
     ROS.flush();
 #else
     // Declare success.
     Out->keep();
 #endif // PNACL_BROWSER_TRANSLATOR
   }
   return 0;
 }
 
 struct ThreadData {
   const TargetOptions *Options;
   const Triple *TheTriple;
   const Target *TheTarget;
   std::string FeaturesStr;
   CodeGenOpt::Level OLvl;
   std::string ProgramName;
-  Module *GlobalModule;
+  Module *GlobalModuleRef;
   StreamingMemoryObject *StreamingObject;
   unsigned ModuleIndex;
   ThreadedFunctionQueue *FuncQueue;
 };
 
 
 static void *runCompileThread(void *arg) {
   struct ThreadData *Data = static_cast<ThreadData *>(arg);
   int ret = compileSplitModule(*Data->Options,
                                *Data->TheTriple,
                                Data->TheTarget,
                                Data->FeaturesStr,
                                Data->OLvl,
                                Data->ProgramName,
-                               Data->GlobalModule,
+                               Data->GlobalModuleRef,
                                Data->StreamingObject,
                                Data->ModuleIndex,
                                Data->FuncQueue);
   return reinterpret_cast<void *>(static_cast<intptr_t>(ret));
 }
 
 static int compileModule(StringRef ProgramName) {
   // Use a new context instead of the global context for the main module. It must
   // outlive the module object, declared below. We do this because
   // lib/CodeGen/PseudoSourceValue.cpp gets a type from the global context and
   // races with any other use of the context. Rather than doing an invasive
   // plumbing change to fix it, we work around it by using a new context here
   // and leaving PseudoSourceValue as the only user of the global context.
   std::unique_ptr<LLVMContext> MainContext(new LLVMContext());
-  std::unique_ptr<Module> mod;
+  std::unique_ptr<Module> MainMod;
   Triple TheTriple;
   PNaClABIErrorReporter ABIErrorReporter;
   std::unique_ptr<StreamingMemoryObject> StreamingObject;
 
   if (!MainContext) return 1;
 
 #if defined(PNACL_BROWSER_TRANSLATOR)
   StreamingObject.reset(
       new StreamingMemoryObjectImpl(getNaClBitcodeStreamer()));
 #else
   if (LazyBitcode) {
     std::string StrError;
     DataStreamer* FileStreamer(getDataFileStreamer(InputFilename, &StrError));
     if (!StrError.empty()) {
       SMDiagnostic Err(InputFilename, SourceMgr::DK_Error, StrError);
       Err.print(ProgramName.data(), errs());
     }
     if (!FileStreamer)
       return 1;
     StreamingObject.reset(new StreamingMemoryObjectImpl(FileStreamer));
   }
 #endif
-  mod.reset(getModule(ProgramName, *MainContext.get(), StreamingObject.get()));
+  MainMod = getModule(ProgramName, *MainContext.get(), StreamingObject.get());
 
-  if (!mod) return 1;
+  if (!MainMod) return 1;
 
   if (PNaClABIVerify) {
     // Verify the module (but not the functions yet)
     std::unique_ptr<ModulePass> VerifyPass(
         createPNaClABIVerifyModulePass(&ABIErrorReporter, LazyBitcode));
-    VerifyPass->runOnModule(*mod);
+    VerifyPass->runOnModule(*MainMod);
     CheckABIVerifyErrors(ABIErrorReporter, "Module");
     VerifyPass.reset();
   }
 
   // Add declarations for external functions required by PNaCl. The
   // ResolvePNaClIntrinsics function pass running during streaming
   // depends on these declarations being in the module.
   std::unique_ptr<ModulePass> AddPNaClExternalDeclsPass(
       createAddPNaClExternalDeclsPass());
-  AddPNaClExternalDeclsPass->runOnModule(*mod);
+  AddPNaClExternalDeclsPass->runOnModule(*MainMod);
   AddPNaClExternalDeclsPass.reset();
 
   if (UserDefinedTriple.empty()) {
     report_fatal_error("-mtriple must be set to a target triple for pnacl-llc");
   } else {
-    mod->setTargetTriple(Triple::normalize(UserDefinedTriple));
-    TheTriple = Triple(mod->getTargetTriple());
+    MainMod->setTargetTriple(Triple::normalize(UserDefinedTriple));
+    TheTriple = Triple(MainMod->getTargetTriple());
   }
 
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple,
                                                          Error);
   if (!TheTarget) {
     errs() << ProgramName << ": " << Error;
     return 1;
   }
@@ skipping 20 matching lines @@
     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;
   }
 
   SmallVector<pthread_t, 4> Pthreads(SplitModuleCount);
   SmallVector<ThreadData, 4> ThreadDatas(SplitModuleCount);
-  ThreadedFunctionQueue FuncQueue(mod.get(), SplitModuleCount);
+  ThreadedFunctionQueue FuncQueue(MainMod.get(), SplitModuleCount);
 
   if (SplitModuleCount == 1) {
     // No need for dynamic scheduling with one thread.
     SplitModuleSched = SplitModuleStatic;
     return compileSplitModule(Options, TheTriple, TheTarget, FeaturesStr,
-                              OLvl, ProgramName, mod.get(), nullptr, 0,
+                              OLvl, ProgramName, MainMod.get(), nullptr, 0,
                               &FuncQueue);
   }
 
   for(unsigned ModuleIndex = 0; ModuleIndex < SplitModuleCount; ++ModuleIndex) {
     ThreadDatas[ModuleIndex].Options = &Options;
     ThreadDatas[ModuleIndex].TheTriple = &TheTriple;
     ThreadDatas[ModuleIndex].TheTarget = TheTarget;
     ThreadDatas[ModuleIndex].FeaturesStr = FeaturesStr;
     ThreadDatas[ModuleIndex].OLvl = OLvl;
     ThreadDatas[ModuleIndex].ProgramName = ProgramName.str();
-    ThreadDatas[ModuleIndex].GlobalModule = mod.get();
+    ThreadDatas[ModuleIndex].GlobalModuleRef = MainMod.get();
     ThreadDatas[ModuleIndex].StreamingObject = StreamingObject.get();
     ThreadDatas[ModuleIndex].ModuleIndex = ModuleIndex;
     ThreadDatas[ModuleIndex].FuncQueue = &FuncQueue;
     if (pthread_create(&Pthreads[ModuleIndex], nullptr, runCompileThread,
                         &ThreadDatas[ModuleIndex])) {
       report_fatal_error("Failed to create thread");
     }
   }
   for(unsigned ModuleIndex = 0; ModuleIndex < SplitModuleCount; ++ModuleIndex) {
     void *retval;
     if (pthread_join(Pthreads[ModuleIndex], &retval))
       report_fatal_error("Failed to join thread");
     intptr_t ret = reinterpret_cast<intptr_t>(retval);
     if (ret != 0)
       report_fatal_error("Thread returned nonzero");
   }
   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
 }