Merge branch 'feat/ts-core' into feat/ts-globals

Author: chharvey

scripts/fuzz_opt.py

@@ -864,9 +864,11 @@ def can_run(self, wasm):
 
     @override
     def can_compare_to_self(self):
-        # With nans, VM differences can confuse us, so only very simple VMs
-        # can compare to themselves after opts in that case.
-        return not NANS
+        # With nans or relaxed SIMD, VM differences can confuse us, including
+        # differences between binaryen and V8 (binaryen's behavior can get
+        # "baked" into the wasm when it precomputes code, so we cannot compare
+        # V8's output before binaryen opts and after binaryen opts).
+        return not NANS and all_disallowed(['relaxed-simd'])
 
     @override
     def can_compare_to_other(self, other):
@@ -919,7 +921,7 @@ def can_run(self, wasm):
         if random.random() < 0.5:
             return False
         # wasm2c doesn't support most features
-        return all_disallowed(['exception-handling', 'simd', 'threads', 'bulk-memory', 'nontrapping-float-to-int', 'tail-call', 'sign-ext', 'reference-types', 'multivalue', 'gc', 'custom-descriptors', 'relaxed-atomics', 'wide-arithmetic'])
+        return all_disallowed(['exception-handling', 'simd', 'threads', 'bulk-memory', 'nontrapping-float-to-int', 'tail-call', 'sign-ext', 'reference-types', 'multivalue', 'gc', 'custom-descriptors', 'acquire-release-atomics', 'wide-arithmetic'])
 
     @override
     def run(self, wasm):
@@ -1250,7 +1252,7 @@ def can_run_on_wasm(self, wasm):
         # implement wasm suspending using JS async/await.
         if JSPI:
             return False
-        return all_disallowed(['exception-handling', 'simd', 'threads', 'bulk-memory', 'nontrapping-float-to-int', 'tail-call', 'sign-ext', 'reference-types', 'multivalue', 'gc', 'multimemory', 'memory64', 'custom-descriptors', 'relaxed-atomics', 'wide-arithmetic'])
+        return all_disallowed(['exception-handling', 'simd', 'threads', 'bulk-memory', 'nontrapping-float-to-int', 'tail-call', 'sign-ext', 'reference-types', 'multivalue', 'gc', 'multimemory', 'memory64', 'custom-descriptors', 'acquire-release-atomics', 'wide-arithmetic'])
 
 
 # Returns the wat for a wasm file. If it is already wat, it just returns that
@@ -2048,10 +2050,11 @@ def handle(self, wasm):
         compare(output, optimized_output, 'Two-Opt')
 
         # If we can, also test in V8. We also cannot compare if there are NaNs
-        # (as optimizations can lead to different outputs), and we must
-        # disallow some features.
+        # or relaxed SIMD (as binaryen optimizations can lead to different
+        # outputs from V8), and we must disallow features that don't even work
+        # in V8.
         # TODO: relax some of these
-        if NANS or not all_disallowed(DISALLOWED_FEATURES_IN_V8):
+        if NANS or not all_disallowed(['relaxed-simd']) or not all_disallowed(DISALLOWED_FEATURES_IN_V8):
             return
 
         output = run_d8_wasm(wasm, args=[second_wasm])

scripts/test/generate_atomic_spec_test.py

