ABI verifier: Add standalone tool pnacl-abicheck

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/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/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/Module.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Pass.h"
@@ skipping 72 matching lines @@
 
 // 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 180 matching lines @@
   cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
 
   // Compile the module TimeCompilations times to give better compile time
   // metrics.
   for (unsigned I = TimeCompilations; I; --I)
     if (int RetVal = compileModule(argv, Context))
       return RetVal;
   return 0;
 }
 
+// @LOCALMOD-BEGIN
+static void CheckABIVerifyErrors(PNaClABIErrorReporter &Reporter,
+                                 const Twine &Name) {
+  if (PNaClABIVerify && Reporter.getErrorCount() > 0) {
+    errs() << (PNaClABIVerifyFatalErrors ? "ERROR:" : "WARNING:");
+    errs() << Name << " is not valid PNaCl bitcode:\n";
+    Reporter.printErrors(errs());
+    if (PNaClABIVerifyFatalErrors)
+      exit(1);
+  }
+  Reporter.reset();
+}
+// @LOCALMOD-END
+
 static int compileModule(char **argv, LLVMContext &Context) {
   // Load the module to be compiled...
   SMDiagnostic Err;
   std::auto_ptr<Module> M;
   Module *mod = 0;
   Triple TheTriple;
 
   bool SkipModule = MCPU == "help" ||
                     (!MAttrs.empty() && MAttrs.front() == "help");
 
+  PNaClABIErrorReporter ABIErrorReporter; // @LOCALMOD
+
   // If user just wants to list available options, skip module loading
   if (!SkipModule) {
     // @LOCALMOD-BEGIN
 #if defined(__native_client__) && defined(NACL_SRPC)
     if (LazyBitcode) {
       std::string StrError;
       M.reset(getStreamedBitcodeModule(
           std::string("<SRPC stream>"),
           NaClBitcodeStreamer, Context, &StrError));
       if (!StrError.empty()) {
         Err = SMDiagnostic(InputFilename, SourceMgr::DK_Error, StrError);
       }
     } else {
       // Avoid using ParseIRFile to avoid pulling in the LLParser.
       // Only handle binary bitcode.
       llvm_unreachable("native client SRPC only supports streaming");
     }
 #else
     M.reset(ParseIRFile(InputFilename, Err, Context));
 #endif
     // @LOCALMOD-END
 
     mod = M.get();
     if (mod == 0) {
       Err.print(argv[0], errs());
       return 1;
     }
 
     // @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:
@@ skipping 106 matching lines @@
   if (!Out) return 1;
 #endif
 
   // Build up all of the passes that we want to do to the module.
   // @LOCALMOD-BEGIN
   OwningPtr<PassManagerBase> PM;
   if (LazyBitcode || ReduceMemoryFootprint)
     PM.reset(new FunctionPassManager(mod));
   else
     PM.reset(new PassManager());
+
+  // Add the ABI verifier pass before the analysis and code emission passes.
+  FunctionPass *FunctionVerifyPass = NULL;
+  if (PNaClABIVerify) {
+    FunctionVerifyPass = createPNaClABIVerifyFunctionsPass(&ABIErrorReporter);
+    PM->add(FunctionVerifyPass);
+  }
   // @LOCALMOD-END
 
   // Add an appropriate TargetLibraryInfo pass for the module's triple.
   TargetLibraryInfo *TLI = new TargetLibraryInfo(TheTriple);
   if (DisableSimplifyLibCalls)
     TLI->disableAllFunctions();
   PM->add(TLI);
 
   // Add intenal analysis passes from the target machine.
   Target.addAnalysisPasses(*PM.get());
@@ skipping 14 matching lines @@
     else
       Target.setMCRelaxAll(true);
   }
 
 
 #if defined __native_client__ && defined(NACL_SRPC)
   {
     raw_fd_ostream ROS(GetObjectFileFD(), true);
     ROS.SetBufferSize(1 << 20);
     formatted_raw_ostream FOS(ROS);
+
     // Ask the target to add backend passes as necessary.
     if (Target.addPassesToEmitFile(*PM, FOS, FileType, NoVerify)) {
       errs() << argv[0] << ": target does not support generation of this"
              << " file type!\n";
       return 1;
     }
 
     if (LazyBitcode || ReduceMemoryFootprint) {
       FunctionPassManager* P = static_cast<FunctionPassManager*>(PM.get());
       P->doInitialization();
       for (Module::iterator I = mod->begin(), E = mod->end(); I != E; ++I) {
         P->run(*I);
+        CheckABIVerifyErrors(ABIErrorReporter, "Function " + I->getName());
         if (ReduceMemoryFootprint) {
           I->Dematerialize();
         }
       }
       P->doFinalization();
     } else {
       static_cast<PassManager*>(PM.get())->run(*mod);
     }
     FOS.flush();
     ROS.flush();
@@ skipping 32 matching lines @@
     }
 
     // Before executing passes, print the final values of the LLVM options.
     cl::PrintOptionValues();
 
     if (LazyBitcode || ReduceMemoryFootprint) {
       FunctionPassManager *P = static_cast<FunctionPassManager*>(PM.get());
       P->doInitialization();
       for (Module::iterator I = mod->begin(), E = mod->end(); I != E; ++I) {
         P->run(*I);
+        CheckABIVerifyErrors(ABIErrorReporter, "Function " + I->getName());
         if (ReduceMemoryFootprint) {
           I->Dematerialize();
         }
       }
       P->doFinalization();
     } else {
       static_cast<PassManager*>(PM.get())->run(*mod);
     }
   }
 
@@ skipping 22 matching lines @@
 }
 
 #if !defined(NACL_SRPC)
 int
 main (int argc, char **argv) {
   return llc_main(argc, argv);
 }
 #else
 // main() is in nacl_file.cpp.
 #endif