Check for metadata in PNaCl ABI checker.

lib/Analysis/NaCl/PNaClABIVerifyModule.cpp

 //===- PNaClABIVerifyModule.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 module-level PNaCl ABI requirements (specifically those that do not
@@ skipping 13 matching lines @@
 using namespace llvm;
 
 namespace {
 // This pass should not touch function bodies, to stay streaming-friendly
 class PNaClABIVerifyModule : public ModulePass {
  public:
   static char ID;
   PNaClABIVerifyModule() :
       ModulePass(ID),
       Reporter(new PNaClABIErrorReporter),
-      ReporterIsOwned(true) {
+      ReporterIsOwned(true),
+      AllowDebugMetadata(false) {
     initializePNaClABIVerifyModulePass(*PassRegistry::getPassRegistry());
   }
-  explicit PNaClABIVerifyModule(PNaClABIErrorReporter *Reporter_) :
+  PNaClABIVerifyModule(PNaClABIErrorReporter *Reporter_,
+                       bool AllowDebugMetadata_) :
       ModulePass(ID),
       Reporter(Reporter_),
-      ReporterIsOwned(false) {
+      ReporterIsOwned(false),
+      AllowDebugMetadata(AllowDebugMetadata_) {

[Mark Seaborn, 2013/04/25 18:04:32]

Same style comment as other file

     initializePNaClABIVerifyModulePass(*PassRegistry::getPassRegistry());
   }
   ~PNaClABIVerifyModule() {
     if (ReporterIsOwned)
       delete Reporter;
   }
   bool runOnModule(Module &M);
   virtual void print(raw_ostream &O, const Module *M) const;
  private:
   void CheckGlobalValueCommon(const GlobalValue *GV);
+  bool WhiteListedMetadata(const NamedMDNode *MD);
   PNaClABITypeChecker TC;
   PNaClABIErrorReporter *Reporter;
   bool ReporterIsOwned;
+  bool AllowDebugMetadata;
 };
 
 static const char *linkageName(GlobalValue::LinkageTypes LT) {
   // This logic is taken from PrintLinkage in lib/VMCore/AsmWriter.cpp
   switch (LT) {
     case GlobalValue::ExternalLinkage: return "external";
     case GlobalValue::PrivateLinkage:       return "private ";
     case GlobalValue::LinkerPrivateLinkage: return "linker_private ";
     case GlobalValue::LinkerPrivateWeakLinkage: return "linker_private_weak ";
     case GlobalValue::InternalLinkage:      return "internal ";
@@ skipping 34 matching lines @@
       Reporter->addError() << GVTypeName << GV->getName()
                            << " has disallowed linkage type: "
                            << linkageName(GV->getLinkage()) << "\n";
   }
   if (GV->hasSection()) {
     Reporter->addError() << GVTypeName << GV->getName() <<
         " has disallowed \"section\" attribute\n";
   }
 }
 
+bool PNaClABIVerifyModule::WhiteListedMetadata(const NamedMDNode* MD) {
+  return MD->getName().startswith("llvm.dbg") && AllowDebugMetadata;

[Mark Seaborn, 2013/04/25 18:04:32]

Maybe "llvm.dbg." (trailing dot) to be stricter?

[jvoung (off chromium), 2013/04/25 23:22:20]

Done.

+}
+
 bool PNaClABIVerifyModule::runOnModule(Module &M) {
   for (Module::const_global_iterator MI = M.global_begin(), ME = M.global_end();
        MI != ME; ++MI) {
     // Check types of global variables and their initializers
     if (!TC.isValidType(MI->getType())) {
       // GVs are pointers, so print the pointed-to type for clarity
       Reporter->addError() << "Variable " << MI->getName() <<
           " has disallowed type: " <<
           PNaClABITypeChecker::getTypeName(MI->getType()->getContainedType(0))
           + "\n";
@@ skipping 49 matching lines @@
 
     if (MI->hasGC()) {
       Reporter->addError() << "Function " << MI->getName() <<
           " has disallowed \"gc\" attribute\n";
     }
   }
 
   // Check named metadata nodes
   for (Module::const_named_metadata_iterator I = M.named_metadata_begin(),
            E = M.named_metadata_end(); I != E; ++I) {
-    for (unsigned i = 0, e = I->getNumOperands(); i != e; i++) {
-      if (Type *T = TC.checkTypesInMDNode(I->getOperand(i))) {
-        Reporter->addError() << "Named metadata node " << I->getName() <<
-            " refers to disallowed type: " <<
-            PNaClABITypeChecker::getTypeName(T) << "\n";
+    if (!WhiteListedMetadata(I)) {
+      Reporter->addError() << "Named metadata node " << I->getName()
+                           << " is disallowed\n";
+    } else {
+      // Check the types in the metadata.
+      for (unsigned i = 0, e = I->getNumOperands(); i != e; i++) {
+        if (Type *T = TC.checkTypesInMDNode(I->getOperand(i))) {
+          Reporter->addError() << "Named metadata node " << I->getName()
+                               << " refers to 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 (this is more of an issue for the FunctionPass
 // than the ModulePass)
 void PNaClABIVerifyModule::print(llvm::raw_ostream &O, const Module *M) const {
   Reporter->printErrors(O);
   Reporter->reset();
 }
 
 char PNaClABIVerifyModule::ID = 0;
 INITIALIZE_PASS(PNaClABIVerifyModule, "verify-pnaclabi-module",
                 "Verify module for PNaCl", false, true)
 
 ModulePass *llvm::createPNaClABIVerifyModulePass(
-    PNaClABIErrorReporter *Reporter) {
-  return new PNaClABIVerifyModule(Reporter);
+    PNaClABIErrorReporter *Reporter,
+    bool AllowDebugMetadata) {
+  return new PNaClABIVerifyModule(Reporter, AllowDebugMetadata);
 }