Always use LaneResults for SIMD values in spec tests (#8434)

For use in #8421. Previously LaneResults was only used if the expected
v128 constant contained NaN patterns, which meant that we lose the shape
information (otherwise they were stored/matched as a normal v128
Literal). Change the parser to always use LaneResult so that we keep the
shape information and can output exactly which lane doesn't match during
test failures.

Error message before:

```
expected i32x4 0x56485649 0x56485648 0x56485648 0x56485648, got i32x4 0x56485648 0x56485648 0x56485648 0x56485648
```

Error message after:

```
expected 22089, got 22088 at lane 0
```

Part of #8261 and #8315.

Author: stevenfontanella

src/parser/lexer.cpp

@@ -935,6 +935,15 @@ void Lexer::skipSpace() {
   }
 }
 
+std::optional<char> Lexer::peekChar() const {
+  auto n = next();
+  if (n.empty()) {
+    return std::nullopt;
+  }
+
+  return n[0];
+}
+
 bool Lexer::takeLParen() {
   if (LexCtx(next()).startsWith("("sv)) {
     ++pos;

src/parser/lexer.h

@@ -78,6 +78,8 @@ struct Lexer {
     advance();
   }
 
+  std::optional<char> peekChar() const;
+
   bool takeLParen();
 
   bool peekLParen() { return Lexer(*this).takeLParen(); }

src/parser/wast-parser.cpp

@@ -169,38 +169,63 @@ Result<NaNKind> nan(Lexer& in) {
 }
 
 Result<ExpectedResult> result(Lexer& in) {
-  Lexer constLexer = in;
-  auto c = const_(constLexer);
-  // TODO: Generating and discarding errors like this can lead to quadratic
-  // behavior. Optimize this if necessary.
-  if (!c.getErr()) {
-    in = constLexer;
-    return *c;
-  }
-
-  // If we failed to parse a constant, we must have either a nan pattern or a
-  // reference.
-  if (in.takeSExprStart("f32.const"sv)) {
-    auto kind = nan(in);
-    CHECK_ERR(kind);
-    if (!in.takeRParen()) {
-      return in.err("expected end of f32.const");
+  if (in.takeSExprStart("v128.const"sv)) {
+    auto laneTypeChar = in.peekChar();
+    if (!laneTypeChar) {
+      return in.err("expected vector shape");
     }
-    return NaNResult{*kind, Type::f32};
-  }
 
-  if (in.takeSExprStart("f64.const"sv)) {
-    auto kind = nan(in);
-    CHECK_ERR(kind);
-    if (!in.takeRParen()) {
-      return in.err("expected end of f64.const");
+    LaneResults::LaneType laneType;
+    switch (*laneTypeChar) {
+      case 'f': {
+        laneType = LaneResults::LaneType::Float;
+        break;
+      }
+      case 'i': {
+        laneType = LaneResults::LaneType::Int;
+        break;
+      }
+      default: {
+        return in.err("expected vector shape");
+      }
     }
-    return NaNResult{*kind, Type::f64};
-  }
 
-  if (in.takeSExprStart("v128.const"sv)) {
-    LaneResults lanes;
-    if (in.takeKeyword("f32x4"sv)) {
+    LaneResults results(laneType);
+    auto& lanes = results.lanes;
+
+    if (in.takeKeyword("i8x16"sv)) {
+      for (int i = 0; i < 16; ++i) {
+        auto int_ = in.takeI8();
+        if (!int_) {
+          return in.err("expected i8 immediate");
+        }
+        lanes.push_back(Literal(static_cast<uint32_t>(*int_)));
+      }
+    } else if (in.takeKeyword("i16x8"sv)) {
+      for (int i = 0; i < 8; ++i) {
+        auto int_ = in.takeI16();
+        if (!int_) {
+          return in.err("expected i16 immediate");
+        }
+        lanes.push_back(Literal(static_cast<uint32_t>(*int_)));
+      }
+    } else if (in.takeKeyword("i32x4"sv)) {
+      for (int i = 0; i < 4; ++i) {
+        auto int_ = in.takeI32();
+        if (!int_) {
+          return in.err("expected i32 immediate");
+        }
+        lanes.push_back(Literal(static_cast<uint32_t>(*int_)));
+      }
+    } else if (in.takeKeyword("i64x2"sv)) {
+      for (int i = 0; i < 2; ++i) {
+        auto int_ = in.takeI64();
+        if (!int_) {
+          return in.err("expected i64 immediate");
+        }
+        lanes.push_back(Literal(*int_));
+      }
+    } else if (in.takeKeyword("f32x4"sv)) {
       for (int i = 0; i < 4; ++i) {
         if (auto f = in.takeF32()) {
           lanes.push_back(Literal(*f));
@@ -226,7 +251,36 @@ Result<ExpectedResult> result(Lexer& in) {
     if (!in.takeRParen()) {
       return in.err("expected end of v128.const");
     }
-    return lanes;
+    return results;
+  }
+
+  Lexer constLexer = in;
+  auto c = const_(constLexer);
+  // TODO: Generating and discarding errors like this can lead to quadratic
+  // behavior. Optimize this if necessary.
+  if (!c.getErr()) {
+    in = constLexer;
+    return *c;
+  }
+
+  // If we failed to parse a constant, we must have either a nan pattern or a
+  // reference.
+  if (in.takeSExprStart("f32.const"sv)) {
+    auto kind = nan(in);
+    CHECK_ERR(kind);
+    if (!in.takeRParen()) {
+      return in.err("expected end of f32.const");
+    }
+    return NaNResult{*kind, Type::f32};
+  }
+
+  if (in.takeSExprStart("f64.const"sv)) {
+    auto kind = nan(in);
+    CHECK_ERR(kind);
+    if (!in.takeRParen()) {
+      return in.err("expected end of f64.const");
+    }
+    return NaNResult{*kind, Type::f64};
   }
 
   if (in.takeSExprStart("ref.null")) {

src/parser/wat-parser.h

@@ -74,7 +74,17 @@ struct NaNResult {
 
 using LaneResult = std::variant<Literal, NaNResult>;
 
-using LaneResults = std::vector<LaneResult>;
+struct LaneResults {
+  enum class LaneType {
+    Int,
+    Float,
+  };
+  LaneResults(LaneType type, std::vector<LaneResult> lanes = {})
+    : type(type), lanes(std::move(lanes)) {}
+
+  LaneType type;
+  std::vector<LaneResult> lanes;
+};
 
 using ExpectedResult =
   std::variant<Literal, NullRefResult, RefResult, NaNResult, LaneResults>;

src/tools/wasm-shell.cpp

@@ -400,28 +400,44 @@ struct Shell {
           err << e->msg << atIndex();
           return Err{err.str()};
         }
-      } else if (auto* lanes = std::get_if<LaneResults>(&expected)) {
+      } else if (auto* l = std::get_if<LaneResults>(&expected)) {
+        auto* lanes = &l->lanes;
+
+        auto check = [&](const auto& vals) -> Result<> {
+          for (size_t i = 0; i < vals.size(); ++i) {
+            auto check = checkLane(vals[i], (*lanes)[i], i);
+            if (auto* e = check.getErr()) {
+              err << e->msg << atIndex();
+              return Err{err.str()};
+            }
+          }
+          return Ok{};
+        };
+
+        bool isFloat = l->type == WATParser::LaneResults::LaneType::Float;
         switch (lanes->size()) {
+          // Use unsigned values for the smaller types here to avoid sign
+          // extension when storing 8/16-bit values in 32-bit ints. This isn't
+          // needed for i32 and i64.
+          case 16: {
+            // There is no f8.
+            assert(!isFloat && "float8 does not exist");
+            CHECK_ERR(check(val.getLanesUI8x16()));
+            break;
+          }
+          case 8: {
+            CHECK_ERR(
+              check(isFloat ? val.getLanesF16x8() : val.getLanesUI16x8()));
+            break;
+          }
           case 4: {
-            auto vals = val.getLanesF32x4();
-            for (Index i = 0; i < 4; ++i) {
-              auto check = checkLane(vals[i], (*lanes)[i], i);
-              if (auto* e = check.getErr()) {
-                err << e->msg << atIndex();
-                return Err{err.str()};
-              }
-            }
+            CHECK_ERR(
+              check(isFloat ? val.getLanesF32x4() : val.getLanesI32x4()));
             break;
           }
           case 2: {
-            auto vals = val.getLanesF64x2();
-            for (Index i = 0; i < 2; ++i) {
-              auto check = checkLane(vals[i], (*lanes)[i], i);
-              if (auto* e = check.getErr()) {
-                err << e->msg << atIndex();
-                return Err{err.str()};
-              }
-            }
+            CHECK_ERR(
+              check(isFloat ? val.getLanesF64x2() : val.getLanesI64x2()));
             break;
           }
           default: