Changes from 3.7 merge to files not in upstream

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/STLExtras.h"
 #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/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/IR/LegacyPassManager.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/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.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/Analysis/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>
 
@@ skipping 25 matching lines @@
 #endif
                 );
 
 // General options for llc.  Other pass-specific options are specified
 // within the corresponding llc passes, and target-specific options
 // and back-end code generation options are specified with the target machine.
 //
 static cl::opt<std::string>
 InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
 
+// Primary output filename. If module splitting is used, the other output files
+// will have names derived from this one.
 static cl::opt<std::string>
-OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));
+MainOutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));
 
 // Using bitcode streaming allows compilation of one function at a time. This
 // allows earlier functions to be compiled before later functions are read from
 // the bitcode but of course means no whole-module optimizations. This means
 // that Module passes that run should only touch globals/function declarations
 // and not function bodies, otherwise the streaming and non-streaming code
 // pathes wouldn't emit the same code for each function. For now, streaming is
 // only supported for files and stdin.
 static cl::opt<bool>
 LazyBitcode("streaming-bitcode",
@@ skipping 53 matching lines @@
                    "Static thread scheduling"),
         clEnumValEnd),
     cl::init(SplitModuleDynamic));
 
 /// Compile the module provided to pnacl-llc. The file name for reading the
 /// module and other options are taken from globals populated by command-line
 /// option parsing.
 static int compileModule(StringRef ProgramName);
 
 #if !defined(PNACL_BROWSER_TRANSLATOR)
