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/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/NaCl.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 141 matching lines @@
 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);
 }
 
+// The signature for atomics is:
+// T nacl.atomic.<size>(int32_t operation, T *location, T value,

[Derek Schuff, 2013/06/26 17:03:29]

should be llvm.nacl.atomic.<size> when represented as an intrinsic name, right?

[JF, 2013/06/26 23:41:12]

Yes, I fixed all of these in a previous change.

+//                      T old_value, int32_t memory_order);
+// With:
+//  - T in {i8, i16, i32, i64}.
+//  - operation as a valid NaCl::AtomicOperation.
+//  - memory_order as a valid NaCl::MemoryOrder.
+static bool isWhitelistedAtomic(const Function *F, unsigned ID) {
+  LLVMContext &C = F->getContext();
+  FunctionType *FT = F->getFunctionType();
+
+  Type *ReturnType = FT->getReturnType();
+  switch (ID) {
+    default: llvm_unreachable("unhandled atomic intrinsic");
+    case Intrinsic::nacl_atomic_8:
+      if (ReturnType != Type::getInt8Ty(C)) return false;
+      break;
+    case Intrinsic::nacl_atomic_16:
+      if (ReturnType != Type::getInt16Ty(C)) return false;
+      break;
+    case Intrinsic::nacl_atomic_32:
+      if (ReturnType != Type::getInt32Ty(C)) return false;
+      break;
+    case Intrinsic::nacl_atomic_64:
+      if (ReturnType != Type::getInt64Ty(C)) return false;
+      break;
+  }
+
+  if ((FT->getNumParams() != 5) ||
+      (FT->getParamType(0) != Type::getInt32Ty(C)) ||
+      (!FT->getParamType(1)->isPointerTy()) ||
+      (FT->getParamType(1)->getPointerElementType() != ReturnType) ||
+      (FT->getParamType(2) != ReturnType) ||
+      (FT->getParamType(3) != ReturnType) ||
+      (FT->getParamType(4) != Type::getInt32Ty(C)))
+    return false;
+
+  // Validate the operation and memory_order arguments have whitelisted values.
+  for (Value::const_use_iterator Call(F->use_begin()), CallEnd(F->use_end());

[Derek Schuff, 2013/06/26 17:03:29]

= instead of constructor syntax here too.

[JF, 2013/06/26 23:41:12]

Done in a previous change.

+       Call != CallEnd; ++Call) {
+    if (const CallInst *C = dyn_cast<CallInst>(*Call)) {
+      assert(C->getNumArgOperands() == 5 && "call should have as many "
+             "arguments as the corresponding intrinsic");
+      const Value *Operation = C->getArgOperand(0);
+      const Value *MemoryOrder = C->getArgOperand(4);
+      const Constant *OperationC = dyn_cast<Constant>(Operation);
+      const Constant *MemoryOrderC = dyn_cast<Constant>(MemoryOrder);
+      if (!Operation || !MemoryOrder)
+        return false;
+      const APInt &OperationI = OperationC->getUniqueInteger();
+      const APInt &MemoryOrderI = MemoryOrderC->getUniqueInteger();
+      if (OperationI.ule(NaCl::AtomicInvalid) ||
+          OperationI.uge(NaCl::AtomicNum))
+        return false;
+      if (MemoryOrderI.ule(NaCl::MemoryOrderInvalid) ||
+          MemoryOrderI.uge(NaCl::MemoryOrderNum))
+        return false;
+      // TODO For now only sequential consistency is allowed.
+      if (MemoryOrderI != NaCl::MemoryOrderSequentiallyConsistent)
+        return false;
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool PNaClABIVerifyModule::isWhitelistedIntrinsic(const Function *F,
                                                   unsigned ID) {
   // Keep 3 categories of intrinsics for now.

[Derek Schuff, 2013/06/26 17:03:29]

new! now with 33% more categories!

[JF, 2013/06/26 23:41:12]

<marquee>

   // (1) Allowed always
-  // (2) Never allowed
-  // (3) "Dev" intrinsics, which may or may not be allowed.
+  // (2) Allowed with certain restrictions.
+  // (3) Never allowed
+  // (4) "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.
-    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.
+    // (2) Allowed with certain restrictions.
+    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::nacl_atomic_8:
+    case Intrinsic::nacl_atomic_16:
+    case Intrinsic::nacl_atomic_32:
+    case Intrinsic::nacl_atomic_64: return isWhitelistedAtomic(F, ID);
+
+    // (3) 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:
     case Intrinsic::eh_sjlj_callsite:
     case Intrinsic::eh_sjlj_functioncontext:
@@ skipping 41 matching lines @@
     case Intrinsic::sin: // Rounding not defined: support with fast-math?
     // We run -lower-expect to convert Intrinsic::expect into branch weights
     // and consume in the middle-end. The backend just ignores llvm.expect.
     case Intrinsic::expect:
     // For FLT_ROUNDS macro from float.h. It works for ARM and X86
     // (but not MIPS). Also, wait until we add a set_flt_rounds intrinsic
     // before we bless this.
     case Intrinsic::flt_rounds:
       return false;
 
-    // (3) Dev intrinsics.
+    // (4) Dev intrinsics.
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_value:
       return PNaClABIAllowDevIntrinsics || PNaClABIAllowDebugMetadata;
     case Intrinsic::nacl_target_arch: // Used by translator self-build.
     case Intrinsic::pow: // Rounding is supposed to be the same as libm.
     case Intrinsic::powi: // Rounding not defined: support with fast-math?
     case Intrinsic::prefetch: // Could ignore if target doesn't support?
     case Intrinsic::sqrt: // Rounding is defined, but setting errno up to libm.
     case Intrinsic::stackrestore: // Used to support C99 VLAs.
     case Intrinsic::stacksave: // Used to support C99 VLAs.
@@ skipping 188 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);
 }