Add a "relaxed" memory order (#8984)

The memory order is not the C++ relaxed memory order, but rather the
slightly stronger load-store ordered memory order, which prevents
out-of-thin-air values by forbidding earlier atomic loads from being
reordered past later atomic stores. This makes it impossible to
construct the self-justifying causality cycle that gives rise to
out-of-thin-air values. The name of the memory order in both the
implementation and the text format is likely to change in the future to
become more descriptive.

Author: tlively

src/binaryen-c.cpp

@@ -430,6 +430,9 @@ BinaryenExternalKind BinaryenExternalTag(void) {
 BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderUnordered(void) {
   return static_cast<BinaryenMemoryOrder>(MemoryOrder::Unordered);
 }
+BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderRelaxed(void) {
+  return static_cast<BinaryenMemoryOrder>(MemoryOrder::Relaxed);
+}
 BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderAcqRel(void) {
   return static_cast<BinaryenMemoryOrder>(MemoryOrder::AcqRel);
 }

src/binaryen-c.h

@@ -211,6 +211,9 @@ typedef uint8_t BinaryenMemoryOrder;
 
 BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderUnordered(void);
 
+// Relaxed atomic memory operation.
+BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderRelaxed(void);
+
 // Acquire/Release atomic memory operation; acquire for loads, release for
 // stores.
 BINARYEN_API BinaryenMemoryOrder BinaryenMemoryOrderAcqRel(void);

src/ir/effects.h

@@ -364,6 +364,12 @@ class EffectAnalyzer {
     if (danglingPop) {
       return true;
     }
+    // Relaxed (or stronger) loads cannot be reordered after relaxed (or
+    // stronger) stores.
+    if (readOrder >= MemoryOrder::Relaxed &&
+        other.writeOrder >= MemoryOrder::Relaxed) {
+      return true;
+    }
     // Shared location accesses cannot be reordered after (but may be able to be
     // reordered before) release stores.
     if (other.writeOrder >= MemoryOrder::AcqRel &&

src/js/binaryen.js-post.js

@@ -162,8 +162,9 @@ function initializeConstants() {
   // MemoryOrder for atomic operations
   Module['MemoryOrder'] = {};
   [ 'Unordered',
-    'SeqCst',
-    'AcqRel'
+    'Relaxed',
+    'AcqRel',
+    'SeqCst'
    ].forEach(name => {
     Module['MemoryOrder'][name.toLowerCase()] = Module['_BinaryenMemoryOrder' + name]()
    });

src/parser/parsers.h

@@ -900,19 +900,22 @@ Result<typename Ctx::MemTypeT> memtypeContinued(Ctx& ctx, Type addressType) {
   return ctx.makeMemType(addressType, *limits, shared, pageSizeLog2);
 }
 
-// memorder ::= 'seqcst' | 'acqrel'
+// memorder ::= 'seqcst' | 'acqrel' | 'relaxed'
 template<typename Ctx> MaybeResult<MemoryOrder> maybeMemOrder(Ctx& ctx) {
   if (ctx.in.takeKeyword("seqcst"sv)) {
     return MemoryOrder::SeqCst;
   }
   if (ctx.in.takeKeyword("acqrel"sv)) {
     return MemoryOrder::AcqRel;
   }
+  if (ctx.in.takeKeyword("relaxed"sv)) {
+    return MemoryOrder::Relaxed;
+  }
 
   return {};
 }
 
-// memorder ::= '' | 'seqcst' | 'acqrel'
+// memorder ::= '' | 'seqcst' | 'acqrel' | 'relaxed'
 template<typename Ctx> Result<MemoryOrder> memorder(Ctx& ctx) {
   auto order = maybeMemOrder(ctx);
   CHECK_ERR(order);

src/passes/OptimizeInstructions.cpp

@@ -1913,6 +1913,7 @@ struct OptimizeInstructions
     trapOnNull(curr, curr->ref);
     // Relax acquire loads of unshared fields to unordered because they cannot
     // synchronize with other threads.
+    // TODO: Relax all other memory orderings as well.
     if (curr->order == MemoryOrder::AcqRel && curr->ref->type.isRef() &&
         !curr->ref->type.getHeapType().isShared()) {
       curr->order = MemoryOrder::Unordered;
@@ -1936,6 +1937,7 @@ struct OptimizeInstructions
 
     // Relax release stores of unshared fields to unordered because they cannot
     // synchronize with other threads.
+    // TODO: Relax all other memory orderings as well.
     if (curr->order == MemoryOrder::AcqRel && curr->ref->type.isRef() &&
         !curr->ref->type.getHeapType().isShared()) {
       curr->order = MemoryOrder::Unordered;

src/passes/Precompute.cpp

@@ -158,8 +158,10 @@ class PrecomputingExpressionRunner
       case MemoryOrder::SeqCst:
         // This can never be precomputed away because it synchronizes with other
         // threads.
+        // TODO: Unify with other memory orderings below.
         return Flow(NONCONSTANT_FLOW);
       case MemoryOrder::AcqRel:
+      case MemoryOrder::Relaxed:
         // This synchronizes only with writes to the same data, so it can still
         // be precomputed if the data is not shared with other threads.
         if (curr->ref->type.getHeapType().isShared()) {
@@ -201,8 +203,10 @@ class PrecomputingExpressionRunner
       case MemoryOrder::SeqCst:
         // This can never be precomputed away because it synchronizes with other
         // threads.
+        // TODO: Unify with other memory orderings below.
         return Flow(NONCONSTANT_FLOW);
       case MemoryOrder::AcqRel:
+      case MemoryOrder::Relaxed:
         // This synchronizes only with writes to the same data, so it can still
         // be precomputed if the data is not shared with other threads.
         if (curr->ref->type.getHeapType().isShared()) {

src/passes/Print.cpp

@@ -2329,6 +2329,9 @@ struct PrintExpressionContents
       case MemoryOrder::AcqRel:
         o << " acqrel";
         break;
+      case MemoryOrder::Relaxed:
+        o << " relaxed";
+        break;
     }
   }
 
@@ -4042,6 +4045,9 @@ std::ostream& operator<<(std::ostream& os, wasm::MemoryOrder mo) {
     case wasm::MemoryOrder::Unordered:
       os << "Unordered";
       break;
+    case wasm::MemoryOrder::Relaxed:
+      os << "Relaxed";
+      break;
     case wasm::MemoryOrder::SeqCst:
       os << "SeqCst";
       break;

src/passes/SafeHeap.cpp

@@ -49,14 +49,18 @@ static Name getLoadName(Load* curr) {
       parts.push_back(std::to_string(curr->align));
       break;
     }
-    case MemoryOrder::SeqCst: {
-      parts.push_back("SC");
+    case MemoryOrder::Relaxed: {
+      parts.push_back("RLX");
       break;
     }
     case MemoryOrder::AcqRel: {
       parts.push_back("AR");
       break;
     }
+    case MemoryOrder::SeqCst: {
+      parts.push_back("SC");
+      break;
+    }
   }
 
   return "SAFE_HEAP_LOAD_" + String::join(parts, "_");
@@ -70,12 +74,17 @@ static Name getStoreName(Store* curr) {
       parts.push_back(std::to_string(curr->align));
       break;
     }
-    case MemoryOrder::SeqCst: {
-      parts.push_back("SC");
+    case MemoryOrder::Relaxed: {
+      parts.push_back("RLX");
       break;
     }
     case MemoryOrder::AcqRel: {
       parts.push_back("AR");
+      break;
+    }
+    case MemoryOrder::SeqCst: {
+      parts.push_back("SC");
+      break;
     }
   }
   return "SAFE_HEAP_STORE_" + String::join(parts, "_");
@@ -229,13 +238,14 @@ struct SafeHeap : public Pass {
   void addGlobals(Module* module, FeatureSet features) {
     // load funcs
     Load load;
-    std::vector<MemoryOrder> memoryOrdersToGenerate(
-      features.hasAcquireReleaseAtomics()
-        ? std::initializer_list<MemoryOrder>{MemoryOrder::Unordered,
-                                             MemoryOrder::AcqRel,
-                                             MemoryOrder::SeqCst}
-        : std::initializer_list<MemoryOrder>{MemoryOrder::Unordered,
-                                             MemoryOrder::SeqCst});
+    std::vector<MemoryOrder> memoryOrdersToGenerate{MemoryOrder::Unordered,
+                                                    MemoryOrder::SeqCst};
+    if (features.hasRelaxedAtomics()) {
+      memoryOrdersToGenerate.push_back(MemoryOrder::Relaxed);
+    }
+    if (features.hasAcquireReleaseAtomics()) {
+      memoryOrdersToGenerate.push_back(MemoryOrder::AcqRel);
+    }
     for (Type type : {Type::i32, Type::i64, Type::f32, Type::f64, Type::v128}) {
       if (type == Type::v128 && !features.hasSIMD()) {
         continue;

src/wasm-binary.h

@@ -1235,6 +1235,7 @@ enum ASTNodes {
 
   OrderSeqCst = 0x0,
   OrderAcqRel = 0x1,
+  OrderRelaxed = 0x2,
   StructAtomicGet = 0x5c,
   StructAtomicGetS = 0x5d,
   StructAtomicGetU = 0x5e,