-// GetFileNameRoot - Helper function to get the basename of a filename.
-static std::string
-GetFileNameRoot(StringRef 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'))) {
-    outputFilename = std::string(IFN.begin(), IFN.end()-3); // s/.bc/.s/
-  } else {
-    outputFilename = IFN;
-  }
-  return outputFilename;
-}
-
-static tool_output_file *GetOutputStream(const char *TargetName,
-                                         Triple::OSType OS,
-                                         std::string Filename) {
+static std::unique_ptr<tool_output_file>
+GetOutputStream(const char *TargetName,
+                Triple::OSType OS,
+                std::string OutputFilename) {
   // If we don't yet have an output filename, make one.
-  if (Filename.empty()) {
+  if (OutputFilename.empty()) {
     if (InputFilename == "-")
-      Filename = "-";
+      OutputFilename = "-";
     else {
-      Filename = GetFileNameRoot(InputFilename);
+      // If InputFilename ends in .bc or .ll, remove it.
+      StringRef IFN = InputFilename;
+      if (IFN.endswith(".bc") || IFN.endswith(".ll"))
+        OutputFilename = IFN.drop_back(3);
+      else
+        OutputFilename = IFN;
 
       switch (FileType) {
       case TargetMachine::CGFT_AssemblyFile:
         if (TargetName[0] == 'c') {
           if (TargetName[1] == 0)
-            Filename += ".cbe.c";
+            OutputFilename += ".cbe.c";
           else if (TargetName[1] == 'p' && TargetName[2] == 'p')
-            Filename += ".cpp";
+            OutputFilename += ".cpp";
           else
-            Filename += ".s";
+            OutputFilename += ".s";
         } else
-          Filename += ".s";
+          OutputFilename += ".s";
         break;
       case TargetMachine::CGFT_ObjectFile:
         if (OS == Triple::Win32)
-          Filename += ".obj";
+          OutputFilename += ".obj";
         else
-          Filename += ".o";
+          OutputFilename += ".o";
         break;
       case TargetMachine::CGFT_Null:
-        Filename += ".null";
+        OutputFilename += ".null";
         break;
       }
     }
   }
 
   // Decide if we need "binary" output.
   bool Binary = false;
   switch (FileType) {
   case TargetMachine::CGFT_AssemblyFile:
     break;
   case TargetMachine::CGFT_ObjectFile:
   case TargetMachine::CGFT_Null:
     Binary = true;
     break;
   }
 
   // Open the file.
   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, EC, OpenFlags);
+  auto FDOut = llvm::make_unique<tool_output_file>(OutputFilename, 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.
 //
 int llc_main(int argc, char **argv) {
@@ skipping 74 matching lines @@
 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:
+    case PNaClFormat: {
+      std::unique_ptr<StreamingMemoryObject> Cache(
+          new ThreadedStreamingCache(StreamingObject));
       M.reset(getNaClStreamedBitcodeModule(
-          InputFilename,
-          new ThreadedStreamingCache(StreamingObject), Context, &VerboseStrm,
-          &StrError));
+          InputFilename, Cache.release(), Context, &VerboseStrm, &StrError));
       break;
-    case LLVMFormat:
-      M.reset(getStreamedBitcodeModule(
-          InputFilename,
-          new ThreadedStreamingCache(StreamingObject), Context, &StrError));
+    }
+    case LLVMFormat: {
+      std::unique_ptr<StreamingMemoryObject> Cache(
+          new ThreadedStreamingCache(StreamingObject));
+      ErrorOr<std::unique_ptr<Module>> MOrErr =
+          getStreamedBitcodeModule(
+          InputFilename, Cache.release(), Context);
+      M = std::move(*MOrErr);
       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
@@ skipping 19 matching lines @@
 ExternalizeAll("externalize",
                cl::desc("Externalize all symbols"),
                cl::init(false));
 
 static int runCompilePasses(Module *ModuleRef,
                             unsigned ModuleIndex,
                             ThreadedFunctionQueue *FuncQueue,
                             const Triple &TheTriple,
                             TargetMachine &Target,
                             StringRef ProgramName,
-                            formatted_raw_ostream &FOS){
+                            raw_pwrite_stream &OS){
   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 (Function &F : *ModuleRef) {
       if (!F.hasName())
         F.setName("Function");
       if (F.hasInternalLinkage())
@@ skipping 32 matching lines @@
   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.
   // We always use a FunctionPassManager to divide up the functions
   // among threads (instead of a whole-module PassManager).
-  std::unique_ptr<FunctionPassManager> PM(new FunctionPassManager(ModuleRef));
+  std::unique_ptr<legacy::FunctionPassManager> PM(
+      new legacy::FunctionPassManager(ModuleRef));
 
   // Add the target data from the target machine, if it exists, or the module.
-  if (const DataLayout *DL = Target.getSubtargetImpl()->getDataLayout())
-    ModuleRef->setDataLayout(DL);
-  PM->add(new DataLayoutPass());
+  if (const DataLayout *DL = Target.getDataLayout())
+    ModuleRef->setDataLayout(*DL);
 
   // 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));
 
   // Add the intrinsic resolution pass. It assumes ABI-conformant code.
   PM->add(createResolvePNaClIntrinsicsPass());
 
   // Add an appropriate TargetLibraryInfo pass for the module's triple.
-  TargetLibraryInfo *TLI = new TargetLibraryInfo(TheTriple);
+  TargetLibraryInfoImpl TLII(TheTriple);
+
+  // The -disable-simplify-libcalls flag actually disables all builtin optzns.
   if (DisableSimplifyLibCalls)
-    TLI->disableAllFunctions();
-  PM->add(TLI);
+    TLII.disableAllFunctions();
+  PM->add(new TargetLibraryInfoWrapperPass(TLII));
 
   // Allow subsequent passes and the backend to better optimize instructions
   // that were simplified for PNaCl's ABI. This pass uses the TargetLibraryInfo
   // above.
   PM->add(createBackendCanonicalizePass());
 
-  // Add internal analysis passes from the target machine.
-  Target.addAnalysisPasses(*PM);
-
   // Ask the target to add backend passes as necessary. We explicitly ask it
   // not to add the verifier pass because we added it earlier.
-  if (Target.addPassesToEmitFile(*PM, FOS, FileType,
+  if (Target.addPassesToEmitFile(*PM, OS, FileType,
                                  /* DisableVerify */ true)) {
     errs() << ProgramName
     << ": target does not support generation of this file type!\n";
     return 1;
   }
 
   PM->doInitialization();
   unsigned FuncIndex = 0;
   switch (SplitModuleSched) {
   case SplitModuleStatic:
@@ skipping 53 matching lines @@
                               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 *ModuleRef = nullptr;
 
   if (ModuleIndex == 0) {
@@ skipping 14 matching lines @@
         createAddPNaClExternalDeclsPass());
     AddPNaClExternalDeclsPass->runOnModule(*ModuleRef);
     AddPNaClExternalDeclsPass.reset();
   }
 
   ModuleRef->setTargetTriple(Triple::normalize(UserDefinedTriple));
 
   {
 #if !defined(PNACL_BROWSER_TRANSLATOR)
       // Figure out where we are going to send the output.
-    std::string N(OutputFilename);
+    std::string N(MainOutputFilename);
     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()));
+    std::unique_ptr<tool_output_file> Out =
+        GetOutputStream(TheTarget->getName(), TheTriple.getOS(),
+                         OutFileName.str());
     if (!Out) return 1;
-    formatted_raw_ostream FOS(Out->os());
+    raw_pwrite_stream *OS = &Out->os();
+    std::unique_ptr<buffer_ostream> BOS;
+    if (FileType != TargetMachine::CGFT_AssemblyFile &&
+        !Out->os().supportsSeeking()) {
+      BOS = make_unique<buffer_ostream>(*OS);
+      OS = BOS.get();
+    }
 #else
-    raw_fd_ostream ROS(getObjectFileFD(ModuleIndex), /* ShouldClose */ true);
-    ROS.SetBufferSize(1 << 20);
-    formatted_raw_ostream FOS(ROS);
+    auto OS = llvm::make_unique<raw_fd_ostream>(
+        getObjectFileFD(ModuleIndex), /* ShouldClose */ true);
+    OS->SetBufferSize(1 << 20);
 #endif
     int ret = runCompilePasses(ModuleRef, ModuleIndex, FuncQueue,
                                TheTriple, Target, ProgramName,
-                               FOS);
+                               *OS);
     if (ret)
       return ret;
 #if defined(PNACL_BROWSER_TRANSLATOR)
-    FOS.flush();
-    ROS.flush();
+    OS->flush();
 #else
     // Declare success.
     Out->keep();
 #endif // PNACL_BROWSER_TRANSLATOR
   }
   return 0;
 }
 
 struct ThreadData {
   const TargetOptions *Options;
@@ skipping 87 matching lines @@
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple,
                                                          Error);
   if (!TheTarget) {
     errs() << ProgramName << ": " << Error;
     return 1;
   }
 
   TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
   Options.DisableIntegratedAS = NoIntegratedAssembler;
+  Options.MCOptions.AsmVerbose = true;
 
   if (GenerateSoftFloatCalls)
     FloatABIForCalls = FloatABI::Soft;
 
   // Package up features to be passed to target/subtarget
   std::string FeaturesStr;
   if (MAttrs.size()) {
     SubtargetFeatures Features;
     for (unsigned i = 0; i != MAttrs.size(); ++i)
       Features.AddFeature(MAttrs[i]);
@@ skipping 51 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
 }