Concurrency support for PNaCl ABI

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
 // require looking at the function bodies)
 //
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Pass.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/NaCl.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/NaClIntrinsics.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "PNaClABITypeChecker.h"
 using namespace llvm;
 
 namespace llvm {
 cl::opt<bool>
 PNaClABIAllowDebugMetadata("pnaclabi-allow-debug-metadata",
   cl::desc("Allow debug metadata during PNaCl ABI verification."),
@@ skipping 26 matching lines @@
     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 isWhitelistedIntrinsic(const Function *F, unsigned ID);
+  bool isWhitelistedIntrinsic(const NaCl::AtomicIntrinsics *AI,
+                              const Function *F, Intrinsic::ID ID);
   bool isWhitelistedMetadata(const NamedMDNode *MD);
   void checkGlobalIsFlattened(const GlobalVariable *GV);
   PNaClABIErrorReporter *Reporter;
   bool ReporterIsOwned;
   bool StreamingMode;
 };
 
 static const char *linkageName(GlobalValue::LinkageTypes LT) {
   // This logic is taken from PrintLinkage in lib/VMCore/AsmWriter.cpp
   switch (LT) {
@@ skipping 83 matching lines @@
   if (FT->getNumParams() != 1)
     return false;
   Type *ParamType = FT->getParamType(0);
   LLVMContext &C = F->getContext();
   Type *AcceptableTypes[] = { Type::getInt16Ty(C),
                               Type::getInt32Ty(C),
                               Type::getInt64Ty(C) };
   return TypeAcceptable(ParamType, AcceptableTypes);
 }
 
+static bool isWhitelistedAtomic(const NaCl::AtomicIntrinsics *AI,
+                                const Function *F, Intrinsic::ID ID) {
+  FunctionType *FT = F->getFunctionType();
+  for (NaCl::AtomicIntrinsics::const_iterator I = AI->begin(ID),
+                                              E = AI->end(ID);
+       I != E; ++I) {
+    bool Match = true;
+    for (size_t P = 0; P != I->NumParams; ++P)

[Mark Seaborn, 2013/07/02 19:16:02]

Start a "{" block here since the body is multi-line.  However, I suspect this
code isn't needed after you rebase, since types of intrinsics are checked now.

[JF, 2013/07/02 23:14:54]

Done.

+      if (I->Parameter(P) != FT->getParamType(P))
+        Match = false;
+    if (Match)
+      return true;
+  }
+  return false;
+}
+
 // We accept cttz, ctlz, and ctpop for a limited set of types (i32, i64).
 static bool isWhitelistedCountBits(const Function *F, unsigned num_params) {
   FunctionType *FT = F->getFunctionType();
   if (FT->getNumParams() != num_params)
     return false;
   Type *ParamType = FT->getParamType(0);
   LLVMContext &C = F->getContext();
   Type *AcceptableTypes[] = { Type::getInt32Ty(C), Type::getInt64Ty(C) };
   return TypeAcceptable(ParamType, AcceptableTypes);
 }
 
-bool PNaClABIVerifyModule::isWhitelistedIntrinsic(const Function *F,
-                                                  unsigned ID) {
+bool PNaClABIVerifyModule::isWhitelistedIntrinsic(const NaCl::AtomicIntrinsics *AI,

[Mark Seaborn, 2013/07/02 19:16:02]

Line is >80 chars

[JF, 2013/07/02 23:14:54]

Done.

+                                                  const Function *F,
+                                                  Intrinsic::ID ID) {
   // Keep 3 categories of intrinsics for now.
-  // (1) Allowed always
-  // (2) Never allowed
+  // (1) Allowed.
+  // (2) Never allowed.
   // (3) "Dev" intrinsics, which may or may not be allowed.
   // "Dev" intrinsics are controlled by the PNaClABIAllowDevIntrinsics flag.
   // Please keep these sorted or grouped in a sensible way, within
   // each category.
   switch(ID) {
     // Disallow by default.
     default: return false;
-    // (1) Always allowed.
+    // (1) Allowed.
+    case Intrinsic::memcpy:

[Mark Seaborn, 2013/07/02 19:16:02]

You'll need to rebase this on top of recent changes

+    case Intrinsic::memmove:
+    case Intrinsic::memset:
+    case Intrinsic::nacl_setjmp:
+    case Intrinsic::nacl_longjmp:
+    case Intrinsic::nacl_read_tp:
+    case Intrinsic::trap:
+      return true;
+    case Intrinsic::nacl_atomic_load:
+    case Intrinsic::nacl_atomic_store:
+    case Intrinsic::nacl_atomic_rmw:
+    case Intrinsic::nacl_atomic_cmpxchg:
+    case Intrinsic::nacl_atomic_fence:
+      return isWhitelistedAtomic(AI, F, ID);
     case Intrinsic::bswap: return isWhitelistedBswap(F);
     case Intrinsic::ctlz:
     case Intrinsic::cttz: return isWhitelistedCountBits(F, 2);
     case Intrinsic::ctpop: return isWhitelistedCountBits(F, 1);
-    case Intrinsic::memcpy:
-    case Intrinsic::memmove:
-    case Intrinsic::memset:
-    case Intrinsic::nacl_read_tp:
-    case Intrinsic::nacl_setjmp:
-    case Intrinsic::nacl_longjmp:
-    case Intrinsic::trap:
-      return true;
 
     // (2) Known to be never allowed.
     case Intrinsic::not_intrinsic:
     // Trampolines depend on a target-specific-sized/aligned buffer.
     case Intrinsic::adjust_trampoline:
     case Intrinsic::init_trampoline:
     // CXX exception handling is not stable.
     case Intrinsic::eh_dwarf_cfa:
     case Intrinsic::eh_return_i32:
     case Intrinsic::eh_return_i64:
@@ skipping 168 matching lines @@
     }
   }
 
   // No aliases allowed for now.
   for (Module::alias_iterator MI = M.alias_begin(),
            E = M.alias_end(); MI != E; ++MI) {
     Reporter->addError() << "Variable " << MI->getName() <<
         " is an alias (disallowed)\n";
   }
 
+  NaCl::AtomicIntrinsics AI(M.getContext());
   for (Module::const_iterator MI = M.begin(), ME = M.end(); MI != ME; ++MI) {
     if (MI->isIntrinsic()) {
       // Check intrinsics.
-      if (!isWhitelistedIntrinsic(MI, MI->getIntrinsicID())) {
+      Intrinsic::ID ID = (Intrinsic::ID) MI->getIntrinsicID();
+      if (!isWhitelistedIntrinsic(&AI, MI, ID)) {
         Reporter->addError() << "Function " << MI->getName()
                              << " is a disallowed LLVM intrinsic\n";
       }
     } else {
       // Check types of functions and their arguments.  Not necessary
       // for intrinsics, whose types are fixed anyway, and which have
       // argument types that we disallow such as i8.
       if (!PNaClABITypeChecker::isValidFunctionType(MI->getFunctionType())) {
         Reporter->addError() << "Function " << MI->getName()
             << " has disallowed type: "
@@ skipping 60 matching lines @@
 }
 
 char PNaClABIVerifyModule::ID = 0;
 INITIALIZE_PASS(PNaClABIVerifyModule, "verify-pnaclabi-module",
                 "Verify module for PNaCl", false, true)
 
 ModulePass *llvm::createPNaClABIVerifyModulePass(
     PNaClABIErrorReporter *Reporter, bool StreamingMode) {
   return new PNaClABIVerifyModule(Reporter, StreamingMode);
 }