ABI verifier: Add standalone tool pnacl-abicheck

lib/Analysis/NaCl/PNaClABIVerifyFunctions.cpp

 //===- PNaClABIVerifyFunctions.cpp - Verify PNaCl ABI rules --------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Verify function-level PNaCl ABI requirements.
@@ skipping 12 matching lines @@
 #include "PNaClABITypeChecker.h"
 using namespace llvm;
 
 namespace {
 
 // Checks that examine anything in the function body should be in
 // FunctionPasses to make them streaming-friendly
 class PNaClABIVerifyFunctions : public FunctionPass {
  public:
   static char ID;
-  PNaClABIVerifyFunctions() : FunctionPass(ID), Errors(ErrorsString) {}
+  PNaClABIVerifyFunctions() : FunctionPass(ID), Errors(ErrorsString),
+                              Strict(false), ErrorCount(0) {}
   bool runOnFunction(Function &F);
   virtual void print(raw_ostream &O, const Module *M) const;
+  virtual void setStrict(bool Strict_) { Strict = Strict_; }
+  virtual int getErrorCount() { return ErrorCount; }
  private:
   PNaClABITypeChecker TC;
   std::string ErrorsString;
   raw_string_ostream Errors;
+  bool Strict;
+  int ErrorCount;
 };
 
 } // and anonymous namespace
 
 bool PNaClABIVerifyFunctions::runOnFunction(Function &F) {
   // For now just start with new errors on each function; this may change
   // once we want to do something with them other than just calling print()
   ErrorsString.clear();
+  ErrorCount = 0;
   // TODO: only report one error per instruction
   for (Function::const_iterator FI = F.begin(), FE = F.end();
            FI != FE; ++FI) {
     for (BasicBlock::const_iterator BBI = FI->begin(), BBE = FI->end();
              BBI != BBE; ++BBI) {
       switch (BBI->getOpcode()) {
         // Disallowed instructions. Default is to disallow.
         default:
         // indirectbr may interfere with streaming
         case Instruction::IndirectBr:
         // No vector instructions yet
         case Instruction::ExtractElement:
         case Instruction::InsertElement:
         case Instruction::ShuffleVector:
           Errors << "Function " + F.getName() +
               " has disallowed instruction: " +
               BBI->getOpcodeName() + "\n";
+          ErrorCount++;
           break;
 
         // Terminator instructions
         case Instruction::Ret:
         case Instruction::Br:
         case Instruction::Switch:
         case Instruction::Resume:
         case Instruction::Unreachable:
         case Instruction::Invoke:
         // Binary operations
@@ skipping 47 matching lines @@
         case Instruction::Call:
         case Instruction::VAArg:
         case Instruction::LandingPad:
           break;
       }
       // Check the types. First check the type of the instruction.
       if (!TC.isValidType(BBI->getType())) {
         Errors << "Function " + F.getName() +
             " has instruction with disallowed type: " +
             PNaClABITypeChecker::getTypeName(BBI->getType()) + "\n";
+        ErrorCount++;
       }
 
       // Check the instruction operands. Operands which are Instructions will
       // be checked on their own here, and GlobalValues will be checked by the
       // Module verifier. That leaves Constants.
       // Switches are implemented in the in-memory IR with vectors, so don't
       // check them.
       if (!isa<SwitchInst>(*BBI))
         for (User::const_op_iterator OI = BBI->op_begin(), OE = BBI->op_end();
              OI != OE; OI++) {
           if (isa<Constant>(OI) && !isa<GlobalValue>(OI)) {
             Type *T = TC.checkTypesInConstant(cast<Constant>(*OI));
-            if (T)
+            if (T) {
               Errors << "Function " + F.getName() +
                   " has instruction operand with disallowed type: " +
                   PNaClABITypeChecker::getTypeName(T) + "\n";
+              ErrorCount++;
+            }
           }
         }
 
       // Get types hiding in metadata attached to the instruction
       SmallVector<std::pair<unsigned, MDNode*>, 4> MDForInst;
       BBI->getAllMetadataOtherThanDebugLoc(MDForInst);
       for (unsigned i = 0, e = MDForInst.size(); i != e; i++) {
         Type *T = TC.checkTypesInMDNode(MDForInst[i].second);
-        if (T)
+        if (T) {
           Errors << "Function " + F.getName() +
               " has instruction metadata containing disallowed type: " +
               PNaClABITypeChecker::getTypeName(T) + "\n";
+          ErrorCount++;
+        }
       }
     }
   }
 
   Errors.flush();
+  if (Strict && ErrorCount > 0) {
+    report_fatal_error("Function " + F.getName() +
+                       " is not valid PNaCl bitcode:\n" + ErrorsString);
+  }
   return false;
 }
 
 void PNaClABIVerifyFunctions::print(llvm::raw_ostream &O, const Module *M)
     const {
   O << ErrorsString;
 }
 
 char PNaClABIVerifyFunctions::ID = 0;
 
 static RegisterPass<PNaClABIVerifyFunctions> X("verify-pnaclabi-functions",
     "Verify functions for PNaCl", false, false);
 
-FunctionPass *llvm::createPNaClABIVerifyFunctionsPass() {
-  return new PNaClABIVerifyFunctions();
+FunctionPass *llvm::createPNaClABIVerifyFunctionsPass(bool Strict) {
+  PNaClABIVerifyFunctions *P = new PNaClABIVerifyFunctions();
+  P->setStrict(Strict);
+  return P;
 }