Replace isAtomic field with MemoryOrder enum in Load (#8170)

Supplement to #8169. We're adding a MemoryOrder field in Loads (as well
as other memory accesses) to support relaxed atomics in #8165. Only
touching loads here to get feedback before handling the remaining memory
operations.

Author: stevenfontanella

src/binaryen-c.cpp

@@ -2633,12 +2633,14 @@ void BinaryenMemoryGrowSetDelta(BinaryenExpressionRef expr,
 bool BinaryenLoadIsAtomic(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Load>());
-  return static_cast<Load*>(expression)->isAtomic;
+  return static_cast<Load*>(expression)->isAtomic();
 }
+
 void BinaryenLoadSetAtomic(BinaryenExpressionRef expr, bool isAtomic) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Load>());
-  static_cast<Load*>(expression)->isAtomic = isAtomic != 0;
+  static_cast<Load*>(expression)->order =
+    isAtomic ? MemoryOrder::SeqCst : MemoryOrder::Unordered;
 }
 bool BinaryenLoadIsSigned(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;

src/ir/cost.h

@@ -101,7 +101,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
   CostType visitGlobalGet(GlobalGet* curr) { return 1; }
   CostType visitGlobalSet(GlobalSet* curr) { return 2 + visit(curr->value); }
   CostType visitLoad(Load* curr) {
-    return 1 + visit(curr->ptr) + AtomicCost * curr->isAtomic;
+    return 1 + visit(curr->ptr) + AtomicCost * curr->isAtomic();
   }
   CostType visitStore(Store* curr) {
     return 2 + visit(curr->ptr) + visit(curr->value) +

src/ir/effects.h

@@ -598,7 +598,7 @@ class EffectAnalyzer {
     }
     void visitLoad(Load* curr) {
       parent.readsMemory = true;
-      parent.isAtomic |= curr->isAtomic;
+      parent.isAtomic |= curr->isAtomic();
       parent.implicitTrap = true;
     }
     void visitStore(Store* curr) {

src/ir/load-utils.h

@@ -33,7 +33,7 @@ inline bool isSignRelevant(Load* load) {
 }
 
 // check if a load can be signed (which some opts want to do)
-inline bool canBeSigned(Load* load) { return !load->isAtomic; }
+inline bool canBeSigned(Load* load) { return !load->isAtomic(); }
 
 } // namespace wasm::LoadUtils
 

src/ir/properties.h

@@ -502,7 +502,7 @@ inline MemoryOrder getMemoryOrder(Expression* curr) {
     return set->order;
   }
   if (auto* load = curr->dynCast<Load>()) {
-    return load->isAtomic ? MemoryOrder::SeqCst : MemoryOrder::Unordered;
+    return load->order;
   }
   if (auto* store = curr->dynCast<Store>()) {
     return store->isAtomic ? MemoryOrder::SeqCst : MemoryOrder::Unordered;

src/passes/I64ToI32Lowering.cpp

@@ -414,7 +414,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> {
     if (curr->type != Type::i64) {
       return;
     }
-    assert(!curr->isAtomic && "64-bit atomic load not implemented");
+    assert(!curr->isAtomic() && "64-bit atomic load not implemented");
     TempVar lowBits = getTemp();
     TempVar highBits = getTemp();
     TempVar ptrTemp = getTemp();

src/passes/OptimizeInstructions.cpp

@@ -1049,7 +1049,7 @@ struct OptimizeInstructions
         // extend operation.
         bool willBeSigned = curr->op == ExtendSInt32 && load->bytes == 4;
         if (!(curr->op == ExtendUInt32 && load->bytes <= 2 && load->signed_) &&
-            !(willBeSigned && load->isAtomic)) {
+            !(willBeSigned && load->isAtomic())) {
           if (willBeSigned) {
             load->signed_ = true;
           }
@@ -1092,7 +1092,7 @@ struct OptimizeInstructions
       // i32.reinterpret_f32(f32.load(x))  =>  i32.load(x)
       // i64.reinterpret_f64(f64.load(x))  =>  i64.load(x)
       if (auto* load = curr->value->dynCast<Load>()) {
-        if (!load->isAtomic && load->bytes == curr->type.getByteSize()) {
+        if (!load->isAtomic() && load->bytes == curr->type.getByteSize()) {
           load->type = curr->type;
           return replaceCurrent(load);
         }

src/passes/PickLoadSigns.cpp

@@ -120,7 +120,7 @@ struct PickLoadSigns : public WalkerPass<ExpressionStackWalker<PickLoadSigns>> {
         continue;
       }
       // Atomic operations are always unsigned, never signed.
-      if (load->isAtomic) {
+      if (load->isAtomic()) {
         continue;
       }
       // we can pick the optimal one. our hope is to remove 2 items per

src/passes/Print.cpp

@@ -549,7 +549,7 @@ struct PrintExpressionContents
   }
   void visitLoad(Load* curr) {
     prepareColor(o) << forceConcrete(curr->type, curr->align);
-    if (curr->isAtomic) {
+    if (curr->isAtomic()) {
       o << ".atomic";
     }
     o << ".load";

src/passes/SafeHeap.cpp

@@ -43,7 +43,7 @@ static Name getLoadName(Load* curr) {
   if (LoadUtils::isSignRelevant(curr) && !curr->signed_) {
     ret += "U_";
   }
-  if (curr->isAtomic) {
+  if (curr->isAtomic()) {
     ret += "A";
   } else {
     ret += std::to_string(curr->align);
@@ -233,7 +233,8 @@ struct SafeHeap : public Pass {
               continue;
             }
             for (auto isAtomic : {true, false}) {
-              load.isAtomic = isAtomic;
+              load.order =
+                isAtomic ? MemoryOrder::SeqCst : MemoryOrder::Unordered;
               if (isAtomic &&
                   !isPossibleAtomicOperation(
                     align, bytes, module->memories[0]->shared, type)) {
@@ -321,7 +322,7 @@ struct SafeHeap : public Pass {
     *load = style; // basically the same as the template we are given!
     load->ptr = builder.makeLocalGet(2, addressType);
     Expression* last = load;
-    if (load->isAtomic && load->signed_) {
+    if (load->isAtomic() && load->signed_) {
       // atomic loads cannot be signed, manually sign it
       last = Bits::makeSignExt(load, load->bytes, *module);
       load->signed_ = false;