Subzero: Support non sequentially consistent memory orderings for atomic ops.

src/IceIntrinsics.cpp

Index: src/IceIntrinsics.cpp
diff --git a/src/IceIntrinsics.cpp b/src/IceIntrinsics.cpp
index 26a81dea7eaa10b5836e1aac95d29011c9396db9..4fdac75a2f5a6946965c4d0bb7d8bad26d6561d5 100644
--- a/src/IceIntrinsics.cpp
+++ b/src/IceIntrinsics.cpp
@@ -233,9 +233,60 @@ const Intrinsics::FullIntrinsicInfo *Intrinsics::find(const IceString &Name,
   return &it->second;
 }
 
-bool Intrinsics::VerifyMemoryOrder(uint64_t Order) {
-  // There is only one memory ordering for atomics allowed right now.
-  return Order == Intrinsics::MemoryOrderSequentiallyConsistent;
+bool Intrinsics::isMemoryOrderValid(IntrinsicID ID, uint64_t Order,
+                                    uint64_t OrderOther) {
+  // Reject orderings not allowed in PNaCl.
+  switch (Order) {
+  case Intrinsics::MemoryOrderInvalid:
+  case Intrinsics::MemoryOrderNum:
+  case Intrinsics::MemoryOrderRelaxed:
+  case Intrinsics::MemoryOrderConsume:
+    return false;
+  }

[JF, 2015/03/17 16:58:53]

I'd do the opposite and whitelist acquire/release/acq_rel/seq_cst: the file
format could contain any other number and you don't want to let them through.

[Jim Stichnoth, 2015/03/17 18:42:04]

Done.

+  // Reject orderings not allowed by C++11.
+  switch (ID) {
+  default:
+    llvm_unreachable("isMemoryOrderValid: Unknown IntrinsicID");
+    return false;
+  case AtomicFence:
+  case AtomicFenceAll:
+  case AtomicRMW:
+    return true;
+  case AtomicCmpxchg:
+    switch (OrderOther) {
+    case Intrinsics::MemoryOrderInvalid:
+    case Intrinsics::MemoryOrderNum:
+    case Intrinsics::MemoryOrderRelease:
+    case Intrinsics::MemoryOrderAcquireRelease:
+    case Intrinsics::MemoryOrderRelaxed:
+    case Intrinsics::MemoryOrderConsume:
+      return false;
+    default:
+      if (OrderOther > Order)
+        return false;
+      if (Order == Intrinsics::MemoryOrderRelease &&
+          OrderOther != Intrinsics::MemoryOrderRelaxed)

[JF, 2015/03/17 21:18:14]

I would leave this in, otherwise when we add relaxed we won't be doing the right
thing.

[Jim Stichnoth, 2015/03/18 00:00:25]

OK, yeah, that optimization did seem too good to be true...

+        return false;
+      return true;
+    }
+  case AtomicLoad:
+    switch (Order) {
+    case Intrinsics::MemoryOrderRelease:
+    case Intrinsics::MemoryOrderAcquireRelease:
+      return false;
+    default:
+      return true;
+    }
+  case AtomicStore:
+    switch (Order) {
+    case Intrinsics::MemoryOrderConsume:
+    case Intrinsics::MemoryOrderAcquire:
+    case Intrinsics::MemoryOrderAcquireRelease:
+      return false;
+    default:
+      return true;
+    }
+  }
 }
 
 Intrinsics::ValidateCallValue