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/STLExtras.h"
 #include "llvm/ADT/StringMap.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/NaClIntrinsics.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 NaCl::AtomicIntrinsics *AI,

[Mark Seaborn, 2013/07/03 04:55:20]

This isn't defined any more after rebasing

[JF, 2013/07/03 15:06:13]

Done, and the include up top.

+                              const Function *F, Intrinsic::ID ID);
   bool isWhitelistedMetadata(const NamedMDNode *MD);
 
   /// Returns whether \p GV is an allowed external symbol in stable bitcode.
   bool isWhitelistedExternal(const GlobalValue *GV);
 
   void checkGlobalIsFlattened(const GlobalVariable *GV);
   PNaClABIErrorReporter *Reporter;
   bool ReporterIsOwned;
   bool StreamingMode;
 };
@@ skipping 86 matching lines @@
   // definitions, but that should be done by user-toolchain
   // optimization passes, not by the PNaCl translator.
   if (GV->hasUnnamedAddr()) {
     Reporter->addError() << GVTypeName << GV->getName()
                          << " has disallowed \"unnamed_addr\" attribute\n";
   }
 }
 
 AllowedIntrinsics::AllowedIntrinsics(LLVMContext *Context) : Context(Context) {
   Type *I8Ptr = Type::getInt8PtrTy(*Context);
+  Type *I8 = Type::getInt8Ty(*Context);
   Type *I16 = Type::getInt16Ty(*Context);
   Type *I32 = Type::getInt32Ty(*Context);
   Type *I64 = Type::getInt64Ty(*Context);
 
   // We accept bswap for a limited set of types (i16, i32, i64).  The
   // various backends are able to generate instructions to implement
   // the intrinsic.  Also, i16 and i64 are easy to implement as along
   // as there is a way to do i32.
   addIntrinsic(Intrinsic::bswap, I16);
   addIntrinsic(Intrinsic::bswap, I32);
   addIntrinsic(Intrinsic::bswap, I64);
 
   // We accept cttz, ctlz, and ctpop for a limited set of types (i32, i64).
   addIntrinsic(Intrinsic::ctlz, I32);
   addIntrinsic(Intrinsic::ctlz, I64);
   addIntrinsic(Intrinsic::cttz, I32);
   addIntrinsic(Intrinsic::cttz, I64);
   addIntrinsic(Intrinsic::ctpop, I32);
   addIntrinsic(Intrinsic::ctpop, I64);
 
   addIntrinsic(Intrinsic::nacl_read_tp);
   addIntrinsic(Intrinsic::nacl_longjmp);
   addIntrinsic(Intrinsic::nacl_setjmp);
 
+  Type *AtomicTypes[] = { I8, I16, I32, I64 };
+  for (Type **T = &AtomicTypes[0], **E = T + array_lengthof(AtomicTypes);
+       T != E; ++T) {
+    addIntrinsic(Intrinsic::nacl_atomic_load, *T);
+    addIntrinsic(Intrinsic::nacl_atomic_store, *T);
+    addIntrinsic(Intrinsic::nacl_atomic_rmw, *T);
+    addIntrinsic(Intrinsic::nacl_atomic_cmpxchg, *T);
+  }
+  addIntrinsic(Intrinsic::nacl_atomic_fence);
+
   // Stack save and restore are used to support C99 VLAs.
   addIntrinsic(Intrinsic::stacksave);
   addIntrinsic(Intrinsic::stackrestore);
 
   addIntrinsic(Intrinsic::trap);
 
   // We only allow the variants of memcpy/memmove/memset with an i32
   // "len" argument, not an i64 argument.
   Type *MemcpyTypes[] = { I8Ptr, I8Ptr, I32 };
   addIntrinsic(Intrinsic::memcpy, MemcpyTypes);
   addIntrinsic(Intrinsic::memmove, MemcpyTypes);
   Type *MemsetTypes[] = { I8Ptr, I32 };
   addIntrinsic(Intrinsic::memset, MemsetTypes);
 }
 
 bool AllowedIntrinsics::isAllowed(const Function *Func) {
   // Keep 3 categories of intrinsics for now.
   // (1) Allowed always, provided the exact name and type match.
-  // (2) Never 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.
 
   // (1) Allowed always, provided the exact name and type match.
   if (Mapping.count(Func->getName()) == 1)
     return Func->getFunctionType() == Mapping[Func->getName()];
 
   switch (Func->getIntrinsicID()) {
@@ skipping 273 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);
 }