Check for metadata in PNaCl ABI checker.

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.
 //
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Pass.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/NaCl.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "PNaClABITypeChecker.h"
 using namespace llvm;
 
 namespace {
 
 // Checks that examine anything in the function body should be in
 // FunctionPasses to make them streaming-friendly
@@ skipping 12 matching lines @@
       ReporterIsOwned(false) {
     initializePNaClABIVerifyFunctionsPass(*PassRegistry::getPassRegistry());
   }
   ~PNaClABIVerifyFunctions() {
     if (ReporterIsOwned)
       delete Reporter;
   }
   bool runOnFunction(Function &F);
   virtual void print(raw_ostream &O, const Module *M) const;
  private:
+  bool IsWhitelistedMetadata(unsigned MDKind);
   PNaClABITypeChecker TC;
   PNaClABIErrorReporter *Reporter;
   bool ReporterIsOwned;
 };
 
+// There's no built-in way to get the name of an MDNode, so use a
+// string ostream to print it.
+std::string getMDNodeString(unsigned Kind,
+                            const SmallVectorImpl<StringRef>& MDNames) {
+  std::string MDName;
+  raw_string_ostream N(MDName);
+  if (Kind < MDNames.size()) {
+    N << "!" << MDNames[Kind];
+  } else {
+    N << "!<unknown kind #" << Kind << ">";
+  }
+  return N.str();
+}
+
 } // and anonymous namespace
 
+bool PNaClABIVerifyFunctions::IsWhitelistedMetadata(unsigned MDKind) {
+  return MDKind == LLVMContext::MD_dbg && PNaClABIAllowDebugMetadata;
+}
+
 bool PNaClABIVerifyFunctions::runOnFunction(Function &F) {
+  SmallVector<StringRef, 8> MDNames;
+  F.getContext().getMDKindNames(MDNames);
+
   // 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:
         // We expand GetElementPtr out into arithmetic.
         case Instruction::GetElementPtr:
@@ skipping 104 matching lines @@
         }
 
       for (User::const_op_iterator OI = BBI->op_begin(), OE = BBI->op_end();
            OI != OE; OI++) {
         if (isa<ConstantExpr>(OI)) {
           Reporter->addError() << "Function " << F.getName() <<
               " contains disallowed ConstantExpr\n";
         }
       }
 
-      // Get types hiding in metadata attached to the instruction
+      // Check instruction attachment metadata.
       SmallVector<std::pair<unsigned, MDNode*>, 4> MDForInst;
-      BBI->getAllMetadataOtherThanDebugLoc(MDForInst);
+      BBI->getAllMetadata(MDForInst);
+
       for (unsigned i = 0, e = MDForInst.size(); i != e; i++) {
-        Type *T = TC.checkTypesInMDNode(MDForInst[i].second);
-        if (T) {
-          Reporter->addError() << "Function " << F.getName() <<
-              " has instruction metadata containing disallowed type: " <<
-              PNaClABITypeChecker::getTypeName(T) << "\n";
+        if (!IsWhitelistedMetadata(MDForInst[i].first)) {
+          Reporter->addError()
+              << "Function " << F.getName()
+              << " has disallowed instruction metadata: "
+              << getMDNodeString(MDForInst[i].first, MDNames) << "\n";
+        } else {
+          // If allowed, check the types hiding in the metadata.
+          Type *T = TC.checkTypesInMDNode(MDForInst[i].second);
+          if (T) {
+            Reporter->addError()
+                << "Function " << F.getName()
+                << " has instruction metadata containing disallowed type: "
+                << PNaClABITypeChecker::getTypeName(T) << "\n";
+          }
         }
       }
     }
   }
 
   Reporter->checkForFatalErrors();
   return false;
 }
 
 // This method exists so that the passes can easily be run with opt -analyze.
 // In this case the default constructor is used and we want to reset the error
 // messages after each print.
 void PNaClABIVerifyFunctions::print(llvm::raw_ostream &O, const Module *M)
     const {
   Reporter->printErrors(O);
   Reporter->reset();
 }
 
 char PNaClABIVerifyFunctions::ID = 0;
 INITIALIZE_PASS(PNaClABIVerifyFunctions, "verify-pnaclabi-functions",
                 "Verify functions for PNaCl", false, true)
 
 FunctionPass *llvm::createPNaClABIVerifyFunctionsPass(
     PNaClABIErrorReporter *Reporter) {
   return new PNaClABIVerifyFunctions(Reporter);
 }