@@ -224,7 +224,7 @@ def bin_statement_lines(template: Template, mem_idx: int, mem_ptr_type: ValueTyp
 
     has_ordering = ordering is not None
     has_mem_idx = mem_idx is not None
-    raw_alignment = int(math.log2(mem_ptr_type.value // 8))
+    raw_alignment = int(math.log2(template.value_type.value // 8))
     alignment = raw_alignment | (has_ordering << 4) | (has_mem_idx << 6)
     comment = f"Alignment of {raw_alignment}" \
               f'{" with bit 4 set indicating that an ordering immediate follows" if has_ordering else ""}' \

src/binaryen-c.cpp

@@ -505,8 +505,8 @@ BinaryenFeatures BinaryenFeatureBulkMemoryOpt(void) {
 BinaryenFeatures BinaryenFeatureCallIndirectOverlong(void) {
   return static_cast<BinaryenFeatures>(FeatureSet::CallIndirectOverlong);
 }
-BinaryenFeatures BinaryenFeatureRelaxedAtomics(void) {
-  return static_cast<BinaryenFeatures>(FeatureSet::RelaxedAtomics);
+BinaryenFeatures BinaryenFeatureAcquireReleaseAtomics(void) {
+  return static_cast<BinaryenFeatures>(FeatureSet::AcquireReleaseAtomics);
 }
 BinaryenFeatures BinaryenFeatureMultibyte(void) {
   return static_cast<BinaryenFeatures>(FeatureSet::Multibyte);

src/binaryen-c.h

@@ -245,7 +245,7 @@ BINARYEN_API BinaryenFeatures BinaryenFeatureSharedEverything(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureFP16(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureBulkMemoryOpt(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureCallIndirectOverlong(void);
-BINARYEN_API BinaryenFeatures BinaryenFeatureRelaxedAtomics(void);
+BINARYEN_API BinaryenFeatures BinaryenFeatureAcquireReleaseAtomics(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureMultibyte(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureCustomPageSizes(void);
 BINARYEN_API BinaryenFeatures BinaryenFeatureWideArithmetic(void);

src/cfg/Relooper.cpp

@@ -333,7 +333,6 @@ wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
     auto Base = std::string("switch$") + std::to_string(Id);
     auto SwitchDefault = wasm::Name(Base + "$default");
     auto SwitchLeave = wasm::Name(Base + "$leave");
-    std::map<Block*, wasm::Name> BlockNameMap;
     auto* Outer = Builder.makeBlock();
     auto* Inner = Outer;
     std::vector<wasm::Name> Table;

src/compiler-support.h

@@ -31,4 +31,10 @@
 #define WASM_BUILTIN_UNREACHABLE __assume(false)
 #endif
 
+#if defined(__GNUC__) || defined(__clang__)
+#define BYN_WARN_UNUSED [[gnu::warn_unused]]
+#else
+#define BYN_WARN_UNUSED
+#endif
+
 #endif // wasm_compiler_support_h

src/ir/constraint.cpp

@@ -265,11 +265,17 @@ std::optional<Constraint> approximateOrTermEqualPair(const Abstract::Op aOp,
   if (aOp == Eq && bOp == GtS) {
     return Constraint{GeS, term};
   }
+  if (aOp == Eq && bOp == GtU) {
+    return Constraint{GeU, term};
+  }
 
   // x > C || x >= C  ===  x >= C
   if (aOp == GtS && bOp == GeS) {
     return Constraint{GeS, term};
   }
+  if (aOp == GtU && bOp == GeU) {
+    return Constraint{GeU, term};
+  }
 
   // TODO: all the rest
 
@@ -286,11 +292,17 @@ std::optional<Constraint> approximateOrAdjacentConstantPair(
   if (aOp == Eq && bOp == GeS && !aConstant.isSignedMax()) {
     return Constraint{GeS, {aConstant}};
   }
+  if (aOp == Eq && bOp == GeU && !aConstant.isUnsignedMax()) {
+    return Constraint{GeU, {aConstant}};
+  }
 
   // x > C || x >= C+1  ===  x > C, if C+1 does not overflow.
   if (aOp == GtS && bOp == GeS && !aConstant.isSignedMax()) {
     return Constraint{GtS, {aConstant}};
   }
+  if (aOp == GtU && bOp == GeU && !aConstant.isUnsignedMax()) {
+    return Constraint{GtU, {aConstant}};
+  }
 
   // TODO: all the rest
 
@@ -494,15 +506,110 @@ void LocalConstraint::flip() {
 }
 
 void BasicBlockConstraintMap::set(Index index, const Constraint& c) {
+  set(index, AndedConstraintSet{c});
+}
+
+void BasicBlockConstraintMap::set(Index index,
+                                  const AndedConstraintSet& constraints) {
   // We should not set values in unreachable code.
   assert(!unreachable);
 
   // Clear the old state.
   eraseStaleRefs(index);
   map.erase(index);
 
-  // Apply the constraint.
-  approximateAnd(index, c);
+  // Apply the constraints, if there are any.
+  if (constraints.provesNothing()) {
+    setProvesNothing(index);
+  } else {
+    for (auto& c : constraints) {
+      approximateAnd(index, c);
+    }
+  }
+}
+
+void BasicBlockConstraintMap::set(Index index, Expression* value) {
+  using namespace Match;
+  using namespace Abstract;
+
+  // Apply a constraint to a value, x = C.
+  if (Properties::isSingleConstantExpression(value)) {
+    auto c = Properties::getLiteral(value);
+    set(index, Constraint{Abstract::Eq, {c}});
+    return;
+  }
+
+  // Apply a constraint to a local, x = y.
+  if (auto* get = value->dynCast<LocalGet>()) {
+    set(index, Constraint{Abstract::Eq, {get->index}});
+    return;
+  }
+
+  // Apply an increment of a local, x = y + 1.
+  Index y;
+  if (matches(value, binary(Abstract::Add, local(&y), ival(1)))) {
+    // The local y must have old constraints that we know how to increment.
+    auto old = get(y);
+
+    // Iterate over the old constraints and increment each one.
+    auto success = true;
+    for (auto& c : old) {
+      auto* N = std::get_if<Literal>(&c.term);
+      if (!N) {
+        // A non-constant term, which we don't know how to increment.
+        success = false;
+        break;
+      }
+
+      switch (c.op) {
+        // x == N, x++  =>  x == N+1.
+        case Eq:
+          *N = N->add(Literal::makeFromInt32(1, N->type));
+          continue;
+        // x >= N, x++  =>  x > N
+        case GeS:
+          c.op = GtS;
+          continue;
+        case GeU:
+          c.op = GtU;
+          continue;
+        // x < N, x++  =>  x <= N
+        case LtS:
+          c.op = LeS;
+          continue;
+        case LtU:
+          c.op = LeU;
+          continue;
+        // x <= N, x++ => x <= N+1 if no overflow
+        case LeS:
+          if (N->isSignedMax()) {
+            success = false;
+            break;
+          }
+          *N = N->add(Literal::makeFromInt32(1, N->type));
+          continue;
+        case LeU:
+          if (N->isUnsignedMax()) {
+            success = false;
+            break;
+          }
+          *N = N->add(Literal::makeFromInt32(1, N->type));
+          continue;
+        default:
+          // Something we don't recognize.
+          success = false;
+          break;
+      }
+    }
+
+    if (success) {
+      set(index, old);
+      return;
+    }
+  }
+
+  // We know and can prove nothing.
+  setProvesNothing(index);
 }
 
 void BasicBlockConstraintMap::setProvesNothing(Index index) {

src/ir/constraint.h

@@ -251,9 +251,15 @@ struct BasicBlockConstraintMap {
     assert(map.empty());
   }
 
-  // Apply a constraint to a local.
+  // Apply a constraint to a local, replacing anything before.
   void set(Index index, const Constraint& c);
 
+  // Apply a set of constraints to a local, replacing anything before.
+  void set(Index index, const AndedConstraintSet& constraints);
+
+  // Set the value in an expression to a local, replacing anything before.
+  void set(Index index, Expression* value);
+
   // Mark a local as unknown and able to prove nothing.
   void setProvesNothing(Index index);
 

src/ir/effects.h

@@ -1044,10 +1044,8 @@ class EffectAnalyzer {
     }
     void visitRefGetDesc(RefGetDesc* curr) { trapOnNull(curr->ref); }
     void visitBrOn(BrOn* curr) {
-      if (trapOnNull(curr->desc)) {
-        return;
-      }
       parent.breakTargets.insert(curr->name);
+      trapOnNull(curr->desc);
     }
     void visitStructNew(StructNew* curr) { trapOnNull(curr->desc); }
     void visitStructGet(StructGet* curr) {

src/ir/features.h

@@ -173,7 +173,8 @@ inline FeatureSet get(BinaryOp op) {
     case RelaxedMinVecF64x2:
     case RelaxedMaxVecF64x2:
     case RelaxedSwizzleVecI8x16:
-    case RelaxedQ15MulrSVecI16x8: {
+    case RelaxedQ15MulrSVecI16x8:
+    case RelaxedDotI8x16I7x16SToVecI16x8: {
       ret.setSIMD();
       ret.setRelaxedSIMD();
       break;