Separate the PNaCl llc into a tool named pnacl-llc (how original!)

tools/pnacl-llc/pnacl-llc.cpp

-//===-- llc.cpp - Implement the LLVM Native Code Generator ----------------===//
+//===-- 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.
 //
 //===----------------------------------------------------------------------===//
 //
-// 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.
+// pnacl-llc: the core of the PNaCl translator, compiling a pexe into a nexe.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/IR/LLVMContext.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/NaCl.h"
 #include "llvm/Assembly/PrintModulePass.h"
-#include "llvm/Support/DataStream.h"  // @LOCALMOD
+#include "llvm/Support/DataStream.h"
 #include "llvm/CodeGen/CommandFlags.h"
-#include "llvm/CodeGen/IntrinsicLowering.h" // @LOCALMOD
 #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/MC/SubtargetFeature.h"
 #include "llvm/Pass.h"
 #include "llvm/PassManager.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/IRReader.h"
 #include "llvm/Support/ManagedStatic.h"
-#if !defined(__native_client__)
-#include "llvm/Support/PluginLoader.h"
-#endif
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/Timer.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetLibraryInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include <memory>
 
-// @LOCALMOD-BEGIN
-#include "llvm/Support/Timer.h"
-#include "StubMaker.h"
-#include "TextStubWriter.h"
-// @LOCALMOD-END
 
 using namespace llvm;
 
 // @LOCALMOD-BEGIN
 // NOTE: this tool can be build as a "sandboxed" translator.
 //       There are two ways to build the translator
 //       SRPC-style:  no file operations are allowed
 //                    see nacl_file.cc for support code
 //       non-SRPC-style: some basic file operations are allowed
 //                       This can be useful for debugging but will
@@ skipping 24 matching lines @@
 static cl::opt<std::string>
 InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
 
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));
 
 static cl::opt<unsigned>
 TimeCompilations("time-compilations", cl::Hidden, cl::init(1u),
                  cl::value_desc("N"),
                  cl::desc("Repeat compilation N times for timing"));
-// @LOCALMOD-BEGIN
-static cl::opt<std::string>
-MetadataTextFilename("metadata-text", cl::desc("Metadata as text, out filename"),
-                     cl::value_desc("filename"));
 
 // 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));
 
 // The option below overlaps very much with bitcode streaming.
 // We keep it separate because it is still experimental and we want
 // to use it without changing the outside behavior which is especially
 // relevant for the sandboxed case.
 static cl::opt<bool>
 ReduceMemoryFootprint("reduce-memory-footprint",
   cl::desc("Aggressively reduce memory used by llc"),
   cl::init(false));
 
 static cl::opt<bool>
 PNaClABIVerify("pnaclabi-verify",
   cl::desc("Verify PNaCl bitcode ABI before translating"),
   cl::init(false));
 static cl::opt<bool>
 PNaClABIVerifyFatalErrors("pnaclabi-verify-fatal-errors",
   cl::desc("PNaCl ABI verification errors are fatal"),
   cl::init(false));
-// @LOCALMOD-END
 
 // Determine optimization level.
 static cl::opt<char>
 OptLevel("O",
          cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
                   "(default = '-O2')"),
          cl::Prefix,
          cl::ZeroOrMore,
          cl::init(' '));
 
@@ skipping 81 matching lines @@
                                                  OpenFlags);
   if (!error.empty()) {
     errs() << error << '\n';
     delete FDOut;
     return 0;
   }
 
   return FDOut;
 }
 
 // @LOCALMOD-BEGIN

[jvoung (off chromium), 2013/05/15 18:10:21]

dangling LOCALMOD-BEGIN?

[eliben, 2013/05/15 18:13:33]

Done.

-#if defined(__native_client__) && defined(NACL_SRPC)
-void RecordMetadataForSrpc(const Module &mod) {
-  bool is_shared = (mod.getOutputFormat() == Module::SharedOutputFormat);
-  std::string soname = mod.getSOName();
-  NaClRecordObjectInformation(is_shared, soname);
-  for (Module::lib_iterator L = mod.lib_begin(),
-                            E = mod.lib_end();
-       L != E; ++L) {
-    NaClRecordSharedLibraryDependency(*L);
-  }
-}
-#endif  // defined(__native_client__) && defined(NACL_SRPC)
-// @LOCALMOD-END
-
-
-// @LOCALMOD-BEGIN
-
-// Write the ELF Stubs to the metadata file, in text format
-// Returns 0 on success, non-zero on error.
-int WriteTextMetadataFile(const Module &M, const Triple &TheTriple) {
-  // Build the ELF stubs (in high level format)
-  SmallVector<ELFStub*, 8> StubList;
-  // NOTE: The triple is unnecessary for the text version.
-  MakeAllStubs(M, TheTriple, &StubList);
-  // For each stub, write the ELF object to the metadata file.
-  std::string s;
-  for (unsigned i = 0; i < StubList.size(); i++) {
-    WriteTextELFStub(StubList[i], &s);
-  }
-  FreeStubList(&StubList);
-
-#if defined(__native_client__) && defined(NACL_SRPC)
-  llvm_unreachable("Not yet implemented. Need a file handle to write to.");
-#else
-  std::string error;
-  OwningPtr<tool_output_file> MOut(
-      new tool_output_file(MetadataTextFilename.c_str(), error,
-                           raw_fd_ostream::F_Binary));
-  if (!error.empty()) {
-    errs() << error << '\n';
-    return 1;
-  }
-  MOut->os().write(s.data(), s.size());
-  MOut->keep();
-#endif
-  return 0;
-}
-
-// @LOCALMOD-END
 
 // main - Entry point for the llc compiler.
 //
 int llc_main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
   // Enable debug stream buffering.
   EnableDebugBuffering = true;
 
@@ skipping 95 matching lines @@
     }
 
     // @LOCALMOD-BEGIN
     if (PNaClABIVerify) {
       // Verify the module (but not the functions yet)
       ModulePass *VerifyPass = createPNaClABIVerifyModulePass(&ABIErrorReporter);
       VerifyPass->runOnModule(*mod);
       CheckABIVerifyErrors(ABIErrorReporter, "Module");
     }
 #if defined(__native_client__) && defined(NACL_SRPC)
-    RecordMetadataForSrpc(*mod);
-
     // To determine if we should compile PIC or not, we needed to load at
     // least the metadata. Since we've already constructed the commandline,
     // we have to hack this in after commandline processing.
     if (mod->getOutputFormat() == Module::SharedOutputFormat) {
       RelocModel = Reloc::PIC_;
     }
     // Also set PIC_ for dynamic executables:
     // BUG= http://code.google.com/p/nativeclient/issues/detail?id=2351
     if (mod->lib_size() > 0) {
       RelocModel = Reloc::PIC_;
@@ skipping 225 matching lines @@
       P->doFinalization();
     } else {
       static_cast<PassManager*>(PM.get())->run(*mod);
     }
   }
 
   // Declare success.
   Out->keep();
 #endif
 
-  // @LOCALMOD-BEGIN
-  // Write out the metadata.
-  //
-  // We need to ensure that intrinsic prototypes are available, in case
-  // we have a NeededRecord for one of them.
-  // They may have been eliminated by the StripDeadPrototypes pass,
-  // or some other pass that is unaware of NeededRecords / IntrinsicLowering.
-  if (!MetadataTextFilename.empty()) {
-    IntrinsicLowering IL(*target->getDataLayout());
-    IL.AddPrototypes(*M);
-
-    int err = WriteTextMetadataFile(*M.get(), TheTriple);
-    if (err != 0)
-      return err;
-  }
-  // @LOCALMOD-END
-
   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